用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)
}
因为堆栈是链式栈，是否满栈取决于堆存储的大小。堆空间耗尽时，可以狭义地理解为栈满。
那么在编程时，可以用一个变量保存栈元素的个数。栈是否满，取决于申请动态内存时的返回值，如
Stack
*p
=
(Stack
*)malloc(sizeof(Stack))；，若（p
==
NULL），则栈满。
其实是一种数据结构，常用的结构还有栈(汇编必学)，队列，和树(这种结构对于提高效率相当有用。)
如果是初学就不要想这些了，老实地把基础打好，可以地话，认真越好你的数学，，真正的计算机大牛还是强在算法，结构，思想，设计上。而且越学你会发现自己知道的越少。C语言是一种极端，然而lisp是另一种极端，我现在才开始接触函数式编程这东东，才知道思想无止境啊。
链表开始是一个“头指针”，定义了链表开始的位置，下面是像链条一样的一串节点，每个节点包含数据部分和指针部分。前一节点的指针指向后一节点，最后一个节点是数据和空地址，表示结束。
好处在于空间是动态分配的，需要多长可以一直链下去。
