线性表的链式存储（单链表）的c语言实现

#include <stdio.h>
#include <stdlib.h>
//线性表的链式存储结构
#define OK 1
#define ERROR -1
typedef int ElemType;
typedef int Status;
//定义了线性表的链式存储结构
typedef struct{
ElemType data;
struct Node *next;
}Node,*List;

//定义单链表的基本操作
//本程序中设定每个单链表都有一个头结点,末尾都指向NULL

//1. 单链表的初始化
Status InitList(List *L){
*L=(List)malloc(sizeof(Node));//*L指向一个结点的存储空间
(*L)->data=1;
(*L)->next=NULL;
return OK;
}

//2. 单链表的整表创建,依次从尾部插入结点;a(n)->a(n-1)->...->a(1)
Status CreateTailList(List *L){
int i,n;
List t;//新建临时结点
printf("输入要创建的单链表的结点的个数，n=\n");
scanf("%d",&n);

//初始化随机数种子,准备产生随机数，依赖<string.h>头文件
srand(time(0));
for(i=0;i<n;i++){

//
t=(List)malloc(sizeof(Node));
t->data=rand()%100+1;//产生1~100的随机数
t->next=(*L)->next;//指向L的尾部
(*L)->next=t;
}
return OK;

}
//3. 单链表的整表创建，依次从头部插入，即顺序插入a(1)->a(2)->...->a(n)
Status CreateHeadList(List *L){
int i,n;
List t,p;//新建临时结点
printf("输入要创建的单链表的结点的个数，n=\n");
scanf("%d",&n);

//初始化随机数种子,准备产生随机数，依赖<string.h>头文件
srand(time(0));
p=*L;
for(i=0;i<n;i++){

//
t=(List)malloc(sizeof(Node));
t->data=rand()%100+1;//产生1~100的随机数
p->next=t;
p=t;
}
p->next=NULL;
return OK;

}

//4. 获取链表长度

int GetLEN(List L){
//为什么传入的参数不用带指针呢？因为取长度操作不必对链表本身进行操作；
//当所进行的操作会影响到原来的链表时，带上指针！
//个人总结的一点规律
int length;
length=0;

//p=L->next;
while(L->next){
//头结点不计入长度
length++;
L=L->next;
}
//*len=length;
return length;

}
//4.单链表的插入操作
Status InsertNode(List *L,int i,ElemType e){

//在第i个结点处插入元素e;i可以从1~len+1
int j,len;
j=1;
List p,t;
p=*L;

len=GetLEN(p);
if(i>len+1 || i<1){
printf("\n请检查输入的i值是否超界!\n");
return ERROR;
}

//准备插入
while(j<i && p->next){
//将链表指针移到第i个结点
p=p->next;
j++;
}
//新建结点
t=(List)malloc(sizeof(Node));
t->data=e;
t->next=p->next;
p->next=t;
return OK;

}
//5. 单链表的删除结点
Status DeleteNode(List *L,int i){
//删除第i个结点
int j;
List p,t;
p=*L;
//先判断位置

if(!p || i<1 || i>GetLEN(p)){
printf("删除元素的位置超界！");
return ERROR;
}
j=1;
while(j<i && p->next){
p=p->next;
j++;
}
t=p->next;//指向第i个结点
p->next=t->next;
free(t);//让系统回收此结点，释放内存
return OK;
}

//单链表的元素获取
Status GetElem(List L,int i,ElemType *e){
//获取第i个结点的元素，将值传给e
if(i>GetLEN(L) || i<0){
return ERROR;
}
int j;
j=0;
while(j<i && L->next){
L=L->next;
j++;
}
*e=L->data;
return OK;
}

//单链表的整表删除,置空表
Status EmptyList(List *L){
List p,t;
p=(*L)->next;//指向第一个结点
while(p){
t=p->next;
free(p);
p=t;

}
(*L)->next=NULL;
return OK;
}

int main()
{
List L,t;

InitList(&L);
if(OK==CreateHeadList(&L)){
//输出初始化后的链表
//引入一个新的链表接收L，防止对L操作后影响对L的后续操作
//下面的代码如果while循环直接对L，即while(L),那么循环结束后，L指向的是NULL；进而影响对L的后续操作！

t=L->next;//指向第一个结点
while(t){
printf("%d\t",t->data);
t=t->next;
}
}

printf("当前链表长度为：%d\n",GetLEN(L));

printf("\n准备插入结点\n输入插入结点的位置及数值，用逗号分隔\n");
int n,e;
scanf("%d,%d",&n,&e);
if(OK==InsertNode(&L,n,e)){
printf("\n插入元素成功，新的链表为：\n");
t=L->next;//指向第一个结点
while(t){
printf("%d\t",t->data);
t=t->next;
}
printf("当前链表长度为：%d\n",GetLEN(L));

}else{
printf("\n插入失败\n");
}
printf("输入要删除的结点位置n=\n");
scanf("%d",&n);
if(OK==DeleteNode(&L,n)){
printf("删除成功");
t=L->next;//指向第一个结点
while(t){
printf("%d\t",t->data);
t=t->next;
}
printf("当前链表长度为：%d\n",GetLEN(L));

}else{
printf("\n删除失败\n");
}

printf("输入想要获取元素的位置i=\n");
scanf("%d",&n);
int data;
if(OK==GetElem(L,n,&data)){
printf("链表第%d个元素的值为%d\n",n,data);
}

if(OK==EmptyList(&L)){
printf("当前链表长度为：%d\n",GetLEN(L));
printf("链表为空！");
}else{
printf("链表置空失败！");
}

if(OK==CreateHeadList(&L)){
//输出初始化后的链表
//引入一个新的链表接收L，防止对L操作后影响对L的后续操作
//下面的代码如果while循环直接对L，即while(L),那么循环结束后，L指向的是NULL；进而影响对L的后续操作！

t=L->next;//指向第一个结点
while(t){
printf("%d\t",t->data);
t=t->next;
}
}

printf("当前链表长度为：%d\n",GetLEN(L));

return 0;
}