城市链表c语言

1. 如何用C语言创建一个链表，实现增、删、改、查

#include<stdio.h>
#include<string.h>
#include <malloc.h>
//先定义一种student类型,表示一个学生的信息，如下：
typedef struct student
{
int num; //表示学号
char name[30]; //表示姓名
float score; //表示分数
}student;
//定义一种NODE类型,表示一个结点信息，如下：
typedef struct node
{
student st; //表示一个学生的信息
struct node *next; //表示一个NODE类型的指针
}NODE;
//1、写出建立一个带头结点的线性链表的函数，其中每个结点包括学号、姓名、分数三个数据域。函数形式如下：
NODE *creat_link(int direction)
{
NODE *head,*p,*tail;
int xh,i=1;
if(direction==1) //当direction的值为1时，新建立的结点连到尾部
{
tail=head=(NODE *)malloc(sizeof(NODE));
head->next=NULL;
printf("请输入第%d个学生的学号：",i);
scanf("%d",&xh);
while(xh>0) //从键盘临时输入学生情况，当输入的学号非正，则链表建立完毕
{
p=(NODE *)malloc(sizeof(NODE));
p->st.num=xh;
printf("请输入第%d个学生的姓名：",i);
scanf("%s",p->st.name);
printf("请输入第%d个学生的成绩：",i);
scanf("%f",&p->st.score);
p->next=NULL;
tail->next=p;
tail=p;
i=i+1;
printf("请输入第%d个学生的学号：",i);
scanf("%d",&xh);
}
}
else if(direction==0) //当direction为0时，新建立的结点成为第一个结点
{
head=(NODE *)malloc(sizeof(NODE));
head->next=NULL;
printf("请输入第%d个学生的学号：",i);
scanf("%d",&xh);
while(xh>0) //从键盘临时输入学生情况，当输入的学号非正，则链表建立完毕
{
p=(NODE *)malloc(sizeof(NODE));
p->st.num=xh;
printf("请输入第%d个学生的姓名：",i);
scanf("%s",p->st.name);
printf("请输入第%d个学生的成绩：",i);
scanf("%f",&p->st.score);
p->next=head->next;
head->next=p;
i=i+1;
printf("请输入第%d个学生的学号：",i);
scanf("%d",&xh);
}
}
return head;
}
//2、写出输出上述链表各结点数据域值的函数。该函数对应的函数需要一个形参，表示链表的头指针，形式如下：
void print_link(NODE *head)
{
NODE *p;
p=head->next;
printf("%-10s%-20s%-10s\n","学号","姓名","分数");
while(p!=NULL)
{
printf("%-10d%-20s%-10.1f\n",p->st.num,p->st.name,p->st.score);
p=p->next;
}
//该函数能输出head所指的链表的所有结点值，输出形式如下：
/*本函数输出线性表sq中所有数据，形式如下：
学号 姓名 分数
12 张三 234.5
18 李四 987.7
……… ……… …….*/
}
//3、写出在链表中删除结点的函数
int del_link(NODE *head,char name[])
{
NODE *p,*p1;
p=head->next;
p1=head;
while(p!=NULL)
{
if(strcmp(p->st.name,name)!=0)
{
p1=p;
p=p->next;
}
else
{
break;
}
}
if(p!=NULL)
{
p1->next=p->next;
free(p);
return 1;
}
else
{
return 0;
}
//删除head所指的链表中，名字为name的结点，删除成功返回1，不成功返回0
}
//4、写出在链表中插入结点的算法
int insert(NODE *head,student x,int wz)
{
NODE *p=head;
int i=0,jg;
if(wz<=0)
{
jg=0;
}
else
{
while(i<wz-1&&p!=NULL)
{
i++;
p=p->next;
}
if(p==NULL)
{
jg=0;
}
if(i=wz-1)
{
//找到wz前面的节点，p指向它
NODE *q;
q=(NODE *)malloc(sizeof(NODE));
q->st.num=x.num;
strcpy(q->st.name,x.name);
q->st.score=x.score;
q->next=p->next;
p->next=q;
jg=1;
}
}
return jg;
//该函数能够在wz这个结点之前，插入一个新结点，新结点的数据域为x。插入成功返回1，不成功返回0。
}
//5、写出主函数，分别调用上面算法所对应的程序，建立链表，并输出链表的值。
void main()
{
NODE *head; //定义指针变量head
int wz; //表示插入位置
char xm[30];
student st; //定义一个变量st，用来表示一个学生的信息
head=creat_link(1);
print_link(head); //调用函数建立链表，并把返回值送给head;
//调用函数，输出链表中各个结点的值
//输入一个学生的有关信息，送给变量st的有关成员
printf("\n\n请输入要插入的位置：");
scanf("%d",&wz); //输入wz的值
printf("请输入要插入的学生的学号：");
scanf("%d",&st.num);
printf("请输入要插入的学生的姓名：");
scanf("%s",st.name);
printf("请输入要插入的学生的成绩：");
scanf("%f",&st.score);
//调用函数，在链表中把学生st的值作为一个结点插入,如果插入成功，输出新链表
if(insert(head,st,wz)==1)
{
printf("\n插入成功，新表为：\n");
print_link(head);
}
else
{
printf("插入不成功");
}
//调用函数，在链表中删除一个指定结点的值,如果删除成功，输出新链表
printf("\n\n请输入要删除的学生的姓名：");
getchar();
gets(xm);
if(del_link(head,xm)==1)
{
printf("\n删除成功，新表为：\n");
print_link(head);
}
else
{
printf("删除不成功");
}
}

2. C语言链表概念

struct node
{
int data;
struct node *next;
}
这个是一个链表的定义，next就是本身的一个指针
可以这么理解，链表就是一串珠子，每个珠子就是一个结构体，next就是串珠子的线

3. C语言链表操作

包括链表的创建删除添加和释放操作！！
#include<stdio.h>
#include<stdlib.h>
struct node *create();
void print_list(struct node *head);
struct node * insert_node(struct node *h,int x,int y);
struct node * delete_node(struct node *h,int z);
void shifang(struct node *head);
struct node
{
char data;
struct node *next;
};
void main()
{
struct node *head;
int x,y,z;
head=create();
print_list(head);
printf("\n输入插入结点的位置的值和插入的数值：");
scanf("%d%d",&x,&y);
head=insert_node(head,x,y);
print_list(head);
printf("\n输入要删除的结点：");
scanf("%d",&z);
head=delete_node(head,z);
print_list(head);
printf("\n释放链表.\n");
}
struct node *create() //建立链表函数
{
printf("请输入各节点（以-1结尾）：\n");
int x;
//定义指针*head，*tail，*s;
struct node *head,*tail,*s;
//head和tail初始化，生成一个头结点
head=tail=(struct node *)malloc(sizeof(struct node));
//在循环中，生成新结点、赋值、连接、尾指针后移
scanf("%d",&x);
while(x!=-1)
{
s=(struct node *)malloc(sizeof(struct node));
s->data=x;
tail->next=s;
tail=s;
scanf("%d",&x);
}
//尾结点的指针域赋NULL
tail->next=NULL;
return head;
}
void print_list(struct node *head) //输出链表函数
{
//定义工作指针*p并赋初值p=head->next；即指向第一个结点
struct node *p;
p=head->next;
//判断链表是否为空，空：输出空表的信息，否则：输出所有结点
if(p==NULL)
printf("The list is NULL.");
else
//在循环中输出当前结点，工作指针后移
{
printf("head->");
while(p!=NULL)
{
printf("%d->",p->data);
p=p->next;
}
printf("end.");
}
}
struct node * insert_node(struct node *h,int x,int y) //添加结点函数
{
struct node *p,*q,*s;
//生成要插入的新结点
s=(struct node *)malloc(sizeof(struct node));
s->data=y;
q=h;
p=h->next;
//查找要插入结点的位置
while((p!=NULL)&&(p->data!=x))
{
q=p;
p=p->next;
}
//插入结点
q->next=s;s->next=p;
return(h);
}
struct node * delete_node(struct node *h,int z) //删除结点函数
{
struct node *p,*q;
q=h;
p=h->next ;
//查找要删除结点的位置
if(p!=NULL)
{
while((p!=NULL)&&(p->data!=z))
{
q=p;
p=p->next;
}
//释放结点
if(p->data ==z)
{
q->next=p->next ;
free(p);
}
}
return(h);
}
void shifang(struct node *head) //释放链表函数
{
struct node *p;
//逐个释放结点
while(head!=NULL)
{
p=head;
head=head->next;
free(p);
}
}

4. 怎样在C语言中正确运用链表链表的使用需要注意哪些要点

1.使用链表时候，先确认要使用的是单向链表，还是双向链表，或者是循环链表。一定要初始化。
2.添加节点时候，要注意是否队列已满。
3.删除节点的时候，要注意队列是否为空。
4.要有可以判断链表是否为空的函数。
5.要有可以判断链表节点个数的函数。

5. 在C语言中，什么是链表呀

链表
链表链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，链表比较方便插入和删除操作。

概况
链表(Linked list)是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表：顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。在计算机科学中，链表作为一种基础的数据结构可以用来生成其它类型的数据结构。链表通常由一连串节点组成，每个节点包含任意的实例数据(data fields)和一或两个用来指向明上一个/或下一个节点的位置的链接（"links"）。链表最明显的好处就是，常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序，数据的存取往往要在不同的排列顺序中转换。而链表是一种自我指示数据类型，因为它包含指向另一个相同类型的数据的指针（链接）。链表允许插入和移除表上任意位置上的节点，[1]但是不允许随机存取。链表有很多种不同的类型：单向链表，双向链表以及循环链表。链表可以在多种编程语言中实现。像Lisp和Scheme这样的语言的内建数据类型中就包含了链表的存取和操作。程序语言或面向对象语言，如C,C++和Java依靠易变工具来生成链表。
编辑本段特点
线性表的链式存储表示的特点是用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。因此，为了表示每个数据元素 与其直接后继数据元素 之间的逻辑关系，对数据元素 来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置）。由这两部分信息组成一个"结点"（如概述旁的图所示），表示线性表中一个数据元素 。
编辑本段扩展
根据情况，也可以自己设计链表的其它扩展。但是一般不会在边上附加数据，因为链表的点和边基本上是一一对应的（除了第一个或者最后一个节点，但是也不会产生特殊情况）。不过有一个特例是如果链表支持在链表的一段中把前和后指针反向，反向标记加在边上可能会更方便。 对于非线性的链表，可以参见相关的其他数据结构，例如树、图。另外有一种基于多个线性链表的数据结构：跳表，插入、删除和查找等基本操作的速度可以达到O(nlogn)，和平衡二叉树一样。 其中存储数据元素信息的域称作数据域（设域名为data），存储直接后继存储位置的域称为指针域（设域名为next）。指针域中存储的信息又称做指针或链。 由分别表示,,…, 的N 个结点依次相链构成的链表，称为线性表的链式存储表示，由于此类链表的每个结点中只包含一个指针域，故又称单链表或线性链表.
编辑本段三个链表函数（C语言描述）
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
struct Node{
int data;//数据域
struct Node * next;//指针域
}; /************************************************************************************** *函数名称:insert
*函数功能:在链表中插入元素. *输入:head 链表头指针,p新元素插入位置,x 新元素中的数据域内容 *输出:无 *************************************************************************************/ void insert(Node * head,int p,int x)
{ Node * tmp = head; //for循环是为了防止插入位置超出了链表长度 for(int i = 0;i<p;i++)
{
if(tmp == NULL)
return ;
if(i<p-1)
tmp = tmp->next;
}
Node * tmp2 = new Node;
tmp2->data = x;
tmp2->next = tmp->next;
tmp->next = tmp2;
} /************************************************************************************** *函数名称：del *函数功能:删除链表中的元素 *输入:head 链表头指针,p 被删除元素位置 输出:被删除元素中的数据域.如果删除失败返回-1 **************************************************************************************/
int del(Node * head,int p)
{
Node * tmp = head;
for(int i = 0;i<p;i++)
{
if(tmp == NULL)
return -1;
if(i<p-1)
tmp = tmp->next;
}
int ret = tmp->next->data;
tmp->next = tmp->next->next;
return ret;
}
void print(Node *head)
{
for(Node *tmp = head;
tmp!=NULL; tmp = tmp->next)
printf("%d ",tmp->data);
printf("\n");
}
int main()
{
Node * head;
head = new Node;
head->data = -1;
head->next=NULL;
return 0;
}
编辑本段结语
C语言是学习数据结构的很好的学习工具。理解了C中用结构体描述数据结构，那么对于理解其C++描述，Java描述都就轻而易举了！

编辑本段两种链表形式
一、循环链表 循环链表是与单链表一样，是一种链式的存储结构，所不同的是，循环链表的最后一个结点的指针是指向该循环链表的第一个结点或者表头结点，从而构成一个环形的链。 循环链表的运算与单链表的运算基本一致。所不同的有以下几点： 1、在建立一个循环链表时，必须使其最后一个结点的指针指向表头结点，而不是象单链表那样置为NULL。此种情况还使用于在最后一个结点后插入一个新的结点。 2、在判断是否到表尾时，是判断该结点链域的值是否是表头结点，当链域值等于表头指针时，说明已到表尾。而非象单链表那样判断链域值是否为NULL。
二、双向链表 双向链表其实是单链表的改进。 当我们对单链表进行操作时，有时你要对某个结点的直接前驱进行操作时，又必须从表头开始查找。这是由单链表结点的结构所限制的。因为单链表每个结点只有一个存储直接后继结点地址的链域，那么能不能定义一个既有存储直接后继结点地址的链域，又有存储直接前驱结点地址的链域的这样一个双链域结点结构呢？这就是双向链表。 在双向链表中，结点除含有数据域外，还有两个链域，一个存储直接后继结点地址，一般称之为右链域；一个存储直接前驱结点地址，一般称之为左链域。

6. 用C语言实现链表的算法

这个是我们数据结构上机实验的链表问题，

#include<stdio.h>
#include<malloc.h>
#define LEN sizeof(LinkNode)
typedef int Datatype;
typedef int Status;
typedef struct LinkNode{
Datatype data;
struct LinkNode *next;
} LinkNode,*LinkList;
typedef struct OrderedList
{
LinkNode *head,*tail;
int Listsize;
} OrderedList;//有序循环链表的头节点head,尾接接节点 tail及长度Listsize
Status InitList(OrderedList *List)//生成循环链表头节点
{
List->tail=List->head=(LinkList)malloc(LEN);
if(List->head==NULL)
return 0;
else
{
List->head->next=List->tail;
List->tail->next=List->head;
List->Listsize=0;

return 1;
}
}
void OrderedInsert(OrderedList *List,Datatype data)//每调用一次有序插入data形成有序的(从小到大)的链表

{ LinkNode *p ,*q;

if(List->head==List->tail->next)
{
p=(LinkNode*)malloc(LEN);
p->data = data;
List->head->next=p;
p->next=List->tail;
List->Listsize++;
}
else
{
p=List->head->next;
q = List->head;
while(p->data<data&&p!=List->tail)
{
q = p;
p=p->next;
}
if(p->data==data)
{printf("YOu have input the same datas %d\n\t YOu should input another data \n",data);
scanf("%d",&data);
OrderedInsert(List,data);
}
else
{
p=(LinkNode*)malloc(LEN);
p->data = data;
p->next = q->next;
q->next = p;
List->Listsize++;
}
}
}
void Creatset(OrderedList *List)//多次调用OrderedInsert()生成有序链表即集合List
{
Datatype data;
int setsize , i=0;
printf("Please input the setsize you want to creat:\n");
scanf("%d",&setsize);
InitList(List);
if(setsize==0)
printf("You needen't input any data\n");
else if(setsize==1)
printf("Please input a single data\n");
else
printf("Please input %d different datas;\n",setsize);
while(i<setsize||setsize>List->Listsize)//当循环次数i小于setsize或者集合内实际元素数List.Listsize小于setsize时一直循环下去
{
scanf("%d",&data);
OrderedInsert(List,data);
i++;
}
}

void Append(OrderedList *List,Datatype data)//在循环链表的最后面追加 一个data
{
LinkNode *p;
p=(LinkNode*)malloc(LEN);
p->data=data;
List->tail=List->tail->next=p;
List->tail->next=List->head;
List->Listsize+=1;
}
void MergeList(OrderedList La,OrderedList Lb,OrderedList *Lc)//有序循环链表ListLa,ListLb求并集生成ListLc
{
LinkList Pa,Pb;
Pa=La.head->next;Pb=Lb.head->next;
while(Pa!=La.tail&&Pb!=Lb.tail)
{
if(Pa->data<=Pb->data)
{
Append(Lc,Pa->data);
Pa=Pa->next;
}

else {
Append(Lc,Pb->data);Pb=Pb->next;
}
}
while(Pa!=La.tail)
{ Append( Lc,Pa->data);Pa=Pa->next;}

while(Pb!=Lb.tail)
{ Append(Lc,Pb->data);Pb=Pb->next;}

}
void Print(OrderedList List)
{
LinkNode *p;
p=List.head->next;
if(p->next==List.head)
printf("No Elem\n");
while(p!=List.head)
{ printf("%5d",p->data);p=p->next; }
printf("\n");
}
void main()
{
OrderedList ListLa,ListLb,ListLc;
Creatset(&ListLa);
Creatset(&ListLb);
InitList(&ListLc);
MergeList(ListLa,ListLb,&ListLc);
printf("The orgnial list ListLa,ListLb:\n");
Print(ListLa);
Print(ListLb);
printf("The Merge list ListLc;\n");
Print(ListLc);
}

7. C语言链表的建立

参考以前写的这个吧,写的不好,你修改吧
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#define CD sizeof(struct Biao)
struct Biao
{
int num;
struct Biao *next;
};
int m,x;
int main()
{
struct Biao *jianli();
void paixu(struct Biao *n);
void chashu(struct Biao *n);
void shanshu(struct Biao *n);
void qiupingjun(struct Biao *n);
void tuichu();
int n;
struct Biao *t;
printf("1.建立链表\n2.排序\n3.插数\n4.删数\n5.求平均值\n");
printf("请输入选项：\n");
for(;;)
{
scanf("%d",&n);
switch(n)
{
case 1:t=jianli();break;
case 2:paixu(t);break;
case 3:chashu(t);break;
case 4:shanshu(t);break;
case 5:qiupingjun(t);break;
case 6:tuichu();break;
default:printf("输入错误！请重新输入\n");
}
}
}
struct Biao *jianli()
{
int i,j;
printf("建立链表,请输入数据:\n");
struct Biao *head,*p1,*p2;
p1=p2=(struct Biao * )malloc(CD);//if(p1==NULL)建立链表失败
for(i=0;i<=100;i++)
{
if(i==0)
{
head=p1;
p2->next=p1=(struct Biao * )malloc(CD);
p2=p1;
continue;
}
if(p1==NULL)
break;
else
{
scanf("%d",&p1->num);
if(p1->num==-1)
{
p2->num=NULL;
break;
}
p2->next=p1=(struct Biao * )malloc(CD);
p2=p1;
}
}
if(head->next->num==NULL)
printf("您建立了一个空链表\n");
else
{
printf("共有数据：%d\n",i-1);
m=i-1;
printf("输出链表：\n");
p1=head->next;
for(j=0;j<i-1;j++)
{
printf("%d ",p1->num);
p1=p1->next;
}
}
printf("\n");
return(head);
}
void paixu(struct Biao *n)
{
int i,j,a,temp;
a=m;
struct Biao *p1,*p2,*tp;
p2=p1=n->next;
printf("从小到大排序结果：\n");
for(i=0;i<a-1;i++)
{
p1=p2;
tp=p1;
for(j=i+1;j<a;j++)
{
if((p1->next->num)<(tp->num))
{
tp=p1->next;
}
p1=p1->next;
}
temp=tp->num;tp->num=p2->num;p2->num=temp;
p2=p2->next;
}
p1=n->next;
for(i=0;i<a;i++)
{
printf("%d ",p1->num);
p1=p1->next;
}
printf("\n");
}
void chashu(struct Biao *n)
{
int a,i,j;
struct Biao *p1,*p2,*tp;
m=m+1;
x=m;
a=m;
p1=n;
printf("请插入数字:\n");
p2=(struct Biao *)malloc(CD);
scanf("%d",&p2->num);
p1=n->next;
for(i=0;i<a-1;i++)
{
if(p1->num<=p2->num&&p1->next->num>p2->num)
{
tp=p1->next;
p1->next=p2;
p2->next=tp;
break;
}
if(p1->num<p2->num&&p1->next->num>p2->num)
{
tp=p1->next;
p1->next=p2;
p2->next=tp;
break;
}
if(n->next->num>p2->num)
{
tp=n->next;
n->next=p2;
p2->next=tp;
break;
}
p1=p1->next;
}
p1=n;//
for(i=0;i<a-1;i++)
{
p1=p1->next;
}
if(p1->num<=p2->num)
{
tp=p1->next;
p1->next=p2;
p2->next=tp;
}//算法不简便
printf("插入后的数据：\n");
p1=n->next;
for(i=0;i<a;i++)
{
printf("%d ",p1->num);
p1=p1->next;
}
printf("\n");
printf("数据个数:%d\n",a);
}
void shanshu(struct Biao *n)
{
int a,i,j;
a=x;
struct Biao *p1,*p2;
printf("请输入要删除的数：\n");
scanf("%d",&j);
for(;;)
{
p1=n;
for(i=0;i<a;i++)
{
if(p1->next->num==j)
{
p2=p1->next;
p1->next=p1->next->next;
a-=1;
x-=1;
break;
}
p1=p1->next;
}
if(i==a)
break;
}
printf("结果：\n");
p1=n->next;
for(i=0;i<a;i++)
{
printf("%d ",p1->num);
p1=p1->next;
}
printf("\n");
printf("剩余数据个数：%d\n",x);
}
void qiupingjun(struct Biao *n)
{
int s,i;
struct Biao *p1;
s=0;
p1=n->next;
for(i=0;i<x;i++)
{
s+=p1->num;
p1=p1->next;
}
printf("平均值为：%f\n",s*1.0/x);
}
void tuichu()
{
exit(0);
}

8. C语言中怎么定义链表，最好把各个代码都详细的解释一下！

/*creat
a
list*/
#include
"stdlib.h"
#include
"stdio.h"
struct
list
{
int
data;
struct
list
*next;
};
typedef
struct
list
node;
typedef
node
*link;
void
main()
{
link
ptr,head;
int
num,i;
ptr=(link)malloc(sizeof(node));
ptr=head;
printf("please
input
5
numbers==>\n");
for(i=0;i<=4;i++)
{
scanf("%d",&num);
ptr->data=num;
ptr->next=(link)malloc(sizeof(node));
if(i==4)
ptr->next=NULL;
else
ptr=ptr->next;
}
ptr=head;
while(ptr!=NULL)
{
printf("The
value
is
==>%d\n",ptr->data);
ptr=ptr->next;
}
}
上面是一个简单的创建链表的C程序。所谓链表形象的讲就是一个数据块里面存有数据，并且存有下一个数据的指针，这样一个指一个形成一个数据链。这个数据链可以被操作，例如插入数据，删除数据，等。至于指令，首先定义一个结构体，它存有数据和指向下一个数据块的指针。然后分配空间。注意最后一个为NULL，当然你也可以指向开头一个数据块形成一个循环链表。

9. C语言创建链表，函数调用部分

#include<stdio.h>
#include<windows.h>
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

//定义数据类型名称
typedef int DataType;

#define flag -1 //定义数据输入结束的标志数据

//单链表结点存储结构定义
typedef struct Node
{
DataType data;
struct Node *next;
}LNode ,*LinkList;

//建立单链表子函数
LNode *Create_LinkList()
{
LNode *s,*head,*L;int i=0,x; //定义指向当前插入元素的指针
while(1)
{
scanf("%d",&x);
if(-1==x)
{ return head;
break;}
s= (LNode *)malloc(sizeof(LNode)); //为当前插入元素的指针分配地址空间
s->data =x;
s->next =NULL;
i++;
if(i==1)
head=s;
else
L->next =s;
L=s;

}
}
//查找子函数（按序号查找）
LNode *Get_LinkList(LinkList L,int i)
{
LNode *p;
int j; //j是计数器，用来判断当前的结点是否是第i个结点
p=L;
j=1;
while(p!=NULL&&j<i)
{
p=p->next ; //当前结点p不是第i个且p非空，则p移向下一个结点
j++;
}
return p;
}

//插入运算子函数
void Insert_LinkList(LinkList L,int i,DataType x) //在单链表L中第i个位置插入值为x的新结点
{
LNode *p,*s;
p =Get_LinkList(L,i); //寻找链表的第i-1个位置结点
if(p==NULL)
{
printf("插入位置不合法！");
exit(-1);
}
else
{
s= (LinkList)malloc(sizeof(LNode)); //为当前插入元素的指针分配地址空间
s->data =x;
s->next =p->next ;
p->next =s;
}
}

//单链表的删除运算子函数
void Delete_LinkList(LinkList L,int i) //删除单链表上的第i个结点
{
LNode *p,*q;
p=Get_LinkList(L,i-1); //寻找链表的第i-1个位置结点
if(p==NULL)
{
printf("删除的位置不合法！"); //第i个结点的前驱结点不存在，不能执行删除操作
exit(-1);
}
else
{
if(p->next ==NULL)
{
printf("删除的位置不合法！"); //第i个结点不存在，不能执行删除操作
exit(-1);
}

else
{
q=p->next ;
p->next =p->next->next;
free(q);
}
}
}

//求表长运算子函数
int Length_LinkList(LinkList L)
{
int l; //l记录L的表长
LNode *p;
p=L;
l=1;
while(p->next)
{
p=p->next;
l++;
}
return l;
}
int main ()
{
LNode *head,*p;
head=(LinkList)malloc(sizeof(LNode));
int x,y;
a:
printf("*******menu******* ");
printf("**创建**********1* ");
printf("**插入**********2* ");
printf("**删除**********3* ");
printf("**表长**********4* ");
printf("**清屏**********5* ");
printf("**打印**********6* ");
printf("**退出******other* ");
printf("****************** ");
int i=1;
while(i)
{
printf("请输入选项：");
scanf("%d",&i);
switch(i)
{
case 1:head=Create_LinkList(); getchar();break;
case 2:printf("请输入位置和数据；");
scanf("%d%d",&x,&y);
Insert_LinkList(head,x,y);break;
case 3:printf("请输入位置；");
scanf("%d",&x);
Delete_LinkList(head,x);break;
case 4:printf("%d",Length_LinkList(head));break;
case 5:system("cls");goto a;
case 6:p=head;
while(p!=NULL)
{printf("%d ",p->data);
p=p->next;}
break;
default :i=0;
}
}
}

我把创建给改了一下

10. C语言链表的思路

链表的一种数据格式：

typedefintDataType;

typedefstructLinkNode
{
DataTypedata;
structLinkNode*next;
}LinkNode;

LinkNode*Create_LinkList()
{
LinkNode*h=NULL;//指向链表第一个数据节点
LinkNode*tail=NULL;//指向链表最后一个节点

while(1)
{
//用户不断的输入数据,直到输入负数
intinput;
scanf("%d",&input);
if(input<0){
break;
}
//申请新节点内存
LinkNode*newNode=(LinkNode*)malloc(sizeof(LinkNode));
//设置新节点的next
newNode->next=NULL;
//填充数据
newNode->data=input;
//添加到链表尾
if(h==NULL){
//若表头为NULL，说明新节点为第一个节点，则表头和表尾都为新节点
h=tail=newNode;
}else{
//否则将tail->next指向新节点，并更新表尾
tail->next=newNode;
tail=newNode;
}
}
//返回链表第一个节点的指针
returnh;
}