用C语言编写一个动态链条，能删除、插入并且按大、小顺序排列
#include<stdio.h>
#include <stdlib.h>
#include <math.h>
#define ElemType int
#define Status int
#define TRUE 1
#define OK 1
#define FALSE 0
#define ERROR -1
typedef struct LNode
{
ElemType data
struct LNode *next
}LNode, *LinkList
void InitList(LinkList *L)
{
*L=(LinkList)malloc(sizeof(struct LNode))
if(!*L)
exit(OVERFLOW)
(*L)->next=NULL
}
void DestroyList(LinkList *L)
{
LinkList q
while(*L)
{
q=(*L)->next
free(*L)
*L=q
}
}
void ClearList(LinkList L)
{
LinkList p,q
p=L->next
while(p)
{
q=p->next
free(p)
p=q
}
L->next=NULL
}
Status ListEmpty(LinkList L)
{
if(L->next)
return FALSE
else
return TRUE
}
int ListLength(LinkList L)
{
int i=0
LinkList p=L->next
while(p)
{
i++
p=p->next
}
return i
}
Status GetElem(LinkList L,int i,ElemType *e)
{
int j=1
LinkList p=L->next
while(p&&j <i)
{
p=p->next
j++
}
if(!p||j>i)
return ERROR
*e=p->data
return OK
}
int LocateElem(LinkList L,ElemType e,Status(*compare)(ElemType,ElemType))
{
int i=0
LinkList p=L->next
while(p)
{
i++
if(compare(p->data,e))
return i
p=p->next
}
return 0
}
Status PriorElem(LinkList L,ElemType cur_e,ElemType *pre_e)
{
LinkList q,p=L->next
while(p->next)
{
q=p->next
if(q->data==cur_e)
{
*pre_e=p->data
return OK
}
p=q
}
return ERROR
}
Status NextElem(LinkList L,ElemType cur_e,ElemType *next_e)
{
LinkList p=L->next
while(p->next)
{
if(p->data==cur_e)
{
*next_e=p->next->data
return OK
}
p=p->next
}
return ERROR
}
Status ListInsert(LinkList L,int i,ElemType e)
{
int j=0
LinkList p=L,s
while(p&&j <i-1)
{
p=p->next
j++
}
if(!p||j>i-1)
return ERROR
s=(LinkList)malloc(sizeof(struct LNode))
s->data=e
s->next=p->next
p->next=s
return OK
}
Status ListDelete(LinkList L,int i,ElemType *e)
{
int j=0
LinkList p=L,q
while(p->next&&j<i-1)
{
p=p->next
j++
}
if(!p->next||j>i-1)
return ERROR
q=p->next
p->next=q->next
*e=q->data
free(q)
return OK
}
void ListTraverse(LinkList L,void(*vi)(ElemType))
{
LinkList p=L->next
while(p)
{
vi(p->data)
p=p->next
}
printf("\n")
}
void ListPrint(LinkList L)
{
LinkList p=L->next
while(p)
{
printf("%d ", p->data)
p = p->next
}
printf("\n")
}
void ListSort(LinkList L)
{
LinkList first
LinkList t
LinkList p
LinkList q
first = L->next
L->next = NULL
while (first != NULL)
{
for (t = first, q = L((q!=NULL) &&(q->data <t->data))p=q, q=q->next)
first = first->next
if (q == L) L = t
else p->next = t
t->next = q
}
}
void main()
{
LinkList L
int e
InitList(&L)
ListInsert(L, 1, 2)
ListInsert(L, 1, 3)
ListInsert(L, 1, 67)
ListInsert(L, 1, 6)
ListInsert(L, 1, 5)
ListDelete(L, 2, &e)
ListSort(L)
ListPrint(L)
}
链条没听说过，链表但是知道。
其实是一种数据结构，常用的结构还有栈(汇编必学)，队列，和树(这种结构对于提高效率相当有用。)
如果是初学就不要想这些了，老实地把基础打好，可以地话，认真越好你的数学，，真正的计算机大牛还是强在算法，结构，思想，设计上。而且越学你会发现自己知道的越少。C语言是一种极端，然而lisp是另一种极端，我现在才开始接触函数式编程这东东，才知道思想无止境啊。
那么在编程时，可以用一个变量保存栈元素的个数。栈是否满，取决于申请动态内存时的返回值，如
Stack *p = (Stack *)malloc(sizeof(Stack))；，若（p == NULL），则栈满。
q->next = p表示将节点p加入到节点q之后。
意思：使当前指针指向链表的下一个结点。
一般作用在数据结构中的单链表里由应用，语句中的p一般指向一个结构体类型的数据，此类型的数据通常表示节点；结构体里存放的一些数据和记录下一个节点地址的指针变量next；这个next就好比链条一样，连接着一个个节点。
－＞是一个整体，它是用于指向结构体、C＋＋中的class等含有子数据的指针用来取子数据。换种说法，如果在C语言中定义了一个结构体，然后申明一个指针指向这个结构体，那么要用指针取出结构体中的数据，就要用到“－＞”．
扩展资料
链表的特点：
1、n个节点离散分配
2、每一个节点之间通过指针相连
3、每一个节点有一个前驱节点和一个后继节点
4、首节点没有前驱节点，尾节点没有后继节点
创建链表前须知
首节点：存放第一个有效数据的节点。
头节点：在单链表的第一个结点之前附设一个结点，它没有直接前驱，称之为头结点，头结点的数据域可以不存储任何信息，指针域指向第一个节点（首节点）的地址。头结点的作用是使所有链表（包括空表）的头指针非空。
头指针：指向头节点的指针。
尾节点：存放最后一个有效数据的节点。
尾指针：指向尾节点的指针。
参考资料来源：
百度百科——链表
链表开始是一个“头指针”，定义了链表开始的位置，下面是像链条一样的一串节点，每个节点包含数据部分和指针部分。前一节点的指针指向后一节点，最后一个节点是数据和空地址，表示结束。
好处在于空间是动态分配的，需要多长可以一直链下去。
唯一的区别就是剩下的n-1颗珠子一共可以排出多少种组合，也就是(n-1)! 种组合。
一般这种情况可以写成n! / n ,这样就不用吧n=1这种特殊情况单独拿出来处理了。
c语言写法就是：
#include<stdio.h>
int main()
{
int n = 10//10就是珠子个数
int i= 0；
int ret = n
for(i = n i >1 i--)
{
ret = ret * (i - 1)
}
ret = ret / n //就算n=1，前面的for循环进不去，这儿最终的结果也不会错。
printf("所有的可能一共有%d种\n", ret)
return 0
}
整形，可以理解为整数
字符型 可以理解为单个字符，如字符‘a','b','1'等
浮点型 可以理解为小数
2.型数据类型：
struct 可以理解为把不同的数据类型放在一起组成一个新的有意义：说到一说起人，你就会想到人具有身高，性别，年龄等属性，人就是由身高，性别，年龄等放在一起构造的数据类型
struct person{
double shenggao
char [] xingbie
intnianling
}
3.class(类)
在struct的基础上加了对数据的操作，还有对数据访问权限的设置，还有对数据操作方法间得一些规定，设置，比如继承等
4.数据结构和算法
这个要一本书专门学习，有链表，树，图等
