数据结构与算法（2-2）线性表之链式存储（单链表、静态链表、循环链表、双向循环链表）

最新推荐文章于 2023-06-09 20:20:12 发布
最新推荐文章于 2023-06-09 20:20:12 发布
阅读量388 收藏 1
点赞数 1
分类专栏： # 数据结构与算法 文章标签： c语言 c++ 算法 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/great_yzl/article/details/119294510
版权

目录

一、单链表

1、存储方式

2、插入

3、删除

总代码： 

 二、静态链表

1、存储方式

2、插入

3、删除

4、遍历

总代码：

三、循环链表

 总代码：

四、双向循环链表

1、存储方式：

2、插入和删除

3、正向遍历与反向遍历

 总代码：

一、单链表

每个数据存储在结点中，单链表负责把这些结点串起来。（主要利用*next指针）

1、存储方式

从根结点开始（根结点可以不存储元素），用*next指针指向后面元素的地址，后面元素的*next继续指向更后面的元素，以此类推。（添加或插入元素要用malloc函数动态分配内存空间）头指针指向根，尾指针指向最后结点，便于插入删除。

//结点结构体
typedef struct Node
{
	int data;						//数据域
	struct Node* next;		//指针域
}Node;
Node* head;
Node* tail;

2、插入

前面元素的*next断开，指向插入元素，插入元素的*next又指向后面的元素，完成“挤入”式插入。 

//插入元素
void Insert(int index, int num)
{
	int i = 0;
	if (index < getLength() && index >= 0)		//插入下标有效
	{
		Node* s = (Node*)malloc(sizeof(Node)), * p = head;
		for (i = 0; i < index; i++)
			p = p->next;
		s->data = num;				//插入的元素值
		s->next = p->next;			//s->后面
		p->next = s;						//前面->s
	}
	else
		printf("不在插值范围内！");
}

3、删除

待删除元素前面元素的*next断开，指向待删除元素后面的元素，释放掉待删除元素的空间。（前面malloc分配的内存需要释放）

//删除结点	（必须有外变量暂时保存要删除的结点）
//如果删除的是head结点，直接把head指向后面的结点即可
void Delete_Node(int index)
{
	int i = 0;
	Node* p = head, * s = NULL;
	if (index < getLength() && index >= 0)		//删除下标有效
	{
		for (i = 0; i < index; i++)
			p = p->next;						//移动到前一位
		s = p->next;								//要删除的结点
		p->next = p->next->next;		//前结点next->后结点（跳过要删除的结点）
		free(s);
	}
	else
		printf("没有该下标的结点！\n");
}

总代码： 

//单链表
//动态内存分配malloc函数：			(指定的指针类型)malloc(要分配的字节数)
//头结点保存链表的首，可以在尾结点进行一系列操作(如添加)，p表示动态的指针
#include <stdio.h>
#include <malloc.h>

int i = 0;

//结点结构体
typedef struct Node
{
	int data;						//数据域
	struct Node* next;		//指针域
}Node;
Node* head;
Node* tail;

//初始化链表
void Init_List()
{
	//初始化链表
	head = (Node*)malloc(sizeof(Node));
	tail = (Node*)malloc(sizeof(Node));
	head = tail;
}

//创建结点
void Add_Node(int Data)
{
	Node* p = (Node*)malloc(sizeof(Node));
	p->data = Data;
	p->next = NULL;
	//指针后移
	tail->next = p;
	tail = p;
}

//获取链表长度
int getLength()
{
	int num = 0;
	Node* p = head->next;					//第一个数据存放在head->next里面
	while (p)
	{
		num++;
		p = p->next;
	}
	return num;
}

//遍历链表
void Print()
{
	Node* p = head->next;					//第一个数据存放在head->next里面
	while (p)
	{
		printf("%d\n", p->data);
		p = p->next;
	}
}

//插入元素
void Insert(int index, int num)
{
	int i = 0;
	if (index < getLength() && index >= 0)		//插入下标有效
	{
		Node* s = (Node*)malloc(sizeof(Node)), * p = head;
		for (i = 0; i < index; i++)
			p = p->next;
		s->data = num;				//插入的元素值
		s->next = p->next;			//s->后面
		p->next = s;						//前面->s
	}
	else
		printf("不在插值范围内！");
}

//删除结点	（必须有外变量暂时保存要删除的结点）
//如果删除的是head结点，直接把head指向后面的结点即可
void Delete_Node(int index)
{
	int i = 0;
	Node* p = head, * s = NULL;
	if (index < getLength() && index >= 0)		//删除下标有效
	{
		for (i = 0; i < index; i++)
			p = p->next;						//移动到前一位
		s = p->next;								//要删除的结点
		p->next = p->next->next;		//前结点next->后结点（跳过要删除的结点）
		free(s);
	}
	else
		printf("没有该下标的结点！\n");
}

//清空链表
void Clear_List()
{
	Node* p = head->next, * q;
	while (p)
	{
		q = p->next;
		free(p);
		p = q;
	}
	head->next = NULL;
}

int main()
{
	//初始化链表
	Init_List();

	//创建链表
	for (i = 0; i < 5; i++)
	{
		Add_Node(i);
	}

	//插入结点
	Insert(0, 5);

	//删除结点（第二次删除注意：位置改变）
	Delete_Node(0);

	//清空链表
	Clear_List();

	//遍历
	Print();

	return 0;
}

 二、静态链表

以数组的方式存储，虽然需要分配较大的内存空间，但是插入/删除比较容易，不需要移动数组元素，只用改变游标(cur)指向即可即可。

1、存储方式

创建一个数组（index是下标，cur是游标）

cur(游标)：存放前一个元素的index，通过它实现连接。

整个链表被分成两部分：1、有值链表（存放有元素）2、备用链表（不存放元素）

首元素(index=0)的cur：                           存放备用链表的首元素。

尾元素(index=MAXSIZE-1)的cur：        存放有值链表的首元素。

链表构成：1、以首元素为首构成的备用链表；        2、以尾元素为首构成的有值链表。

//静态链表结构体
typedef struct
{
	int data;			//数据
	int cur;				//游标
}StaticList;
StaticList L[MAXSIZE];

2、插入

只移动游标，不移动元素。

//插入链表
void Insert(int index, int num)
{
	int pre = MAXSIZE - 1;
	if (index <= 0 || index > L[0].cur)			//插入范围无效（第1个和最后一个元素不存放数据）
	{
		printf("%d Insert Error!\n", num);
		return;
	}
	//移动到前一个元素(有效元素)
	for (i = 1; i < index; i++)
		pre = L[pre].cur;							

	L[0].cur = L[index].cur;				//链表首元素游标指向备用链表首元素
	L[index].data = num;
}

3、删除

被删除的元素作为备用链表首元素，其游标连接原备用链表首元素，原备用链表首元素变成第二个元素（向后移）。

//删除链表（把需要删除的元素降级，变为备用链表的首元素）
void Delete(int index)
{
	int pre = MAXSIZE - 1, j;
	if (index < 1 || index >= L[0].cur)
	{
		printf("要删除的下标无效！\n");
		return;
	}

	for (i = 1; i <= index - 1; i++)
		pre = L[pre].cur;						//移动到需要删除的前一个位置（有元素位）

	L[index].cur = L[0].cur;					//1、游标指向原备用元素（被删除的元素作为备用元素的首）
	L[0].cur = index;							//2、更新备用链表首元素（被删除的元素）
	L[pre].cur = index;						//3、连接前一个元素和后一个元素（游标）
}

4、遍历

从index = MAXSIEZE-1处开始遍历（从尾元素开始遍历），因为尾元素的cur存有有效链表的首元素。

//遍历链表
void Traverse()
{
	int cur;
	cur = L[MAXSIZE - 1].cur;			//指向有效链表的首元素
	for (i = 1; i < L[0].cur; i++)			//从第一个开始，到最后一个结束（备用链表的首元素就是最后一个元素的下一个元素）
	{
		printf("%d\n", L[cur].data);
		cur = L[cur].cur;						//有效链表中继续后移
	}
}

总代码：

//静态链表
//插入/删除时只修改游标，不移动结点
//游标存放下标，前一元素游标存放后一元素的下标
//第一个元素游标：	存放备用链表第一个元素的下标
//最后一个元素游标：存放有元素链表第一个元素的下标
//把有效元素作为一个循环，用pre=MAXSIZE-1标志开始，因为L[MAXSIZE-1].cur指向有效链表首元素，相当于在有效链表内循环
#include <stdio.h>

#define MAXSIZE 20
int i = 0;

typedef struct
{
	int data;
	int cur;
}StaticList;
StaticList L[MAXSIZE];

//链表初始化
void List_Init()
{
	//初始化游标
	for (i = 0; i < MAXSIZE; i++)
	{
		L[i].cur = i + 1;							//游标指向下一个
	}
	L[MAXSIZE - 1].cur = 1;				//最后一个元素的游标(有效元素)
}

//根据游标获取下标(这里没用到)
int getIndex(int Cur)
{
	for (i = 0; i < MAXSIZE; i++)
	{
		if (L[i].cur == Cur)		//找到对应游标的元素
			return i;					//返回下标
	}
	return -1;							//没有找到
}

//获取长度
int getLength()
{
	int num = 0;
	i = L[MAXSIZE - 1].cur;
	if (L[0].cur == L[MAXSIZE - 1].cur)			//没有元素
		return 0;

	while (i < L[0].cur)
	{
		i = L[i].cur;
		num++;
	}
	return num;
}

//插入链表
void Insert(int index, int num)
{
	int pre = MAXSIZE - 1;
	if (index <= 0 || index > L[0].cur)			//插入范围无效（第1个和最后一个元素不存放数据）
	{
		printf("%d Insert Error!\n", num);
		return;
	}
	//移动到前一个元素(有效元素)
	for (i = 1; i < index; i++)
		pre = L[pre].cur;							

	L[0].cur = L[index].cur;				//链表首元素游标指向备用链表首元素
	L[index].data = num;
	L[0].cur = L[index].cur;				//更新备用链表
}

//删除链表（把需要删除的元素降级，变为备用链表的首元素）
void Delete(int index)
{
	int pre = MAXSIZE - 1, j;
	if (index < 1 || index >= L[0].cur)
	{
		printf("要删除的下标无效！\n");
		return;
	}

	for (i = 1; i <= index - 1; i++)
		pre = L[pre].cur;						//移动到需要删除的前一个位置（有元素位）

	L[index].cur = L[0].cur;					//1、游标指向原备用元素（被删除的元素作为备用元素的首）
	L[0].cur = index;							//2、更新备用链表首元素（被删除的元素）
	L[pre].cur = index;						//3、连接前一个元素和后一个元素（游标）
}

//遍历链表
void Traverse()
{
	int cur;
	cur = L[MAXSIZE - 1].cur;			//指向有效链表的首元素
	for (i = 1; i < L[0].cur; i++)			//从第一个开始，到最后一个结束（备用链表的首元素就是最后一个元素的下一个元素）
	{
		printf("%d\n", L[cur].data);
		cur = L[cur].cur;						//有效链表中继续后移
	}
}

int main()
{
	List_Init();						//链表初始化

	printf("插入前元素总数：%d\n", getLength());

	Insert(1, 6);					//插入链表
	Insert(2, 8);
	Insert(3, 10);

	printf("删除前元素总数：%d\n", getLength());

	Delete(3);
	Delete(2);						//删除链表
	Insert(2, 8);

	printf("删除后元素总数：%d\n", getLength());

	Traverse();

	return 0;
}

三、循环链表

循环链表顾名思义，尾连接头，实现循环。

存储结构和链表类似，就多一个头尾相接，完成循环。

 总代码：

//循环链表
//用了两个指针，一个指向头，一个指向尾，尾连接上头，完成循环链表
#include <stdio.h>
#include <malloc.h>

int i = 0;

//结构体
typedef struct Node
{
	int data;
	struct Node* next;
}Node;
Node* head;			//头结点
Node* tail;				//尾结点
Node* t;					//遍历结点

//链表初始化
void List_Init()
{
	head = (Node*)malloc(sizeof(Node));			//分配地址
	tail = (Node*)malloc(sizeof(Node));			//分配地址
	head->next = tail;
	tail->next = head;
}

//获取链表长度
int getLength() {
	int num = 0;
	Node* L = head;
	while (L->next != tail)
	{
		L = L->next;
		num++;
	}
	return num;
}

//插入链表
void Insert(int index, int num)
{
	if (index<0 || index>getLength())
	{
		printf("%d 序号不在范围内\n", num);
		return;
	}
	Node* p = (Node*)malloc(sizeof(Node)), * L;
	p->next = NULL;
	L = head;							//指向头
	while (L->next != tail)		//移动到尾结点前面（最后一个有效结点）
		L = L->next;
	L->next = p;
	p->data = num;
	tail = p->next;					//更新尾结点
}

//删除链表
void Delete(int index)
{
	if (index < 0 || index >= getLength())
	{
		printf("无该序号\n");
		return;
	}
	Node* L = head, * t;
	for (i = 0; i < index; i++)
		L = L->next;

	t = L->next;
	L->next = L->next->next;
	free(t);
}

//遍历链表
void Traverse()
{
	Node* L = head;
	while (L->next != tail)				//头尾循环
	{
		L = L->next;
		printf("%d\n", L->data);
	}
}

int main()
{
	List_Init();					//链表初始化

	Insert(0, 0);				//插入链表
	Insert(1, 1);
	Insert(2, 2);

	Delete(2);					//删除链表
	Delete(1);					//第二次删除位置改变

	Traverse();						//遍历链表

	return 0;
}

四、双向循环链表

双向循环链表优势：可以完成双向的遍历。

1、存储方式：

双向：*prior指针和*next指针分别指向前后两个元素。

循环：头结点的*prior指向尾结点，尾结点的*next指向头结点。

//双向循环链表
typedef struct Node
{
	int data;
	struct Node* prior;
	struct Node* next;
}Node;

2、插入和删除

插入：一个遍历链表，另一个进行插入（一开始不要进入链表，散置，不然会一直循环）。
删除：也要同时考虑next和prior指针。

3、正向遍历与反向遍历

正向遍历：从头结点head出发，向尾部遍历，直到遇到tail结束遍历。

反向遍历：从尾结点tail出发，向头部遍历，直到遇到head结束遍历。

//正向遍历链表
void Traverse()
{
	Node* p = head;
	printf("正向遍历：\n");
	while (p->next != tail)
	{
		p = p->next;
		printf("%d\n", p->data);
	}
}

//反向遍历链表
void AntiTraverse()
{
	Node* p = tail;
	printf("反向遍历：\n");
	while (p->prior != head)
	{
		p = p->prior;
		printf("%d\n", p->data);
	}
}

 总代码：

//双向循环链表
//前指针和后指针分别连接前面和后面的元素
//插入：一个遍历链表，另一个进行插入（一开始不要进入链表，散置，不然会一直循环）
//删除：也要同时考虑next和prior指针
#include <stdio.h>
#include <malloc.h>

//双向循环链表
typedef struct Node
{
	int data;
	struct Node* prior;
	struct Node* next;
}Node;

Node* head;			//头
Node* tail;				//尾
int i = 0;

//链表初始化
void Init_List()
{
	head = (Node*)malloc(sizeof(Node));
	tail = (Node*)malloc(sizeof(Node));
	head->prior = tail;
	head->next = tail;
	tail->next = head;
	tail->prior = head;
	//赋一个值，便于调试
	tail->data = -2;
	head->data = -1;
}

//获取元素数量
int getLength()
{
	int num = 0;
	Node* p = head;
	while (p->next != tail)
	{
		p = p->next;
		num++;
	}
	return num;
}

//链表插入
void Insert(int index, int num)
{
	if (index<0 || index>getLength())
	{
		printf("插入下标不正确！\n");
		return;
	}
	Node* t = (Node*)malloc(sizeof(Node)), * p;
	p = head;
	for (i = 0; i < index; i++)
	{
		p = p->next;					//移动到前一个元素
	}
	t->prior = p;
	t->next = p->next;
	p->next->prior = t;				//这一步要在前面
	p->next = t;							//这一步要在后面，负责p->next已经改变，前面的没有意义了
	t->data = num;
}

//删除链表
void Delete(int index)
{
	if (index < 0 || index >= getLength())
	{
		printf("删除下标不正确！\n");
		return;
	}
	Node* p = head, * s;
	for (i = 0; i < index; i++)
		p = p->next;
	s = p->next;
	p->next->next->prior = p;
	p->next = p->next->next;
	free(s);
}

//正向遍历链表
void Traverse()
{
	Node* p = head;
	printf("正向遍历：\n");
	while (p->next != tail)
	{
		p = p->next;
		printf("%d\n", p->data);
	}
}

//反向遍历链表
void AntiTraverse()
{
	Node* p = tail;
	printf("反向遍历：\n");
	while (p->prior != head)
	{
		p = p->prior;
		printf("%d\n", p->data);
	}
}

int main()
{
	Init_List();						//链表初始化

	Insert(0, 0);					//插入元素
	Insert(1, 1);
	Insert(2, 2);

	Delete(2);					//删除元素

	Traverse();						//正向遍历
	AntiTraverse();					//反向遍历

	return 0;
}
_(*^▽^*)_
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构c版（1）-线性表之双向带头循环链表代码
11-19
在本篇文章中，我们将深入探讨一个特定的数据结构——双向带头循环链表，它是线性表的一种实现方式。在C语言中，这种数据结构尤其常见，因为C语言提供底层内存管理和指针操作的能力，使得我们能够直接构建复杂的链式...
线性表—单链表、循环链表、双向链表。
weixin_46153942的博客
01-27 1898
单链表 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 链表的存取必须从头指针开始，头指针指示链表的第一个结点（即第一个数据元素的存储映像，也称首元结点）。同时，最后一个数据元素没有直接后继，最后一个结...
【数据结构与算法学习】线性表（顺序表、单链表、双向链表、循环链表）
最新发布
Gefangenes的博客
06-09 1302
12345。
【Python】数据结构——线性表（顺序表、单链表、循环单链表、双链表、循环双链表）
二琳爱吃肉的博客
04-16 3308
线性表是由若干个具有相同特性的数据元素组成的有限序列 空表就是线性表中不包含任何元素，长度为零。当线性表非空时，线性表长度即线性表内数据元素的个数。 直接前驱：线性表某一个元素的前一个元素 直接后继：线性表某一个元素的后一个元素
【数据结构】静态链表和单链表的存储方式、优缺点与区别
qq_55930097的博客
06-07 1343
创建一个足够大的数组，假设大小为6，在将数据存放到数组中时，给各个数据元素配备游标，用于指明各个元素的直接后继元素所在数组中的位置下标，从a[1]存储的数据元素1开始，通过存储的游标变量 3，就可以在a[3]中找到元素1的直接后继元素2；同样，通过元素a[3]存储的游标变量5，可以在a[5]中找到元素2的直接后继元素3，这样的循环过程直到某元素的游标变量为0截止，因为 a[0] 默认不存储数据元素。静态链表，也是线性存储结构的一种，它兼顾了顺序表和链表的优点于一身，可以看做是顺序表和链表的升级版。
初学数据结构——从零开始的数据结构学习第五天（线性表的链式存储方式）
Lazy_ChessPlayer的博客
04-10 2222
本博客为本人在学习数据结构路途上的知识整理，如觉得对有你有所帮助，还希望留下一个赞。由于博主只是一名大一新生，如果博文中出现错误，欢迎指正。如果想要转载，附上链接就行。线性表中各个数据元素在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻。线性表的链式表示又称为非顺序映像或链式映像。一种头尾相接的链表（即：表中最后一个结点的指针域指向头结点，整个链表形成一个环）在单链表的每个结点单再增加一个指向其直接前驱的指针域prior，这样链表中就形成了有两个方向不同的链，故称为双向链表。
数据结构与算法-链表（线性表的链表表示和实现） 定义线性表节点的结构.pdf
04-18
链表数据结构和算法实现 链表是一种线性表的链式表示和实现，定义线性表节点的结构。链表的内存结构是不连续的内存空间，是将一组零散的内存块串联起来，从而进行数据存储的数据结构。一个链表有很多个节点，各个...
数据结构学习--线性表及其应用--链表
06-25
本程序的主要目的在于帮助同学熟练掌握线性表的基本操作在链式存储结构上的...通过本实验， 对链表基本操作及其组合应用的演练，加深对链表存储方法及其基本操作的理解，为以后进 一步学习更复杂的数据结构打下基础。
链表的C++实现（线性表的链式存储C++实现）
04-05
使用C++类模板实现了线性表的链式存储结构（链表），类中包含了线性表的常用方法：向线性表中插入一个元素、删除一个元素、清空线性表、获取一个元素、获取线性表...相关的文章可以在我的主页算法与数据结构专栏查看。
数据结构教学课件：第3-2讲 线性表的链式存储结构-2.pdf
06-16
《数据结构教学课件：第3-2讲 线性表的链式存储结构-2》主要探讨了线性表的链式存储结构，包括单链表、循环链表和双向链表的相关概念和操作。以下是这些知识点的详细解释： 1. **删除运算**：在单链表中，删除某个...
链表
行云流水Gz的专栏
04-20 698
1.1 链表(Linked List)介绍 1.1.1 链表是有序的列表， 但是它在内存中是存储如下： 小结上图: 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域： 指向下一个节点. 如图： 发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表， 根据实际的需求来确定 1.1.2 单链表(带头结点) 逻辑结构示意图如下： 1.1.3 单链表的应用实例 使用带 head 头的单向链表实现 – 水浒英雄排行榜管理完成对英雄人物的增删改查操
考研复习之数据结构笔记（四）线性表（下）（线性表的链式表示：单链表、循环链表、静态链表、双向链表以及顺序表与链表的比较）
欢迎交流！
07-01 747
目录一、线性表的链式表示1.1 单链表（1）相关概念及特点（2）头结点（哨兵位）（3）单链表的相关实现（以下代码实现默认无哨兵位，无哨兵位更具有普适性）1.2 双向链表1.3 循环链表1.4 静态链表二、顺序表与链表的比较2.1 顺序存储和链式存储典型特点2.2 顺序表和链表的具体区别单链表指结点中只含一个指针域的链表，也称线性链表。单链表结点结构下所示，其中data为数据域，存放数据元素；next 为指针域，存放其后继结点的地址。 相关特点：1.利用单链表可以解决顺序表需要大量连续存储单元的缺点。2.
特殊的链表——双向、循环、静态
初学者
02-16 152
双向链表 定义 ：每个节点有两个指针域，分别知道直接前驱和直接后继节点 ， 特点是可以重任意节点出发，从两个方向遍历链表 数据结构 typedef struct node { int data; struct node *font ; struct node *next; } NODE, *LinkList; 插入 // p 为链中节点 s 为待插入节点 把s 放...
静态链表的增，删，清空，销毁等操作
weixin_43854256的博客
05-18 384
创建slinklist.h文件 #pragma once //静态链表：利用顺序表模拟链表操作，包含两条带头循环链表 //一条为有效数据链表，头结点为0下标；一条为空闲链表，头结点为1下标 #define MAXSIZE 10 typedef struct SNode { int data;//数据 int next;//后继指针，其实为后继节点的下标 }SNode,SLinkList[MAXSIZE],*PSLinkList; //typedef SNode SLinkList[MAXSIZE];
数据结构-链表
weixin_45666566的博客
04-20 553
链表一.单链表1.1单链表的概念1.2单链表的基本实现 链表是由n个结点离散分配，彼此通过指针相连构成的。 专业术语： 首结点：第一个有限节点 尾结点：最后一个有效节点 头结点：头结点的数据类型和首节点（）类型一样。第一个有效节点之前的那个节点，头结点并不存放有效数据，加头结点的目的主要是为了方便对链表的操作。 头指针（head):指向第一个结点的地址 尾标志（尾结点tail):终端结点的指针域为...
数据结构 静态链表特别篇
qq2410030025的博客
03-24 367
静态链表 我在《 数据结构 第二章 :双链表，循环链表，静态链表以及对比总结》，初步认识了静态链表。 第一次去理解代码，其实有一点点费力。但是也不是那么复杂，主要抓住下面这一点 静态链表：分配一整个连续内存空间每个节点，每个节点集中安置；静态链表中没有用指针，但是数组的索引值 Index充当了指针的作用。 静态链表就是为那行没有指针的编程语言二存在的，存储数据用的是连续的空间，但是逻辑上连续的空间，在物理上无需连续，还是抓住了链表的特点。 typedef struct { ElemType dat
双链表与循环链表和静态链表
liyulin90的博客
04-22 1316
删除指定结点的后结点
双链表、循环链表和静态链表
m0_46364942的博客
09-15 204
双链表、循环链表和静态链表的一些笔记
《数据结构》—— 循环链表与静态链表
博樽
09-12 571
循环单双链表的思考，以及静态链表逻辑表示的不同。
第二章：线性表-21
08-03
在计算机科学与技术学院的数据结构与算法课程中，我们学习了线性表的不同实现方式，包括顺序表、单链表、静态链表、双向链表和环形链表等。 首先，在线性表的抽象数据类型及操作中，我们定义了线性表LIST为由元素...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_(*^▽^*)_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值