1. 一道c语言链表问题
#include
#include
#define
NULL
0
#define
LEN
sizeof(struct
student)
struct
student
{
long
num;
/*学号*/
float
score;
/*分数，其他信息可以继续在下面增加字段*/
struct
student
*next;
/*指向下一节点的指针*/
};
int
n;
/*节点总数*/
/*
==========================
功能：创建节点
返回：指向链表表头的指针
==========================
*/
struct
student
*Create()
{
struct
student
*head;
/*头节点*/
struct
student
*p1=NULL;
/*p1保存创建的新节点的地址*/
struct
student
*p2=NULL;
/*p2保存原链表最后一个节点的地址*/
n
=
0;
/*创建前链表的节点总数为0：空链表*/
p1
=
(struct
student
*)malloc(LEN);
/*开辟一个新节点*/
p2
=
p1;
/*如果节点开辟成功，则p2先把它的指针保存下来以备后用*/
if
(p1
==
NULL)
/*节点开辟不成功*/
{
printf("\nCann't
create
it,
try
it
again
in
a
moment!\n");
return
NULL;
}
else
/*节点开辟成功*/
{
head
=
NULL;
/*开始head指向NULL*/
printf("Please
input
%d
node
--
num,score:
",n+1);
scanf("%ld,%f",&(p1->num),&(p1->score));
/*录入数据*/
}
while(p1->num
!=
0)
/*只要学号不为0，就继续录入下一个节点*/
{
n
+=
1;
/*节点总数增加1个*/
if
(n==1)
/*如果节点总数是1，则head指向刚创建的节点p1*/
{
head
=
p1;
/*
注意：
此时的p2就是p1,也就是p1->next指向NULL。
这样写目的是与下面else保持一致。
*/
p2->next
=
NULL;
}
else
{
p2->next
=
p1;
/*指向上次下面刚开辟的节点*/
}
p2
=
p1;
/*把p1的地址给p2保留，然后p1去产生新节点*/
p1
=
(struct
student
*)malloc(LEN);
printf("Please
input
%d
node
--
num,score:
",n+1);
scanf("%ld,%f",&(p1->num),&(p1->score));
}
p2->next
=
NULL;
/*此句就是根据单向链表的最后一个节点要指向NULL*/
free(p1);
/*释放p1。用malloc()、calloc()的变量都要free()*/
p1
=
NULL;
/*特别不要忘记把释放的变量清空置为NULL,否则就变成"野指针"，即地址不确定的指针。*/
return
head;
/*返回创建链表的头指针*/
}
/*
===========================
功能：输出节点
返回：
void
===========================
*/
void
Print(struct
student
*head)
{
struct
student
*p;
printf("\nNow
,
These
%d
records
are:\n",n);
p
=
head;
if(head
!=
NULL)
/*只要不是空链表，就输出链表中所有节点*/
{
printf("head
is
%o\n",
head);
/*输出头指针指向的地址*/
do
{
/*
输出相应的值：当前节点地址、各字段值、当前节点的下一节点地址。
这样输出便于读者形象看到一个单向链表在计算机中的存储结构，和我们
设计的图示是一模一样的。
*/
printf("%o
%ld
%5.1f
%o\n",
p,
p->num,
p->score,
p->next);
p
=
p->next;
/*移到下一个节点*/
}
while
(p
!=
NULL);
}
}
/*
==========================
功能：删除指定节点
(此例中是删除指定学号的节点)
返回：指向链表表头的指针
==========================
*/
/*
单向链表的删除图示：
---->[NULL]
head
图3：空链表
从图3可知，空链表显然不能删除
---->[1]---->[2]...---->[n]---->[NULL]（原链表）
head
1->next
2->next
n->next
---->[2]...---->[n]---->[NULL]（删除后链表）
head
2->next
n->next
图4：有N个节点的链表，删除第一个节点
结合原链表和删除后的链表，就很容易写出相应的代码。操作方法如下：
1、你要明白head就是第1个节点，head->next就是第2个节点；
2、删除后head指向第2个节点，就是让head=head->next,OK这样就行了。
---->[1]---->[2]---->[3]...---->[n]---->[NULL]（原链表）
head
1->next
2->next
3->next
n->next
---->[1]---->[3]...---->[n]---->[NULL]（删除后链表）
head
1->next
3->next
n->next
图5：有N个节点的链表，删除中间一个（这里图示删除第2个）
结合原链表和删除后的链表，就很容易写出相应的代码。操作方法如下：
1、你要明白head就是第1个节点，1->next就是第2个节点，2->next就是第3个节点；
2、删除后2，1指向第3个节点，就是让1->next=2->next。
*/
struct
student
*Del(struct
student
*head,
long
num)
{
struct
student
*p1;
/*p1保存当前需要检查的节点的地址*/
struct
student
*p2;
/*p2保存当前检查过的节点的地址*/
if
(head
==
NULL)
/*是空链表（结合图3理解）*/
{
printf("\nList
is
null!\n");
return
head;
}
/*定位要删除的节点*/
p1
=
head;
while
(p1->num
!=
num
&&
p1->next
!=
NULL)
/*p1指向的节点不是所要查找的，并且它不是最后一个节点，就继续往下找*/
{
p2
=
p1;
/*保存当前节点的地址*/
p1
=
p1->next;
/*后移一个节点*/
}
if
(num
==
p1->num)
/*找到了。（结合图4、5理解）*/
{
if
(p1
==
head)
/*如果要删除的节点是第一个节点*/
{
head
=
p1->next;
/*头指针指向第一个节点的后一个节点，也就是第二个节点。这样第一个节点就不在链表中，即删除。*/
}
else
/*如果是其它节点，则让原来指向当前节点的指针，指向它的下一个节点，完成删除*/
{
p2->next
=
p1->next;
}
free(p1);
/*释放当前节点*/
p1
=
NULL;
printf("\ndelete
%ld
success!\n",num);
n
-=
1;
/*节点总数减1个*/
}
else
/*没有找到*/
{
printf("\n%ld
not
been
found!\n",num);
}
return
head;
}
/*
==========================
功能：插入指定节点的后面
(此例中是指定学号的节点)
返回：指向链表表头的指针
==========================
*/
/*
单向链表的插入图示：
---->[NULL]（原链表）
head
---->[1]---->[NULL]（插入后的链表）
head
1->next
图7
空链表插入一个节点
结合原链表和插入后的链表，就很容易写出相应的代码。操作方法如下：
1、你要明白空链表head指向NULL就是head=NULL；
2、插入后head指向第1个节点，就是让head=1,1->next=NULL,OK这样就行了。
---->[1]---->[2]---->[3]...---->[n]---->[NULL]（原链表）
head
1->next
2->next
3->next
n->next
---->[1]---->[2]---->[x]---->[3]...---->[n]---->[NULL]（插入后的链表）
head
1->next
2->next
x->next
3->next
n->next
图8：有N个节点的链表，插入一个节点（这里图示插入第2个后面）
结合原链表和插入后的链表，就很容易写出相应的代码。操作方法如下：
1、你要明白原1->next就是节点2，2->next就是节点3；
2、插入后x指向第3个节点,2指向x，就是让x->next=2->next,1->next=x。
*/
struct
student
*Insert(struct
student
*head,
long
num,
struct
student
*node)
{
struct
student
*p1;
/*p1保存当前需要检查的节点的地址*/
if
(head
==
NULL)
/*（结合图示7理解）*/
{
head
=
node;
node->next
=
NULL;
n
+=
1;
return
head;
}
p1
=
head;
while
(p1->num
!=
num
&&
p1->next
!=
NULL)
/*p1指向的节点不是所要查找的，并且它不是最后一个节点，继续往下找*/
{
p1
=
p1->next;
/*后移一个节点*/
}
if
(num
==
p1->num)
/*找到了（结合图示8理解）*/
{
node->next
=
p1->next;
/*显然node的下一节点是原p1的next*/
p1->next
=
node;
/*插入后，原p1的下一节点就是要插入的node*/
n
+=
1;
/*节点总数增加1个*/
}
else
{
printf("\n%ld
not
been
found!\n",num);
}
return
head;
}
/*
==========================
功能：反序节点
(链表的头变成链表的尾，链表的尾变成头)
返回：指向链表表头的指针
==========================
*/
/*
单向链表的反序图示：
---->[1]---->[2]---->[3]...---->[n]---->[NULL]（原链表）
head
1->next
2->next
3->next
n->next
[NULL]next
2->next
3->next
n->next
head
图9：有N个节点的链表反序
结合原链表和插入后的链表，就很容易写出相应的代码。操作方法如下：
1、我们需要一个读原链表的指针p2,存反序链表的p1=NULL（刚好最后一个节点的next为NULL）,还有一个临时存储变量p；
2、p2在原链表中读出一个节点，我们就把它放到p1中，p就是用来处理节点放置顺序的问题；
3、比如，现在我们取得一个2,为了我们继续往下取节点，我们必须保存它的next值，由原链表可知p=2->next;
4、然后由反序后的链表可知，反序后2->next要指向1，则2->next=1;
5、好了，现在已经反序一个节点，接着处理下一个节点就需要保存此时的信息：
p1变成刚刚加入的2，即p1=2;p2要变成它的下一节点，就是上面我们保存的p,即p2=p。
*/
struct
student
*Reverse(struct
student
*head)
{
struct
student
*p;
/*临时存储*/
struct
student
*p1;
/*存储返回结果*/
struct
student
*p2;
/*源结果节点一个一个取*/
p1
=
NULL;
/*开始颠倒时，已颠倒的部分为空*/
p2
=
head;
/*p2指向链表的头节点*/
while
(p2
!=
NULL)
{
p
=
p2->next;
p2->next
=
p1;
p1
=
p2;
p2
=
p;
}
head
=
p1;
return
head;
}
/*
以上函数的测试程序：
提示：根据测试函数的不同注释相应的程序段，这也是一种测试方法。
*/
main()
{
struct
student
*head;
struct
student
*stu;
long
thenumber;
/*
测试Create()、Print()*/
head
=
Create();
Print(head);
/*测试Del():请编译时去掉注释块*/
/*
printf("\nWhich
one
delete:
");
scanf("%ld",&thenumber);
head
=
Del(head,thenumber);
Print(head);
*/
/*测试Insert():请编译时去掉注释块*/
/*
stu
=
(struct
student
*)malloc(LEN);
printf("\nPlease
input
insert
node
--
num,score:
");
scanf("%ld,%f",&stu->num,&stu->score);
printf("\nInsert
behind
num:
");
scanf("%ld",&thenumber);
head
=
Insert(head,thenumber,stu);
free(stu);
stu
=
NULL;
Print(head);
*/
/*测试Reverse():请编译时去掉注释块*/
/*
head
=
Reverse(head);
Print(head);
*/
printf("\n");
system("pause");
}
2. c语言链表看不懂，while语句后边开始，求帮助，最好有示意图配解释，谢谢谢谢
这就是个头插法建立链表的代码，不过写的不好！
structStudent*head,*new;
head=NULL;
new=malloc();
scanf("%s",new->name);
scanf("%d",&new->number);
while(new->number!=0)//当输入的number值不为0时循环
{
new->next=head;//新结点的后继指向head你就当head是一个链表的头，后面有很多数据结点
head=new;//新结点成为新的head，这样一个一个的就串起来了！
new=malloc();//继续申请结点
scanf("%s",new->name);//读入数据
scanf("%d",&new->number);
}
不知道你看的是哪里的书，程序写的真不咋地
3. 讲这个c语言while(NULL!=p->next)翻译成中文
默认：指针p指向一个含有next指针变量的结构，并且next指针和p指针的类型一致，一般用于链表结构指向下一个链表节点。
当p指针指向的结构中next变量不为NULL时循环
换句话说，如果是在链表中，当p指向节点的后续节点存在时继续循环，当没有后续节点时停止循环。
4. C语言链表输出，while(p)是什么意思怎么判断完成输入了
while(p)
等价于
while(p!=NULL)
如果p不指向NULL，那么就是没有到达结尾，那么就执行循环体中的printf()
5. 关于c语言链表
因为你只创建了一个啊，你的本意是用create函数执行创建链表的工作，不管多少个都是由它完成的，但是你的create函数明明没有while循环或者dowhile循环啊，只做了一遍啊，第一遍的if做完了，第一个链表完成了，再次scanf了之后，就退出来了啊，在你创建了一个链表之后，就在那个链表的尾部写入NULL了，程序就结束了啊，又没一直做scanf，和创建链表的工作。create没循环啊，打印链表是没错啊，输出了第一个啊，你自己创建的第一个叫head，只有后面的链接，自己本身没有存放任何数，只输出了第二个链表，第二链表的next就是NULL了，输出当然就停止了啊。
怕我没说清楚，或者把你绕晕了，所以我截个图给你看。
你这个if只做了一遍啊，没有循环啊，然后就再次用scanf了，然后呢？然后就退出if了吧，然后就执行了r->next=NULL;对吧，r不就是你创建的第一个有数据的链表吗？然后就return h了，那么只有一个啊，有循环吗？scanf了之后，也没判断数值啊，不是-1，应该继续做啊。
解决方案：在这个if的外面，加一个do while的循环，然后判断scanf读入的n的值，应该就可以了。
6. 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，当然你也可以指向开头一个数据块形成一个循环链表。
7. C语言结构体链表逆置中这个代码的while循环什么时候终止
尽管程序不全，没有看到pa变量的类型，但是，仍然可以判定当pa变量的值为0时while循环终止。
在c语言中，常量NULL的值就是0。也就是说，当pa的值是NULL时，循环就终止了。
有什么问题请留言
8. 用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);
}
9. c语言中if和while 有什么区别
区别：
一、if和while共同点是都有判断。
二、if和while不同点是，if后的语句只执行一次，while则会循环执行，直到出现while后的条件成才退出。
三、语法不同：
1、IF（logical＿test，value＿if＿true，value＿if＿false）
2、while＜条件＞do＜语句＞
意为当条件符合时，接着做下面的语句；不符合时，退出循环。
四、功能不同：
1、IF函数是条件判断函数：如果指定条件的计算结果为TRUE，IF函数将返回某个值；如果该条件的计算结果为FALSE，则返回另一个值。
例如IF（测试条件，结果1，结果2），即如果满足“测试条件”则显示“结果1”，如果不满足“测试条件”则显示“结果2”。
2、while循环也被称为“当”型循环。即当条件为真时，执行循环体中。在R语言中，while循环的语法格式如下：while（cond）｛expr｝其中，cond是一个逻辑条件表达式，其值应为TRUE或FALSE；expr是循环体中的语句，即当cond条件为TRUE时要执行的表达式或若干语句。
例如：
1、if用来做条件判断
if用来做条件判断，与else搭配使用。在if条件判断中，若逻辑条件表达式为真，则运行语句或语句块；如果逻辑条件表达式为假，则跳过语句；
例如，超过五点下班走人，否则就继续上班。在这里＆ldquo；时间＆rdquo；就是判断条件，时间就是下班或者上班只要时间超过五点，即判断条件为真，则执行的事件就是下班，else语句不再执行，即不再执行上班语句；只要事件没有超过五点，则执行上班语句。
2、while是循环语句
在C语言中通常用while来表示循环，例如在main（）函数中一般都用while（1）来让主程序循环执行。即在逻辑条件表达式为真的情况下，while反复执行循环体内包含的语句或语句块，直到条件不成立。
例如：天气如果是下雨就执行睡觉指令，直到不下雨为止；如阴天、晴天或者下雪等其他天气就不执行睡觉指令。
4、if语句叫做选择语句，一般和else一起使用。判断条件是否成立，成立则执行if后面的分支，不成立则执行else后面的分支。执行完毕则转入下条语句。
while语句叫做循环语句。同样是判断条件是否成立。但是执行完毕后继续判断该条件，直到该条件不成立则转入下一条语句。
对于一个假条件，两者的执行情况是一致的。对于一个真条件，执行完毕后if语句就顺序执行下一条，while还要继续判断和执行。这就是两者的不同吧。
对于while语句，必须要在执行语句中设置改变判断条件结果的语句或者设置跳出语句以避免陷入死循环。