Ⅰ c语言链表原理
每个节点有一个数据域num保存该节点的数据，以及一个next域指向下一个节点的地址。假设某时刻指针p指向链表头结点，通过一个循环不停地将p赋值为p指向的节点的next域的值，即该节点的下一个节点的地址，即可遍历整个列表。
Ⅱ 怎样在C语言中正确运用链表链表的使用需要注意哪些要点
1.使用链表时候，先确认要使用的是单向链表，还是双向链表，或者是循环链表。一定要初始化。
2.添加节点时候，要注意是否队列已满。
3.删除节点的时候，要注意队列是否为空。
4.要有可以判断链表是否为空的函数。
5.要有可以判断链表节点个数的函数。
Ⅲ 如何用C语言编写一个链表
#include "stdio.h"
#include "stdlib.h"
#include "malloc.h"
struct Node
{
int data;//数据域
struct Node * next;//指针域
};
/*************************************************************************************
*函数名称:Create
*函数功能:创建链表.
*输入:各节点的data
*返回值:指针head
*************************************************************************************/
struct Node * Create()
{
struct Node *head,*p1,*p2;
head = NULL;
p1 = p2 = (struct Node *)malloc(sizeof(struct Node));
printf("Input the linklist (Input 0 to stop):\n");
scanf("%d",&p1->data);
while(p1->data!=0)
{
if(head == NULL){
head = p1;
}else{
p2->next = p1;
p2 =p1;
}
p1 = (struct Node *)malloc(sizeof(struct Node));
scanf("%d",&p1->data);
}
p2->next = NULL;
return head;
}
/*************************************************************************************
*函数名称:insert
*函数功能:在链表中插入元素.
*输入:head 链表头指针,p新元素插入位置,x 新元素中的数据域内容
*返回值:无
*************************************************************************************/
void insert(struct Node * head,int p,int x)
{
struct Node * tmp = head;
struct Node * tmp2 ;
int i ;
for(i = 0;i<p;i++)
{
if(tmp == NULL)
return ;
if(i<p-1)
tmp = tmp->next;
}
tmp2 = (struct Node *)malloc(sizeof(struct Node));
tmp2->data = x;
tmp2->next = tmp->next;
tmp->next = tmp2;
}
/**************************************************************************************
*函数名称：del
*函数功能:删除链表中的元素
*输入:head 链表头指针,p 被删除元素位置
*返回值:被删除元素中的数据域.如果删除失败返回-1
**************************************************************************************/
int del(struct Node * head,int p)
{
struct Node * tmp = head;
int ret , i;
for(i = 0;i<p;i++)
{
if(tmp == NULL)
return -1;
if(i<p-1)
tmp = tmp->next;
}
ret = tmp->next->data;
tmp->next = tmp->next->next;
return ret;
}
/**************************************************************************************
*函数名称：print
*函数功能:打印链表中的元素
*输入:head 链表头指针
*返回值:无
**************************************************************************************/
void print(struct Node *head)
{
struct Node *tmp;
for(tmp = head; tmp!=NULL; tmp = tmp->next)
printf("%d ",tmp->data);
printf("\n");
}
/**************************************************************************************
*函数名称：main
*函数功能:主函数创建链表并打印链表。
**************************************************************************************/
int main(){
struct Node * head = Create();
print(head);
return 0;
}
Ⅳ 用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);
}
Ⅳ 求解C语言数据结构链表倒序思路
循环执行下列操作：
从旧链表头部抽走一个节点
再将这个节点压入新链表头部
旧链表：1--->2--->3--->4--->
新链表：
旧链表：2--->3--->4--->
新链表：1--->
旧链表：3--->4--->
新链表：2--->1--->
旧链表：4--->
新链表：3--->2--->1--->
旧链表：
新链表：4--->3--->2--->1--->
Ⅵ 求c语言链表的详细讲解
链表是一种常见的重要的数据结构.它是动态地进行存储分配的一种结构.我们知道,用数组存放数据时,
必须事先定义固定的长度(即元素个数).比如,有的班级有100人,而有的班只有30人,如果要用同一个数组先后存放不同班级的学生数据,则必须定义长度为100的数组.如果事先难以确定一个班的最多人数,则必须把数组定得足够大,以能存放任何班级的学生数据.显然这将会浪费内存.链表则没有这种缺点,它根据需要开辟内存单元.图10.11表示最简单的一种链表(单向链表)的结构.链表有一个"头指针"变量,图中以head表示,它存放一个地址.
该地址指向一个元素.链表中每一个元素称为"结点",每个结点都应包括两个部分:一为用户需要用的实际数据,二为下一个结点的地址.课以看出,head指向第一个元素;第一个元素又指向第二个元素;……,直到最后一个元素,该元素不再指向其它元素,它称为'表尾",它的地址部分放一个"NULL"(表示"空地址").链表到此结束.
可以看到:链表中各元素在内存中可以不是连续存放的.要找某一元素,必须先找到上一个元素,根据它提供的下一元素地址才能找到下一个元素.
如果不提供"头指针"(head),则整个链表都无法访问.链表如同一条铁链一样,一环扣一环,中间是不能断开的.打个通俗的比方:幼儿园的老师带领孩子出来散步,老师牵着第一个小孩的手,第一个小孩的另一只手牵着第二个孩子,……,这就是一个"链",最后一个孩子有一只手空着,他是"链尾".要找这个队伍,必须先找到老师,然后顺序找到每一个孩子.
Ⅶ c语言链表的思路是什么，动态链表到后面的代码是什么意思
结点就是链表的基本单元。链表的结点就是一组指针的集合，这些指针中存储的是链表中其它结点的位置或者结点对应的数据的位置。
一般情况下，链表的结点存储了它的相邻结点的地址，也只有这样，它才能说是个链表，但有些链表为了便于访问其它元素，或者实现跳跃式访问，可能会存储一些特殊位置，如表头或表尾（不过正常人都会把它放在链表外，用结构体包装起来）。
链表的意义在于，可以很方便地动态管理内存，不必要求大块的连续空间。在只需增删或移动部分数据时，能提高读写效率，尤其是数据较大的排序等管理过程时，能大大提高内存处理效率，减少不必要的操作。
至于动态链表后面的代码，你是指什么？烦请具体陈述，或者给个源码，我可以给你加上注释。也可以函至[email protected]
Ⅷ C语言中链表的原理该如何使用坐等指教 多谢啦
一楼的答案很标准了，我再通俗地说明下-----你把链表看成一辆火车，火车头就是头结点，然后每节车厢有号码标识，比如1号车厢车尾就连上2号车厢车头，这就像1号节点的指针域里面存储的是下一个节点的地址，每节车厢里面容纳乘客的地方就相当于数据域。
至于链表的种类有很多，有单链表的，双连表的，循环链表的，还有有头结点和无头节点的。总之原理都大同小异。
对于链表的操作主要有插入和删除：
插入：在第i个节点之前插入一个节点：
1、首先查找第i-1个节点 if（p满足条件）
2、给新节点分配空间q =(Node*)malloc（sizeof(Node)）;给q数据域赋值。
3、q->next = p->next;
4、p->next = q;
删除：如果要删除符合条件的节点(删除q所指节点)
1、首先找到要删除节点的前驱节点 if(p->next->data满足条件)
2、用q指向要删除的节点 q = p->next;
3、p->next = q->next;
4、free(q);
说再多不如你实际操作，你可以写一个很简单的链表数据试试...
希望对你有所帮助！
Ⅸ 一道C语言中关于链表排序的代码的思路与步骤
/*代码的整体思路是分为3个函数，一个建立链表，一个链表排序，最后一个是输出链表，
而程序调用也是根据这个顺序来调用的，详细说明在下面*/
#include
#include
#define
LEN
sizeof(struct
number)
struct
number
{
int
num;
struct
number
*next;
};
int
n=0,sum=0;
void
main()
{
struct
number
*creat();
void
print(struct
number
*head);
struct
number
*change(struct
number
*head);
struct
number
*ahead;
ahead=creat();
sum+=n;
//sum计算结点的总数
change(ahead);
print(ahead);
}
struct
number
*creat()
//创建链表
{
struct
number
*p1,*p2,*head;
p1=p2=(struct
number*)malloc(LEN);
//LEN就是define定义的sizeof(struct
number)
printf("input
a
number,not
zero\n");
scanf("%d",&p1->num);
//将p1的num赋值为输入的数
while(p1->num!=0)
//如果输入的数不是0
{
n++;
//是记录链表节点的数量
if(n==1)
//如果n是建立的第一个结点，也就是链表的头
head=p1;
else
//否则p2的next指针指向p1，也就是原来链表最后一个结点的next指向新结点p1
p2->next=p1;
p2=p1;
//p2指向p1，每次p2都指向链表的结尾
p1=(struct
number*)malloc(LEN);
//申请内存，建立新结点
scanf("%d",&p1->num);
//再输入号
}
p2->next
=NULL;
//将尾结点的next指针指向NULL
return
head;
//返回头指针
}
struct
number
*change(struct
number
*head)
{
struct
number
*p,*h;
int
i;
for(i=1;i
next;p->next!=NULL;p=p->next,h=h->next)
//p指向头结点，h指向p的后一个结点,每循环一次p和h都往后指一个结点
if(p->num>h->num)
//如果前面的结点比后面结点大，就交换,只交换num的值
{
int
t;
t=p->num;
p->num=h->num;
h->num=t;
}
return
head;
}
void
print(struct
number
*head)
//链表的便利，只便利num值
{
struct
number
*p;
p=head;
while(p!=NULL)
{
printf("%d",p->num
);
p=p->next
;
}
}