C语言链表秒懂

最新推荐文章于 2023-09-21 20:29:17 发布
最新推荐文章于 2023-09-21 20:29:17 发布
阅读量557 收藏 6
点赞数 5
分类专栏： 链表 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46396470/article/details/117742437
版权

C语言链表 秒懂

讲解之前弄清两个概念：

顺序表：是在计算机内存中以数组的形式保存的线性表
特点：
1、存储单元的地址连续
2、逻辑结构上相邻的数据元素存储在相邻的物理存储单元

链表 ：
特点：
1、物理存储单元上非连续、非顺序
2、数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
3、链表由一系列结点（链表中每一个元素称为结点）组成
4、结点可以在运行时动态生成。

每个结点包括两个部分：
1：存储数据的数据域
2：存储下一个结点地址的指针域。

由以上引出：顺序表和链表统称为线性表

链表和顺序表分别对应链式存储结构与顺序存储结构

顺序存储结构：所有的元素地址都相邻。如图：
在这里插入图片描述

    此前我们学习的数组叫顺序表，何为顺序，数组的元素的地址 在内存中是连续的、顺序的。
     如：a[0]的地址和a[1]的地址是挨在一块的。在这里插入图片描述
链表和顺序表的区别
在这里插入图片描述
进入正题之前，介绍一下链表的种类
在这里插入图片描述
    本次讲解包括单向链表、双向链表和循环链表，前两种链表的区别在于能否双向移动指针。循环链表是单向链表或双向链表通过将头结点和表尾结点连接起来的链表。

看一下对比图吧：
在这里插入图片描述
其中单向链表的创建分头插法和尾插法，区别在于：
1、尾插法第一个创建的结点就是头结点，而头插法相反，第一个创建的结点是表尾结点，最后一个创建的结点是头结点。

进入正题：

单向链表

尾插法

创建

：新创建的结点永远是链表的尾巴，尾插法含有头结点。 1、定义如下框架： 
#include<stdio.h>
#include<stdlib.h>
struct Node{
	int data;//存放数据
	struct Node *next;//指向下一个结点的指针，见名知意
};

struct Node *creat(void)//创建链表，返回链表头结点
{
	
}

int main(void)
{
	struct Node *head;
	return 0;
}

2、creat函数内定义三个指针

struct Node *head,*left,*right;

    head保存头结点指针；right指向新创建的结点，即表尾；left指向新结点的前一个结点

3、动态内存内配语句

(struct Node *)malloc(sizeof(struct Node));
//malloc函数返回值为 void *，通过(struct Node *)使指针变量能正确接收；
//sizeof(struct Node)目的使分配一个内存块，其大小为结构体Node的大小

则新结点赋值语句为：

right=(struct Node *)malloc(sizeof(struct Node));//使right指向新结点

    假如现在right和left都正确指向不同的结点，那么请问怎么将两结点连接起来呢？
在这里插入图片描述
正确语句：

left->next=right;//链接最后一个结点和它的前一个结点

图示：
在这里插入图片描述

    那么问题又来了，我再创建一个新结点，由要怎么连接呢，用left->next=right; 还行吗？
如图：
在这里插入图片描述

    答案是否定的，因为left不再是新结点的前一个结点了，如果执行：left->next=right;，那么中间的结点就会丢失，而将倒数第三个和最新的结点连接起来了，那么要怎么保持left一直是倒数第二个结点呢？

    那就要在链接了最新结点和前一结点后，立即让left指向最后一个结点，那么新分配结点时，left就保持了指向新结点的前一结点。
联合上一步得代码：

left->next=right;//连接
left=right;//left回到这一次的最后结点，下一次的前一结点

如图：
在这里插入图片描述
    综上几个步骤，完整的创建新结点，链接结点，更新left指针已经完成，则完整过程如图所示：
在这里插入图片描述

代码展示：

right=(struct Node *)malloc(sizeof(struct Node));//使right指向新结点
left->next=right;//链接最后一个结点和它的前一个结点
left=right;//left回到这一次的最后结点，下一次的前一结点

    以上代码基本上可以实现链表的建立，但是，还有一个问题要处理，怎样确定头结点呢？
    可以用一个if语句来确定头结点
    第一次判断，如果head指针为空，那么就将第一个创建的结点赋给head否则就执行left->next=right;进行连接，然后更新就可以了。
    以上步骤只能通过增加语句来添加新结点，那么怎么用相同的一组语句建立拥有若干个结点的链表呢？
    是的，用循环来完成

看代码：

while(judge==1)//确定是否进入循环，创建链表
	{
		right=(struct Node *)malloc(sizeof(struct Node));//使right指向新结点
		scanf("%d",&right->data);//输入节点数据
		if(head==NULL)//head为空，那么是第一次进循环，则将创建的节点作为头结点
			head=right;//将第一个结点赋给头结点指针
		else
			left->next=right;//链接最后一个结点和它的前一个结点
		left=right;//left回到这一次的最后结点，下一次的前一结点
		puts("\n\ndo you want to continue  1 or 0");
		scanf("%d",&judge);//询问用户是否继续创建，1继续，0停止
	}

    做事有始有终，链表需要有结束标志，这个标志就是：NULL（空指针），通过上面的循环语句可知，结束循环后right指针永远是指向最后一个节点的，所以收尾就由它来完成，收尾语句：

right->next=NULL;

至此，所有步骤讲解完成，接下来，我们用完整代码展示创建步骤：

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

struct Node{
	int data;//存放数据
	struct Node *next;//指向下一个结点的指针，见名知意
};

struct Node *creat(void);

struct Node *creat(void)//创建链表，返回链表头结点
{
	struct Node *head,*left,*right;//定义3结构体指针
	head=left=right=NULL;//全赋空值
	int judge;//循环决定性变量
	puts("do you want to continue  1 or 0");
	scanf("%d",&judge);
	while(judge==1)//确定是否进入循环，创建链表
	{
		right=(struct Node *)malloc(sizeof(struct Node));//使right指向新结点
		scanf("%d",&right->data);//输入节点数据
		if(head==NULL)//head为空，那么是第一次进循环，则将创建的节点作为头结点
			head=right;//将第一个结点赋给头结点指针
		else
			left->next=right;//链接最后一个结点和它的前一个结点
		left=right;//left回到这一次的最后结点，下一次的前一结点
		puts("\n\ndo you want to continue  1 or 0");
		scanf("%d",&judge);//询问用户是否继续创建，1继续，0停止
	}
	right->next=NULL;//链表收尾
	return head;//返回头指针
}

int main(void)
{
	struct Node *head;
	head=creat();//接收头指针
	return 0;
}

运行结果：
在这里插入图片描述

插入结点

    明白链表的创建了，我们进一步学习在已创建的链表中插入一个结点。
先分析一张图：
在这里插入图片描述
通过这张图解，我相信大家已经明白怎样插入的了
    1、先让s的next指向left的next，也就是s的next指向right
在这里插入图片描述

    2、left的next指向s
在这里插入图片描述
这样就能够插入在left和right之间了，看代码:

s->next=left->next;
left->next=s;

还要解决一个问题：怎样保存left和right的值？
答：1、首先left和right应指向同一节点
    2、再让right指向下一节点
在这里插入图片描述

如果你明白了，那么我们来写一个插入节点的函数：

struct Node *insert(struct Node *head)
{
	struct Node *left,*right,*s;//s为新结点指针
	int ist;
	right=head;
	s=(struct Node *)malloc(sizeof(struct Node));
	if(s==NULL)//如果内存分配失败则退出程序
	{
		puts("插入失败\n");
		return NULL;
	}
	puts("input the data of new node");
	scanf("%d",&s->data);//新节点的数据
	puts("input the data of searching");
	scanf("%d",&ist);//要寻找的节点的数据
	while((right!=NULL)&&(right->data!=ist))//找到节点，或没找到退出循环
	{
		left=right;//指向同一结点
		right=right->next;//right移动至下一结点，则left和right就一前一后了
	}
	if(head==NULL)//本身是空表的情况
		return s;//s作为头结点,也是表中唯一结点
	else if(head==right)
	{
		s->next=head;//s作为头结点
		return s;//返回s作为新的头指针
	}
	else if(right==NULL)//没找到数据为ist的结点
	{
		left->next=s;//新结点作为表尾结点
		s->next=NULL;//添加链表结束标志
	}
	else//找到ist的情况
	{
		s->next=left->next;//连接s和right
		left->next=s;//连接left和s
	}
	return head;//返回插入后的头指针
}

运行结果：
在这里插入图片描述

删除结点

    删除和插入类似，比插入简单, 确定left和right位置后，仅仅需要 一条连接语句和 一条释放内存语句即可完成删除. 
left->next=right->next;//left的next跨越right，连接right->next;
free(right);//释放right，完成删除。

在这里插入图片描述
    接下来我们来写一个删除函数夯实学习成果；

struct Node *delet(struct Node *head)
{
	struct Node *left,*right;
	int ist;
	right=left=head;
	puts("input the data of deleting");
	scanf("%d",&ist);//要删除的结点的数据
	while((right!=NULL)&&(right->data!=ist))//找到节点，或没找到退出循环
	{
		left=right;//指向同一结点
		right=right->next;//right移动至下一结点，则left和right就一前一后了
	}
	
	if((head==NULL))//空表或头结点就是待删除的结点的情况
	{
		return NULL;//返回空表
	}
	else if(right==head)//表头为要删除的结点 
	{
		struct Node *T=right->next;
		free(right); 
		return T;//要是表头为要删除的结点，则后一个结点作为新表头 
	}
	else if(right==NULL)//没找到数据为ist的结点
	{
		return head;//没有要删除的，退出；
	}
	else//找到ist的情况
	{
		left->next=right->next;//left的next跨越right，连接right->next;
		free(right);//释放right，完成删除。
	}
	return head;//返回删除后的头结点
}

运行结果：
在这里插入图片描述

最后，我们整合创建，插入，删除于一体，将完整版代码粘贴出来

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

struct Node{
	int data;//存放数据
	struct Node *next;//指向下一个结点的指针，见名知意
};

struct Node *creat(void);
struct Node *insert(struct Node * head);
struct Node *delet(struct Node *head);
void print(struct Node *head);

struct Node *creat(void)//创建链表，返回链表头结点
{
	struct Node *head,*left,*right;//定义3结构体指针
	head=left=right=NULL;//全赋空值
	int judge;//循环决定性变量
	puts("do you want to continue  1 or 0");
	scanf("%d",&judge);
	while(judge==1)//确定是否进入循环，创建链表
	{
		right=(struct Node *)malloc(sizeof(struct Node));//使right指向新结点
		scanf("%d",&right->data);//输入节点数据
		if(head==NULL)//head为空，那么是第一次进循环，则将创建的节点作为头结点
			head=right;//将第一个结点赋给头结点指针
		else
			left->next=right;//链接最后一个结点和它的前一个结点
		left=right;//left回到这一次的最后结点，下一次的前一结点
		puts("\n\ndo you want to continue  1 or 0");
		scanf("%d",&judge);//询问用户是否继续创建，1继续，0停止
	}
	right->next=NULL;//链表收尾
	return head;//返回头指针
}

struct Node *insert(struct Node *head)
{
	struct Node *left,*right,*s;//s为新结点指针
	int ist;
	right=head;
	s=(struct Node *)malloc(sizeof(struct Node));
	if(s==NULL)//如果内存分配失败则退出程序
	{
		puts("插入失败\n");
		return NULL;
	}
	puts("input the data of new node");
	scanf("%d",&s->data);//新节点的数据
	puts("input the data of searching");
	scanf("%d",&ist);//要寻找的节点的数据
	while((right!=NULL)&&(right->data!=ist))//找到节点，或没找到退出循环
	{
		left=right;//指向同一结点
		right=right->next;//right移动至下一结点，则left和right就一前一后了
	}
	if(head==NULL)//本身是空表的情况
		return s;//s作为头结点
	else if(head==right)
	{
		s->next=head;//s作为头结点
		return s;//返回s作为新的头指针
	}
	else if(right==NULL)//没找到数据为ist的结点
	{
		left->next=s;//新结点作为表尾结点
		s->next=NULL;//添加链表结束标志
	}
	else//找到ist的情况
	{
		s->next=left->next;//连接s和right
		left->next=s;//连接left和s
	}
	return head;//返回插入后的头指针
}
struct Node *delet(struct Node *head)
{
	struct Node *left,*right;
	int ist;
	right=left=head;
	puts("input the data of deleting");
	scanf("%d",&ist);//要删除的结点的数据
	while((right!=NULL)&&(right->data!=ist))//找到节点，或没找到退出循环
	{
		left=right;//指向同一结点
		right=right->next;//right移动至下一结点，则left和right就一前一后了
	}
	
	if((head==NULL))//空表或头结点就是待删除的结点的情况
	{
		return NULL;//返回空表
	}
	else if(right==head)//表头为要删除的结点 
	{
		struct Node *T=right->next;
		free(right); 
		return T;//要是表头为要删除的结点，则后一个结点作为新表头 
	}
	else if(right==NULL)//没找到数据为ist的结点
	{
		return head;//没有要删除的，退出；
	}
	else//找到ist的情况
	{
		left->next=right->next;//left的next跨越right，连接right->next;
		free(right);//释放right，完成删除。
	}
	return head;//返回删除后的头结点
}

void print(struct Node *head)
{
	while(head)
	{
		printf("%d ",head->data);
		head=head->next;
	}
}
int main(void)
{
	
	struct Node *head;
	puts("创建节点：");
	head=creat();//接收头指针
	puts("\n\n插入节点：");
	head=insert(head);
	puts("\n\n删除节点：");
	head=delet(head);
	if(head) //非空表则打印
	{	puts("\n\n最后链表：");
		print(head);
	}	
	return 0;
}

运行结果如图：
在这里插入图片描述
一口气写这么多，挺辛苦的，先休息会
在这里插入图片描述

头插法

    头插法是倒序链表，最早添加的结点，在创建完成链表后，变成表尾,最后创建的结点称为表头

创建

对比尾插法和头插法代码 
left->next=right;//尾插法

right->next=left;//头插法

在这里插入图片描述

    有了尾插法的基础我们直接来看代码部分吧！

struct Node *creat(void)//创建链表，返回链表头结点
{
	struct Node *left,*right;左指针，右指针（最新结点）
	left=right=NULL;//全赋空值
	int judge;//循环决定性变量
	puts("do you want to continue  1 or 0");
	scanf("%d",&judge);
	while(judge==1)//确定是否进入循环，创建链表
	{
		right=(struct Node *)malloc(sizeof(struct Node));//使right指向新结点
		scanf("%d",&right->data);//输入节点数据
		right->next=left;//链接最后一个结点和它的前一个结点
		left=right;//left回到这一次的最后结点，下一次的前一结点
		puts("\n\ndo you want to continue  1 or 0");
		scanf("%d",&judge);//询问用户是否继续创建，1继续，0停止
	}
	return right;//返回头指针
}

运行结果：
在这里插入图片描述

插入结点

    头插法与尾插法插入相同，这里要注意，之所以插入语句相同，是因为，left和right始终保持一前一后状态

这里看图可能有些别扭，因为是在头插创建的链表的基础上从后往前看的，left一端为表头端。

在这里插入图片描述

s->next=left->next;//头插法，插入语句
left->next=s;//完成插入

还可以是：

s->next=right;//right和left->next是指向同一结点，所以可以这样替换
left->next=s;

代码：

struct Node *insert(struct Node *head)
{
	struct Node *left,*right,*s;//s为新结点指针
	int ist;
	right=head;
	s=(struct Node *)malloc(sizeof(struct Node));
	if(s==NULL)//如果内存分配失败则退出程序
	{
		puts("插入失败\n");
		return NULL;
	}
	puts("input the data of new node");
	scanf("%d",&s->data);//新节点的数据
	puts("input the data of searching");
	scanf("%d",&ist);//要寻找的节点的数据
	while((right!=NULL)&&(right->data!=ist))//找到节点，或没找到退出循环
	{
		left=right;//指向同一结点
		right=right->next;//right移动至下一结点，则left和right就一前一后了
	}
	if(head==NULL)//本身是空表的情况
		return s;//s作为头结点
	else if(head==right)
	{
		s->next=head;//s作为头结点
		return s;//返回s作为新的头指针
	}
	else if(right==NULL)//没找到数据为ist的结点
	{
		left->next=s;//新结点作为表尾结点
		s->next=NULL;//添加链表结束标志
	}
	else//找到ist的情况
	{
		s->next=left->next;//连接s和right
		left->next=s;//连接left和s
	}
	return head;
}

运行结果：

在这里插入图片描述

删除结点
    与尾插法同理，什么都不变，仅仅看图有点别扭。
在这里插入图片描述

struct Node *delet(struct Node *head)
{
	struct Node *left,*right;
	int ist;
	right=left=head;
	puts("input the data of deleting");
	scanf("%d",&ist);//要删除的结点的数据
	while((right!=NULL)&&(right->data!=ist))//找到节点，或没找到退出循环
	{
		left=right;//指向同一结点
		right=right->next;//right移动至下一结点，则left和right就一前一后了
	}
	
	if((head==NULL))//空表的情况
	{
		return NULL;//返回空表
	}
	else if(right==head)//头结点为要删除结点 
	{
		struct Node *p=right->next;
		free(right);
		return p; 
	}
	else if(right==NULL)//没找到数据为ist的结点
	{
		return head;//没有要删除的，退出；
	}
	else//找到ist的情况
	{
		left->next=right->next;//left的next跨越right，连接right->next;
		free(right);//释放right，完成删除。
	}
	return head;//返回删除后的头结点
}

运行结果：
在这里插入图片描述

接下来，结三部分于一体，看一下头插法的完整部分代码：

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

struct Node{
	int data;//存放数据
	struct Node *next;//指向下一个结点的指针，见名知意
};

struct Node *creat(void);
struct Node *insert(struct Node * head);
struct Node *delet(struct Node *head);
void print(struct Node *head);

struct Node *creat(void)//创建链表，返回链表头结点
{
	struct Node *left,*right;左指针，右指针（最新结点）
	left=right=NULL;//全赋空值
	int judge;//循环决定性变量
	puts("do you want to continue  1 or 0");
	scanf("%d",&judge);
	while(judge==1)//确定是否进入循环，创建链表
	{
		right=(struct Node *)malloc(sizeof(struct Node));//使right指向新结点
		scanf("%d",&right->data);//输入节点数据
		right->next=left;//链接最后一个结点和它的前一个结点
		left=right;//left回到这一次的最后结点，下一次的前一结点
		puts("\n\ndo you want to continue  1 or 0");
		scanf("%d",&judge);//询问用户是否继续创建，1继续，0停止
	}
	return right;//返回头指针
}

struct Node *insert(struct Node *head)
{
	struct Node *left,*right,*s;//s为新结点指针
	int ist;
	right=head;
	s=(struct Node *)malloc(sizeof(struct Node));
	if(s==NULL)//如果内存分配失败则退出程序
	{
		puts("插入失败\n");
		return NULL;
	}
	puts("input the data of new node");
	scanf("%d",&s->data);//新节点的数据
	puts("input the data of searching");
	scanf("%d",&ist);//要寻找的节点的数据
	while((right!=NULL)&&(right->data!=ist))//找到节点，或没找到退出循环
	{
		left=right;//指向同一结点
		right=right->next;//right移动至下一结点，则left和right就一前一后了
	}
	if(head==NULL)//本身是空表的情况
		return s;//s作为头结点
	else if(head==right)
	{
		s->next=head;//s作为头结点
		return s;//返回s作为新的头指针
	}
	else if(right==NULL)//没找到数据为ist的结点
	{
		left->next=s;//新结点作为表尾结点
		s->next=NULL;//添加链表结束标志
	}
	else//找到ist的情况
	{
		s->next=left->next;//连接s和right
		left->next=s;//连接left和s
	}
	return head;
}

struct Node *delet(struct Node *head)
{
	struct Node *left,*right;
	int ist;
	right=left=head;
	puts("input the data of deleting");
	scanf("%d",&ist);//要删除的结点的数据
	while((right!=NULL)&&(right->data!=ist))//找到节点，或没找到退出循环
	{
		left=right;//指向同一结点
		right=right->next;//right移动至下一结点，则left和right就一前一后了
	}
	
	if((head==NULL))//空表或头结点就是待删除的结点的情况
	{
		struct Node *p=right->next;
		free(right);
		return p;//返回空表
	}
	else if(right==head)//头结点为要删除结点 
	{
		struct Node *p=right->next;
		free(right);
		return p; 
	}
	else if(right==NULL)//没找到数据为ist的结点
	{
		return head;//没有要删除的，退出；
	}
	else//找到ist的情况
	{
		left->next=right->next;//left的next跨越right，连接right->next;
		free(right);//释放right，完成删除。
	}
	return head;//返回删除后的头结点
}

void print(struct Node *head)
{
	while(head)
	{
		printf("%d ",head->data);
		head=head->next;
	}
}
int main(void)
{
	
	struct Node *head;
	puts("创建节点：");
	head=creat();//接收头指针
	puts("\n\n插入节点：");
	head=insert(head);
	puts("\n\n删除节点：");
	head=delet(head);
	if(head!=NULL)
	{
		puts("\n\n最后链表：");
		print(head);
	}
	return 0;
}

运行结果：

在这里插入图片描述

郑重声明：
1、学者水平有限，若有不足之处，请指出。
2、未经允许，转载请贴上出处
3、本人系中职生，时间有限（对口高考），所以接下来的循环链表和双向链表可能会停更，若更新也至少得7月份往后。

完结

Midsummer-逐梦
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言链表题目（附答案）.docx
08-07
大一初学C语言时的期末作业，涉及到链表的建立和功能的实现，涉及指针、函数、动态结构建立等方面的知识，初学者可以参考参考尝试尝试哟！！！
关于数组首地址a、a+1、a[0]、&a[0]+1、*a、*&a、a+0的解析
weixin_44690490的博客
05-14 2794
有一个数组： Int a[]={1,2,3,4}; 例如，sizeof(a),很明显它的结果是16，这个a就表示的是整个数组的大小，那么有 a+1: 表示数组a的第二个元素即a[1]的地址 a+0： a[0]的地址 a[0]: a[0]的地址 &a+1: 下一个数组的地址 &a[0]+1: a[1]的地址 *a: a[0]的大小 ...
单向链表的基本操作
weixin_52358343的博客
09-29 750
链表通常是单向链表，它包含多个结点，每个结点有一个指向后继元素的next（下一个）指针。表中最后一个结点的next指针为NULL，表示该链表结束。 链表的类型声明： public class ListNode { private int data; private ListNode next; public ListNode(int data) { this.data = data; } public in...
数据结构--单链表
m0_59052131的博客
11-22 1187
由于顺序表的插入删除操作需要移动大量的元素，影响了运行效率，因此引入了线性表的链式存储——。单链表通过一组任意的存储单元来存储线性表中的数据元素，不需要使用地址连续的存储单元，因此它不要求在逻辑上相邻的两个元素在物理位置上也相邻。
数据结构实验之链表三：链表的逆置
gdg_dys的博客
03-02 419
点击获取原题链接数据结构实验之链表三：链表的逆置 Time Limit: 1000MS Memory Limit: 65536KB Problem Description 输入多个整数，以-1作为结束标志，顺序建立一个带头结点的单链表，之后对该单链表的数据进行逆置，并输出逆置后的单链表数据。 Input 输入多个整数，以-1作为结束标志。 Output 输出逆置后的单链表数据。 Ex
二维数组元素的地址问题，超详细解读。
qq_45710392的博客
11-26 2578
/a[0]列地址，*(a+0)也是列地址 printf("%d,%d\n",&a[0],&a[0][0]);//&a[1][]0],*(a+1)+0代表的列地址 ​​​​​​​ ​​​​​​​ ​​​​​​​ 这里都是打印出0xa111这样的相同地址。&代表的是取地址，&与*和&与[]是逆运算。
C语言链表实现贪吃蛇游戏
08-29
主要介绍了C语言链表实现贪吃蛇游戏源码，适合C语言入门者学习阅读，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
数据结构C语言链表的实现
04-18
数据结构C语言链表的实现
C语言链表学生管理系统
01-10
学生管理系统 主要功能（增删查改）
c语言链表的基本操作实现
最新发布
03-28
C语言链表的基本操作主要包括**初始化、创建节点、插入节点、删除节点和查找节点**。具体如下： 1. **初始化**：创建一个空的链表，通常指创建一个头指针，该指针指向NULL，表示链表的开始。 2. **创建节点**：在...
C语言——轻松理解二维数组
bluecyan的博客
02-02 1837
若有二维数组a: char a[10][10] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20}; 则a表示二维数组本身，含有100个元素，也可认为含有10个一维数组，每个一维数组含有10个元素，其占有100字节；a[0]表示二维数组a的第一个一维数组，含有10个元素，其占有10字节；a[1]表示二维数组a的第二个一维数组，含有10个元素，其占有10字节；a[0][0]表示二维数组a的第一个元素，同时也是一维数组a[0]的第一个元素，其占有1字节
c语言 链表知识分享 --学生管理系统详解
qq_63982739的博客
09-21 853
链表的基础知识详解，基本动态函数的使用；链表构造学生管理系统创建，查找，删除，插入 图书管理系统类似
<3> 单链表的各种操作（创建、增加、删除、修改、查找、逆序、判空、置空等）
Charmain
09-30 1965
1 . 链表的创建 1）首先声明三个结构体指针变量（head、p1、p2），其中，一个是头结点，剩余的两个用来连接。 2）给p1开辟内存空间，代表第一个结点的地址，并且给第一个结点的数据域中的数据赋值。 3）循环创建（假设有N个结点需要创建）的过程。需要分情况，当我们的头结点并没有被连接到任何创建的结点上时，需要将head连接到，同时需要将p2也指向p1，这是因为当我们在将head连
链表的操作_C
duanhehui0928的专栏
08-17 605
1、单链表 单链表的存储结构： typedef struct Node { ElemType Data;//数据域，此处可以为一组数据，也可以为多组数据 struct Node *Link;//指针域，该指针为指向下一节点的指针 }Node, *Linklist; 操作实例： #include #include #include #define N 10  typ
数据结构快速入门——（链式）存储结构、头/尾指针和存储空间
长臂人猿的博客
01-11 913
前言 数据结构总的来说就是存储结构 + 不同的结构特性的使用方法；比如说同样的存储结构，根据其不同的结构特性有链表、栈、队，他们不同在于入出的方法或者说是顺序不同，本质上都是线性存储结构。由于顺序表，实质上就是数组，这里不再累赘。 存储结构 存储结构是决定数据结构的基本单元，以链表为例，首先看一下链式存储的存储结构： typedef struct Node { int data;...
线性表之单链表
bxuanzhao的专栏
11-10 524
链接表示是实现线性表的另一种经常使用的存储结构，这种存储结构不要求逻辑上相邻的两个元素在   物理位置上也相邻存储，而是通过增加元素指针来指示元素之间的逻辑关系和后继元素的位置。             线性表的链接表示就是用一组可以不连续的存储单元，存储线性表的各个元素，为了表示其后继与其的逻辑关系，每个元素除了需要存储自身的信息外，还要存储一个只是其后继的信息（即后继元素的存储位置）。这
数据结构—链表
小芦荟同学的博客
08-06 674
链表 目录 一、概述 二、单链表 三、双链表 四、双指针 五、经典问题—反转链表 一、概述 1.链表是什么 2.链表的基本结构 3.链表的分类 4.链表和数组的比较 5.设计链表：源代码（含测试用例） 1.链表是什么 链表数一种线性数据结构。它是动态地进行储存分配的一种结构。 什么是线性结构，什么是非线性结构？ 线性结构是一个有序数据元素的集合。常用的线性结构有：线性表，栈，队列，双队列，数组，串。 非线性结构，是一个结点元素可能有多个直接前趋和多个直接后继。常见的非线性结构有：二维数组，多维数组，广义表，
36张图带你深刻理解链表
简一未
01-11 1433
欢迎来到算法小课堂，今天分享的内容是链表这种数据结构。在浅谈数组这篇文章中，我们说到数组在内存中是用一块连续的内存空间存储的。由于是用连续内存空间存储的，那么就会出现，明明还剩50M内存...
数据结构---链表
zzhh147的博客
09-17 322
前边我们通过使用数组实现了队列结构。在使用数组的队列中，数组在空间中的地址是连续的，可以通过数组的下标直接访问获得该数组中的元素。在这里我们通过另一种方式来实现----链表。 1.什么是链表。 ...
c语言链表
05-31
在C语言中，可以通过定义结构体来实现链表。例如，定义一个包含数据元素和指向下一个节点的指针的链表节点如下： ``` struct ListNode { int val; // 数据元素 struct ListNode *next; // 指向下一个节点的指针 }...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值