动态链表c语言（C语言，用动态链表实现读取未知条数的txt文件原代码如下，求高人修改并讲解下实现原理）

：暂无数据 2026-09-01 12:00:01 ：0

本篇文章给大家谈谈动态链表c语言，以及C语言，用动态链表实现读取未知条数的txt文件原代码如下，求高人修改并讲解下实现原理对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录

C语言，用动态链表实现读取未知条数的txt文件原代码如下，求高人修改并讲解下实现原理
VS13中C++创建C语言文件后创建一个动态链表然后输出动态链表的功能怎么实现不出来输入完数据后显示n’
c语言中创建动态链表
c语言中，动态链表可不可以用二进制格式保存到文件中
c语言，建立动态链表，大神帮我解释下括号部分每一句是什么作用
c语言编程的问题动态链表的
使用C语言创建一个动态链表
C语言动态链表问题描述：学生信息包括学号、姓名、性别、语文、数学、英语插入学生信息：
C语言的函数与全局变量动态链表的问题

C语言，用动态链表实现读取未知条数的txt文件原代码如下，求高人修改并讲解下实现原理

#include "stdafx.h"
#include《memory.h》
#include《stdio.h》
#include《stdlib.h》
#include《string.h》
#include《conio.h》
#define MAX_NAME_LEN 1024 //最长名称
#define MAX_LINE_LEN 2048 //每行最长字符数
#define READ_IN_FILE_NAME "D:\\test.txt" //入力文件路径为：D:\\test.txt
#define OUT_PUT_FILE_NAME "D:\\test_sort.txt" //出力文件路径为：D:\\test_sort.txt
typedef struct
{
char pcName;
int iSex;
int iAge;
struct STRUCT_DATA * next;
}STRUCT_DATA;
int compare(const void *_pData1,const void *_pData2)
{
STRUCT_DATA *pSrcData1 = (STRUCT_DATA*)_pData1;
STRUCT_DATA *pSrcData2 = (STRUCT_DATA*)_pData2;
if(NULL == pSrcData1 || NULL == pSrcData2)
{
return 0;
}
return pSrcData1-》iAge - pSrcData2-》iAge;
}
struct STRUCT_DATA *head;
int iDataNum;
int main(int argc,char argv)
{
STRUCT_DATA *pNewData, *pCurData;
FILE *pReadInFileData = NULL;
FILE *pOutputFileData = NULL;
//读取文件
pReadInFileData = fopen(READ_IN_FILE_NAME,"r");
if(pReadInFileData == NULL)
{
printf("open file fail!!!\r\n");
getch();
return -1;
}
//存入数组
char pcLine = "";
while (fgets(pcLine,MAX_LINE_LEN,pReadInFileData) != EOF)//name sex age
{
pNewData = (STRUCT_DATA *)malloc(sizeof(STRUCT_DATA));
if(pNewData == NULL) {
fclose(pReadInFileData);
freeList(head);
getch();
return -2;
}
pNewData-》next = NULL;
if(sscanf(pcLine,"%s%d%d",pNewData.pcName,&pNewData.iSex,&pNewData.iAge)!=3)
{
printf("ReadData Error!!!\r\n");
fclose(pReadInFileData);
freeList(head);
getch();
return -2;
}
if(head == NULL)
head = pNewData;
else
{
if(pNewData-》iAge 《 head-》iAge) {
pNewData-》next = head;
head = pNewData;
continue;
}
for(pCurData = head; pCurData-》next != NULL; pCurData = pInsertData-》next)
{
if(pNewData-》iAge 《 pCurData-》next-》iAge) //按升序排序
{
pNewData-》next = pCurData-》next;
pCurData-》next = pNewData;
break;
}
}
if(pCurData-》next = NULL) //最大值，插到链表结尾
pCurData-》next = pNewData;
}
}
//关闭文件
fclose(pReadInFileData);
pReadInFileData=NULL;
//打开文件
pOutputFileData = fopen(OUT_PUT_FILE_NAME,"w");
if(pOutputFileData == NULL)
{
printf("open file fail!!!\r\n");
getch();
return -3;
}
//输出
printf("name\tsex\tage\t\r\n");
for(pCurData = head; pCurData != NULL; pCurData = pCurData-》next)
{
sprintf(pcLine, "%s\t%d\t%d\t\r\n",pCurData-》pcName,pCurData-》iSex,pCurData-》iAge);
getch();
fputs(pcLine,pOutputFileData);
printf(pcLine);
}
//关闭文件
fclose(pOutputFileData);
pOutputFileData=NULL;
freeList(head);
}
void freeList(STRUCT_DATA *head)
{
STRUCT_DATA *pCurData, *pNextData;
for(pCurData = head; pCurData != NULL; ) {
pNextData = pCurData-》next;
free(pCurData);
pCurData = pNextData;
}
}

VS13中C++创建C语言文件后创建一个动态链表然后输出动态链表的功能怎么实现不出来输入完数据后显示n’

#include《stdio.h》
#include《malloc.h》
#define LEN sizeof(struct student)
struct student {
long num;
float score;
struct student * next;
};

struct student *creat(void) {
struct student *head,*p;
long id;
float score;
head = p = (struct student *)malloc(LEN);
printf("学号成绩(q to quit):");
while(scanf("%ld%f",&id, &score) == 2) {
p-》next = (struct student *)malloc(LEN);
p-》next-》num = id;
p-》next-》score = score;
p = p-》next;
printf("学号成绩(q to quit):");
}
p-》next = NULL;
return(head);
}
//实现结构体数据的动态获取；
void print(struct student *head) {
struct student *p = head-》next;
while(p) {
printf("%ld\t%.2f\n",p-》num, p-》score);
p = p-》next;
}
}
int main() {
struct student *head;
printf("input records:\n");
head = creat();
print(head);
return 0;
}

c语言中创建动态链表

给你些资料吧~仔细看，看完就明白链表了
10.7 用指针处理链表
10.7.1链标概述
链表是一种常见的重要的数据结构.它是动态地进行存储分配的一种结构.我们知道,用数组存放数据时,
必须事先定义固定的长度(即元素个数).比如,有的班级有100人,而有的班只有30人,如果要用同一个数组先后存放不同班级的学生数据,则必须定义长度为100的数组.如果事先难以确定一个班的最多人数,则必须把数组定得足够大,以能存放任何班级的学生数据.显然这将会浪费内存.链表则没有这种缺点,它根据需要开辟内存单元.图10.11表示最简单的一种链表(单向链表)的结构.链表有一个"头指针"变量,图中以head表示,它存放一个地址.
该地址指向一个元素.链表中每一个元素称为"结点",每个结点都应包括两个部分:一为用户需要用的实际数据,二为下一个结点的地址.课以看出,head指向第一个元素;第一个元素又指向第二个元素;……,直到最后一个元素,该元素不再指向其它元素,它称为’表尾",它的地址部分放一个"NULL"(表示"空地址").链表到此结束.
可以看到:链表中各元素在内存中可以不是连续存放的.要找某一元素,必须先找到上一个元素,根据它提供的下一元素地址才能找到下一个元素.
如果不提供"头指针"(head),则整个链表都无法访问.链表如同一条铁链一样,一环扣一环,中间是不能断开的.打个通俗的比方:幼儿园的老师带领孩子出来散步,老师牵着第一个小孩的手,第一个小孩的另一只手牵着第二个孩子,……,这就是一个"链",最后一个孩子有一只手空着,他是"链尾".要找这个队伍,必须先找到老师,然后顺序找到每一个孩子.
可以看到,这种链表的数据结构,必须利用指针变量才能实现
.即:一个结点中应包含一个指针变量,用它存放下一结点的地址.
前面介绍了结构体变量,它包含若干成员.这些成员可以是数值类型,字符类型,数组类型,也可以是指针类型.这个指针类型可以是指向其它结构体类型数据,也可以指向它所在的结构体类型.例如:
struct student
{int num;
float score;
struct student *next;
next是成员名,它是指针类型的,它指向struct student类型数据(这就是next所在的结构体类型).用这种方法可以建立链表.见图10.12.
其中每一个结点都属于struct student类型,它的成员next存放下一结点的地址,程序设计人员可以不必具体知道地址值,
只要保证将下一个结点的地址放到前一结点的成员next中即可.
请注意:上面只是定义了一个struct student类型,并未实际分配存储空间.前面讲过,链表结构是动态地分配存储的,即在需要时才开辟一个结点的存储单元.怎样动态地开辟和释放存储单元呢 C语言编译系统的库函数提供了以下有关函数.
1.malloc(size) 在内存的动态存储区中分配一个长度为size的连续空间.
此函数的值(即"返回值")是一个指针,它的值是该分配域的起始地址.如果此函数未能成功地执行,则返回值为0.
2.calloc(n,size) 在内存的动态区存储中分配n个长度为size的连续空间.函数返回分配域的起始地址;如果分配不成功,返回0.
3.free(ptr) 释放由ptr指向的内存区.ptr是最近一次调用ca11或ma11oc函数时返回的值.
上面三个函数中,参数n和size为整型,ptr为字符型指针.
请注意:许多C版本提供的malloc和call0c函数得到的是指向字符型数据的指针.新标准C提供的ma110c和ca11oc函数规定为void*类型.
有了本节所介绍的初步知识,下面就可以对链表进行操作了(包括建立链表,插入或删除链表中一个结点等).有些概念需要在后面的应用中逐步建立和掌握.
10.7.2建立链表
所谓建立链表是指从无到有地建立起一个链表,即一个一个地输入各结点数据,并建立起前后相链的关系.下面通过一个例子来说明如何建立一个链表.
写一函数建立一个有5名学生数据的单向链表.
先考虑实现此要求的算法(见图10. 13).
设三个指针变量:head,p1,p2,它们都指向结构体类型数据.先用mal1oc函数开辟一个结点,并使p1,p2指向它.
然后从键盘读人一个学生的数据给pl所指的结点.我们约定学号不会为零,如果输入的学号为0,则表示建立链表的过程完成,该结点不应连接到链表中.先使head的值为NULL(即等于0),这是链表为"空"时的情况(即head不指向任何结点,链表中无结点),以后增加一个结点就使head指向该结点.
如果输入的pl一》num不等于0,而且输入的是第一个结点数据(n=1)时,则令head=p1,
即把p1的值赋给head,也就是使head也指向新开辟的结点(图10.14).P1所指向的新开辟的结点就成为链表中第一个结点.然后再开辟另一个结点并使p1指向它,接着读入该结点的数据(见图10.15(a)).如果输入的p1-》num!=0,则应链入第2个结点(n=2),由于n!=1,则将p1的值赋给p2--》next,也就是使第一个结点的next成员指向第二个结点(见图10.15(b)).接着使p2=p1,
也就是使p2指向刚才建立的结点,见图10.15(c).再开辟一个结点并使pl指向它,并读入该结点的数据(见图10.16(a)),在第三次循环中,由于n=3(n!=1),又将pl的值赋给p2一》next,也就是将第3个结点连接到第2个结点之后,并使p2=p1,使p2指向最后一个结点(见图10.16(b).
再开辟一个新结点,并使pl指向它,
输入该结点的数据(见图10.17(a)).由于pl一》num的值为0,不再执行循环,此新结点不应被连接到链表中.此时将NULL赋给p2一》next,见图10.17(b).建立链表过程至此结束,pl最后所指的结点未链入链表中,第3个结点的next成员的值为NULL,它不指向任何结点.虽然pl指向新开辟的结点,但从链表中无法找到该结点.
建立链表的函数可以如下:
#define NULL 0
#define LEN sizeof(struct student)
struct student
{1ong num;
float score;
struct student *next;
};
int n;
struct student *creat()
/*此函数带回一个指向链表头的指针*/
{struct student *head;
struct student *p1, *p2;
n=0;
p1=p2=(struct student*)mal1oc(LEN);/*开辟一个新单元*/
scanf("%ld,%f",&pl一》num,&pl一》score);
head=NULL:
while (pl一》num!=0)
{n=n十1;
if(n==1) head=pl;
else p2一》next=p1;
p2=pl;
pl=(struct student*)malloc(LEN);
scanf("%1d,%f",&p1--》num,&pl一》score);
}
p2一》next=NULL;
return(head);
}
请注意:
(1)第一行为#define命令行,令NULL代表0,用它表示"空地址".第二行令LEN代表struct student结构体类型数据的长度,
sizeof是"求字节数运算符".
(2)第9行定义一个creat函数,它是指针类型,即此函数带回一个指针值,它指向一个struct student类型数据.实际上此creat函数带回一个链(3)malloc(LEN)的作用是开辟一个长度为LEN的内存区,LEN已定义为sizeof(struct student),即结构体struct student的长度.在一般系统中,malloc带回的是指向字符型数据的指针.
而p1,p2是指向struct student类型数据的指针变量,二者所指的是不同类型的数据,这是不行的.因此必须用强制类型转换的方法使之类型一致,在malloc (LEN)之前加了"(struct student*)",它的作用是使malloc返回的指针转换为指向struct student类型数据的指针.注意"*"号不可省略,否则变成转换成struct student类型了,而不是指针类型了.
(4)最后一行return后面的参数是head(head已定义为指针变量,指向struct student类型数据).因此函数返回的是head的值,也就是链表的头地址.
(5)n是结点个数.
(6)这个算法的思路是:让pl指向新开的结点,p2指向链表中最后一个结点,把pl所指的结点连接在p2所指的结点后面,用"p2一》next=pl"来实现.
我们对建立链表过程作了比较详细的介绍,
读者如果对建立链表的过程比较清楚的话,对下面介绍的删除和插入过程也就比较容易理解了.
10.7.3输出链麦
将链表中各结点的数据依次输出.这个问题比较容易处理.首先要知道链表头元素的地址,也就是要知道head的值.然后设一个指针变量p,先指向第一个结点,输出p所指的结点,然后使p后移一个结点,再输出.直到链表的尾结点.
「例10.8]写出输出链表的函数print.
void print(head)
struct student *head;
{struct student *p;
printf("\nNow,These%drecords are:\n",n);
p=head;
if(head!=NULL)
do
{printf("%ld%5.1f\",p一》num,p—》score);
p=p一》next;
}while(p!=NULL);
算法可用图10.18表示.
其过程可用图10.19表示.p先指向第一结点,在输出完第一个结点之后,p移到图中p’虚线位置,指向第二个结点.程序中p=p一》next的作用是:将p原来所指向的结点中next的值赋给p,
而p一》next的值就是第二个结点的起始地址.将它赋给p就是使p指向第二个结点.
head的值由实参传过来,也就是将已有的链表的头指针传给被调用的函数,在print函数中从head所指的第一个结点出发顺序输出各个结点.
10.7.4 对链麦的删除操作
已有一个链表,希望删除其中某个结点.怎样考虑此问题的算法呢,先打个比方:
一队小孩(A.B.C.D.E)手拉手,如果某一小孩(C)想离队有事,而队形仍保持不变.只要将C的手从两边脱开,B改为与D拉手即可,见图10.20.图10.20(a)是原来的队伍,图10.20(b)是c离队后的队伍.
与此相仿,从一个链表中删去一个结点,并不是真正从内存中把它抹掉,而是把它从链表中分离开来,即改变链接关系即可.
写一函数以删除指定的结点.
我们以指定的学号作为删除结点的标志.例如,输入89103表示要求删除学号为89103的结点.解题的思路是这样的:从p指向的第一个结点开始,检查该结点中的num值是否等于输入的要求删除的那个学号.如果相等就将该结点删除,如不相等,就将p后移一个结点,再如此�下去,直到遇到表尾为止.
可以设两个指针变量pl和p2,先使pl指向第一个结点(图10.21(a)).如果要删除的不是第一个结点,
则使pl后指向下一个结点(将pl一》next赋给pl),在此之前应将pl的值赋给p2,使p2指向刚才检查过的那个结点,见图10.21(b).如此一次一次地使p后移,直到找到所要删除的结点或检查完全部链表都找不到要删除的结点为止.如果找到某一结点是要删除的结点,还要区分两种情况:①要删的是第一个结点(pl的值等于head的值,如图10.21(a)那样),则应将pl一》next赋给head.见图10.21(c).
这时head指向原来第二个结点.第一个结点虽然仍存在,但它已与链表脱离,因为链表中没有一个元素或头指针指向它.虽然p1还指向它,它仍指向第二个结点,但仍无济于事,现在链表的第一个结点是原来第二个结点,原来第一个结点"丢失".②如果要删除的不是第一个结点,则将pl一》next赋给p2一》next,见图10.21(d).p2一》next原来指向pl指向的结点(图中第二个结点),现在p2一》next改为指向p1一》next所指向的结点
(图中第三个结点).pl所指向的结点不再是链表的一部分.
还需要考虑链表是空表(无结点)和链表中找不到要删除的结点的情况.
图10.22表示解此题的算法.
删除结点的函数del如下:
struct student *del(head,num)
struct student *head;
1ong num;
{struct student *p1,*p2;
if(head==NULL) {printf("\nlist null!\n");goto end;}
p1=head;
whi1e (num!=pl一》num&&pl一》next!一NULL)/*pl指向的不是所要找的结点,并且后面还有结点点*/
{p2=p1;pl=pl一》next;}/*后移一个结点*/
if (num==pl一》num) /*找到了*/
{if (n1==head) head=pl一》next;/*若pl指向的是头结点,把第二个结点地址赋予head*/
e1se p2一》next=pl一》next;/*否则将下一结点地址赋给前一结点地址*\
printf("delete:%ld\n",num);
n=n-1;
}
else printf("%ld not been found!\n",num);/*找不到该结点*/
end:
return(head);
}
函数的类型是指向struct student类型数据的指针,
它的值是链表的头指针.函数参数为head和要删除的学号num.head的值可能在函数执行过程中被改变(当删除第一个结点时).
10.7.5对链表的插入操作
将一个结点插入到一个已有的链表中.设已有的链表中各结点中的成员项num(学号)是按学号由小到大顺序排列的.
用指针变量p0指向待插入的结点,pl指向第一个结点.见图10.23(a).
将p0一》num与pl一》num相比较,如果p0一》num》pl一》num,则待插入的结点不应插在pl所指的结点之前.此时将pl后移,并使p2指向刚才pl所指的结点,见图10.23(b).再将p1一》num与p0一》num比.如果仍然是p0一》num大,则应使pl继续后移,直到p0一》numnum为止.这时将p0所指的结点插到pl所指结点之前.但是如果p1所指的已是表尾结点,则pl就不应后移了.如果p0一》num比所有结点的num都大,
则应将p0所指的结点插到链表末尾.
如果插入的位置既不在第一个结点之前,又不在表尾结点之后,则将p0的值赋给p2一》next,即使p2一》next指向待插入的结点,然后将pl的值赋给p0-》next,即使得p0一》next指向pl指向的变量.见图10.23(c).可以看到,在第一个结点和第二个结点之间已插入了一个新的结点.
如果插入位置为第一结点之前(即pl等于head时),
则将p0赋给head,将p1赋给p0-》next.见图10.23(d).如果要插到表尾之后,应将p0赋给pl一》next,NULL赋给p0一》next,见图10.23(e).
以上算法可用图10.24表示.
插入结点的函数insert如下.
struct student *insert(head,stud)
struct student *head,*stud:
{struct student *p0,*p1,*p2;
pl=head;/*使pl指向第一个结点*/
p0=stud;/*p0指向要插入的结点*/
if (head==NULL)/*原来是空表*/
{head=p0;p0一》next=NULL;}/*使p0指向的结点作为第一个结点*/
else
{while ((p0一》num》pl一》num)&&(pl一》next!=NULL))
{p2=p1;p1=pl一》next;}/*p2指向刚才pl指向的结点,p1后移一个结点*/
if(p0-》numnext=p0;/*插到p2指向的结点之后*/
p0—》next=p1;}
else
{pl一》next=p0;p0一》next=NULL;}}/*插到最后的结点之后*/
n=n+1; /*结点数加1*/
return(head);
}
函数参数是head和stud.stud也是一个指针变量,从实参传来待插入结点的地址给stud.语句p0=stud的作用是使p0指向待插入的结点.
函数类型是指针类型,函数值是链表起始地址head.
将以上建立,输出,删除,插入的函数组织在一个程序中,用main函数作主调函数.可以写出以下main函数.
main()
{struct student *head,stu;
1ong de1_num;
printf("input records:\n");
head=creat(); /*返回头指针*/
print(head); /*输出全部结点*/
printf("\ninput the deleted 0number:");
scanf("%ld",&de1_mum);/*输入要删除的学号*/
head=del(head,de1_num);/*删除后的头地址*/
print(head); /*输出全部结点*/
prinif("/ninput the inserted record:")/*输入要插入的记录*/
scanf("%ld,%f",&stu.num,&stu.score);
head=insert(head,&stu);/*返回地址*/
print(head);
}
此程序运行结果是正确的.
它只删除一个结点,插入一个结点.但如果想再插入一个结点,重复写上程序最后四行,即共插入两个结点.运行结果却是错误的.
input records:(建立链表)
89101,90
89103,98
89105,76
0,0
Now,These 3 records are:
89101 90.0
89103 98.0
89105 76.0
inpu the deleted number:
89103 (删除)
delete:89103
Now,These 2 records are:
89101 90.0 89105 76.0
input the inserted record:89102
90 (插入第一个结点)
Now,These 3 records are:
89101 90.0
89102 90.0
89105 76.0
input the inserted record:89104,99/(插入第二个结点)
Now,The 4 records are:
89101 90.0
89104 99.0
89104 99.0
89104 99.0
...
...
(无终止地输出89104的结点数据)
请读者将main与insert函数结合起来考察为什么会产生以上运行结果.
出现以上结果的原因是:stu是一个有固定地址的变量.第一次把stu结点插入到链表中.第二次若再用它来插入第二个结点,就把第一次结点的数据冲掉了.
实际上并没有开辟两个结点.读者可根据insert函数画出此时链表的情况.为了解决这个问题,必须在每插入一个结点时新开辟一个内存区.我们修改main函数,使之能删除多个结点(直到输入要删的学号为0),能插入多个结点(直到输入要插入的学号为0).
main函数如下:
main()
{struct student *head,*stu;
1ong de1_num;
printf("input records:/n");
head=creat();
print (head);
printf("/ninput the deleted number:");
scanf("%1d",&del_num);
while (de1_num!=0)
{head=del(head,del_num);
print(head);
printf("input the deleted number:");
scanf("%ld",&del_num);
printf("\ninput the inserted record:");
stu=(struct student*)malloc(LEN);
scanf("%1d,%f,",&stu一》num,&stu一》scor);
while (stu一》num!=0)
{head=insert(head,stu):
print(head);
prinif("input the inserted record:");
stu=(struct student*)malloc(LEN);
scanf("%1d,%f,&stu一》num,&stu一》score);
}
}
sum定义为指针变量,在需要插入时先用malloc函数开辟一个内存区,将其起始地址经强制类型转换后赋给stu,然后输入此结构体变量中各成员的值.对不同的插入对象,stu的值是不同的,每次指向一个新的结构体变量.在调用insert函数时,实参为head和stu,将已建立的链表起始地址传给insert函数的形参,将stu(既新开辟的单元的地址)传给形参stud,函数值返回经过插入之后的链表的头指针(地址).
运行情况如下:
input records:
89101,99
89103,87
89105,77
0,0
Now, These 3 records are.
89101 99.0
89103 87.0
89105 77.0
input the deleted number:89103
delete:89103
Now,These 2 records are:
89101 99.0
89105 77.0
input the de1eted number:89105
delete:89105
Now,These l records are:
89101 99.0
input the de1eted number:0
1nput the inserted record:89104,87
NOw,These 2 records are:
89101 99.0
89104 87.0
input the inserted record:89106,65
Now,These 3 records are:
89101 99.0
89104 87.0
89106 65.0
input the inserted record:0,0
对这个程序请读者仔细消化.
指针的应用领域很宽广,除了单向链表之外,还有环形链表,双向链表.此外还有队列,树,栈,图等数据结构.
有关这些问题的算法可以学习《数据结构》》课程,在此不作详述.

c语言中，动态链表可不可以用二进制格式保存到文件中

可以使用二进制格式存储。
需要注意的是，链表的指针域，可以不存入二进制文件，或者说，存进去也没有用处。
指针域的值，是指向其它单元的地址值，而地址值是动态分配的，从文件中读出时，该段内存很可能已经失效，所以再直接使用存储值就会出问题。
正确的做法是：
1
将链表按节点存放到二进制文件中，是否存储指针域均可。
2
读取时，每次读取一个节点的数据，指针域置空；
3
将每个节点的数据，按照存储的顺序(从头到尾，或从尾到头)，重新分配节点资源，并形成有效链表。

c语言，建立动态链表，大神帮我解释下括号部分每一句是什么作用

给题主完整讲述下creat函数吧

struct Student * creat () {
struct Student *head; /*定义head构体指针，代表头结点*/
struct Student *p1, *p2; /*定义p1、p2两个结构体指针*/
n = 0; /*计数器，统计节点数量*/
p1 = p2 = (struct Student *) malloc (LEN); /*申请一个结构体空间，p1、p2均指向它*/
scanf ("%d,%f",&p1-》num,&p1-》score); /*为结构体输入内容*/
head = NULL; /*头结点先指向空*/
/*循环插入新节点，并输入内容。当num变量输入0时结束*/
while (p1-》num!=0) {
n = n1+1; /*元素个数+1*/
if (n == 1) /*第1个元素时，将头结点指向p1*/
head = p1;
else /*不是第1个元素时*/
p2-》next = p1; /*p2的next指向p1，以形成连接。注意此处循环至少执行过1次，所以p2是前一个节点，p1是上次循环插入的节点*/
p2 = p1; /*将p2向后移一位，即指向上次循环插入的节点*/
p1 = (struct Student *) malloc (LEN); /*新插入一个节点，p1指向它*/
scanf ("%d,%f",&p1-》num,&p1-》score); /*为新节点输入内容*/
/*注意此时，在下一次循环中，p1新节点会与p2节点连接，*/
}
p2-next=NULL; /*循环结束时，p2即为最后一个节点，所以p2的next设置为空*/
}

c语言编程的问题动态链表的

分类: 电脑/网络》》程序设计》》其他编程语言
问题描述:

说要见一个动态链表然后任意插入一个结点怎么做啊

解析:

#include 《iostream.h》

#include 《stdio.h》

#include 《string.h》
#include 《stdlib.h》

#define LEN sizeof(struct AddressList)

struct AddressList

{

char name;

char telephone;

char e_mail;

struct AddressList *next;

};

struct AddressList * create(void);

void print(struct AddressList *p);

struct AddressList *release(struct AddressList *head);

void main()

{

struct AddressList *h;

h=create();

cin.get();

}

struct AddressList *create()

{

struct AddressList *head;

struct AddressList *p;

struct AddressList *tail;

char name;

head=NULL;

tail=NULL;

printf("请输入节点数据:\n");

printf(" 姓名:");

gets (name);

while (strcmp(name,"") !=0)

{

p=(struct AddressList *)malloc(LEN);

if(p==NULL)

{

printf("内存不足!\n");

exit(1);

}

else

{

strcpy(p-》name,name);

printf(" 电话:");

gets(p-》telephone);

printf("Email 地址:");

gets(p-》e_mail);

cout《《"内存地址为:"《《p《《endl;

if (head==NULL)

head = p;

else

tail-》next = p;

tail = p;

printf("\n请输入下一个节点数据:\n");

printf(" 姓名:");

gets(name);

}

}

if (head != NULL)

tail-》next = NULL;

printf("建立链表过程结束\n");

cin.get();

int a;

for (a=1;a《5;a++)

{

cout《《endl;

}

print(head);

for (a=1;a《5;a++)

{

cout《《endl;

}

head=release(head);

for (a=1;a《5;a++)

{

cout《《endl;

}

return head;

}

#undef LEN

void print(struct AddressList *p)

{

int i=1;

printf("\n现在输出链表数据:\n");

if(p==NULL)

{

int c;

for(c=1;c《3;c++)

{

cout《《endl;

}

printf("链表中没有数据!");

}

while(p!=NULL)

{

printf("第%d个节点的数据:\n",i);

printf(" 姓名:%s\n 电话:%s\nEmail 地址: %s\n",p-》name,p-》telephone,p-》e_mail);

p=p-》next;

i++;

cout《《"内存地址为:"《《p《《endl;

}

}

struct AddressList *release(struct AddressList *head)

{

struct AddressList *p=head;

while(p)

{

head=p-》next;

free(p);

p=head;

}

return head;

}

使用C语言创建一个动态链表

可以用头插法或尾插法
（下面用尾插法）
思想为:让你输入一串字符串,为每个字符创建一个节点,添加到链表的后面.直到输入的字符为@为止.
#include《stdio.h》
#include《malloc.h》
typedefchardatatype;
typedefstructnode
{
datatypedata;
structnode*next;
}linklist;
linklist*p,*q,*head;
main()
{
charc;
head=(linklist*)malloc(sizeof(linklist));
head-》next=null;
p=head;
c=getchar();
while(c!=’@’)
{
q=(linklist*)malloc(sizeof(linklist));
q-》data=c;
q-》next=null;
p-》next=q;
p=p-》next;
c=getchar();
}
}
可以在main()最后加上
for(p=head-》next;p!=null;p=p-》next)
{
printf("%5c",p-》data);
}
来测试结果,本人已经tc2.0下面测试通过.

C语言动态链表问题描述：学生信息包括学号、姓名、性别、语文、数学、英语插入学生信息：

# include 《stdio.h》
# include 《string.h》
# include 《stdlib.h》
struct student
{
char number;
char name;
char sex;
double score;
};
typedef struct node
{
struct student Data;
struct node *next;
} List;
void InitList(List **head);
void inputSingle(List *head);
void outputSingle(List *head);
void main()
{
List *stu;
char order;
int sel;
InitList(&stu);
do
{
printf("输入命令\n");
scanf("%s",order);
if(!strcmp(order,"Insert\0"))
sel=1;
else
if(!strcmp(order,"Quit\0")||!strcmp(order,"Exit\0"))
sel=2;
switch(sel)
{
case 1:
inputSingle(stu);
outputSingle(stu);
break;
case 2:
outputSingle(stu);
printf("Goodbye\n");
break;
}
}while(sel!=2);
}
void InitList(List **head)
{
*head=(List *)malloc(sizeof(List));
(*head)-》next=NULL;
}
void inputSingle(List *head)
{
List *p,*q=head;
while(q-》next)
q=q-》next;
p=(List *)malloc(sizeof(List));
p-》next=NULL;
scanf("%s%s %c%ld%ld%ld",p-》Data.number,p-》Data.name,&(p-》Data.sex),&(p-》Data.score));
q-》next=p;
}
void outputSingle(List *head)
{
List *p=head-》next;
while(p)
{
printf("%11s%9s%4c%5.2ld%5.2ld%5.2ld\n",p-》Data.number,p-》Data.name,(p-》Data).sex,(p-》Data).score);
p=p-》next;
}
}
建议使用float替换double