【数据结构 c语言版 】线性表的链式表示和实现

已于 2022-10-10 21:59:21 修改
阅读量917 收藏 6
点赞数 5
分类专栏： 数据结构 C语言版 文章标签： 数据结构 c语言 链表
于 2022-09-21 22:42:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shijiuhuaR/article/details/126981186
版权

目录

一  单链表的表示和实现

1.单链表的存储结构

1.1.  头指针、头结点与首元结点

1.2.  带头结点单链表和不带头结点单链表的比较

2. 单链表的初始化

3.  单链表的长度

4.  单链表的插入

5.  单链表的删除

6.  单链表的查看

7.  单链表的撤销

完整代码

二  循环单链表

三  双向链表

1.  双向链表表的存储结构、初始化

2.  双向链表的插入、删除

结点：由数据元素域和一个或若干个指针域组成的一个结构体。
链表：链式存储结构的线性表。

一  单链表的表示和实现

1.单链表的存储结构

typedef char DataType;
typedef struct Node
{	//单链表的储存结构
	DataType data; //存放数据
	struct Node* next;  //存放指针
}SLNode;

1.  每个存储结点都包含两部分：数据域，指针域
2.  在单链表中，除了首元结点外，任一结点的存储位置由其直接前驱结点的链域的值指示。

1.1.  头指针、头结点与首元结点

 头指针是指向链表中第一个结点

头结点是在链表的首元结点之前附设的一个结点；数据域内只放空表标志和表长等信息，它不计入表长度。
首元结点是指链表中存储线性表第一个数据元素a0的结点。

1.2.  带头结点单链表和不带头结点单链表的比较

  1）  带头结点的单链表的第一个数据元素插入时，其插入在头结点后。

   2）  不带头结点的单链表的第一个数据元素插入时，其插入在头指针后。

   3） 不带头结点的单链表的其余数据元素插入时，其插入在前一节点后。

 

   4）  删除带头结点的单链表的第一个数据时，头结点指针指向第二个数据

   5） 删除不带头结点的单链表的第一个数据时，头指针指向第二个数据

 结论：插入操作时，有头结点链表方便

单链表一般构造成带头结点的单链表

2. 单链表的初始化

malloc(m)函数:向系统动态申请m字节长度的地址空间，并返回这段空间的首地址；
free(p)函数:释放指针p所指变量的存储空间，即彻底删除一个变量。
sizeof(x)运算符:计算变量x的长度（字节数）；
以上有库函数/算符都在<malloc.h> 中

void ListInitiate(SLNode** hear)
{	//单链表的初始化
	*hear = (SLNode*)malloc(sizeof(SLNode));
	(* hear)->next = NULL;  //链尾标记NULL
}

3.  单链表的长度

int ListLength(SLNode* hear)
{	//单链表的长度
	SLNode* p = hear;  //p 指向头结点
	int size;
	for (size = 0; p->next != NULL; size++)
	{
		p = p->next;
	}
	return size;
}

4.  单链表的插入

实现步骤：

1.  将插入处前一节点指针指向所插入节点的指针

   （即  将所插入节点的指针指向插入处的节点，防止插入处节点丢失）；

2.  将插入处前一节点指针指向所插入节点。

          x 节点先 生成再使用。

int ListInsert(SLNode* head, int i, DataType x)
{	//在顺序表的第i个位置之前插入数据值x
	//插入成功返回1，插入失败返回0
	SLNode* p, * q;
	p = head;
	int j = 0;
	for (j; p->next != NULL && j < i - 1; j++)
	{
		p = p->next;
	}
	if (j != i - 1)
	{
		printf("插入地方错误！\n");
		return 0;
	}
	q = (SLNode*)malloc(sizeof(SLNode));
	q->data = x;
	q->next = p->next;
	p->next = q;
	return 1;

}

5.  单链表的删除

实现步骤：

1.  将要删除节点前一节点的指针指向删除节点的后一节点

   （即  使得要没有指针指向删除节点）；

2.  释放删除节点。

int ListDelete(SLNode* head, int i, DataType* x)
{	//删除顺序表L中位置i的数据元素值并存放到参数x中
	//删除成功返回1，失败返回0
	SLNode* p, * s;
	p = head;
	int j = 0;
	for (j; p->next != NULL && j < i - 1; j++)
	{
		p = p->next;
	}
	if (j != i - 1)
	{
		printf("删除位置错误！\n");
		return 0;
	}
	s = p->next;
	*x = s->data;
	p->next = s->next;
	free(s);
	return 1;

}

6.  单链表的查看

int ListGet(SLNode* head, int i, DataType* x)
{	//取顺序表中第i个元素存于x中
	//取出成功返回1，失败返回0
	SLNode* p;
	p = head;
	int j = 0;
	for (j; p->next != NULL && j < i; j++)
	{
		p = p->next;
	}
	if (j != i)
	{
		printf("参数i不合法！\n");
		return 0;
	}
	*x = p->data;
	return 1;

}

7.  单链表的撤销

void Destroy(SLNode **head)
{	//撤销单链表
	SLNode* p, * q;
	p = *head;
	for (p; p != NULL; free(q))
	{
		q = p;
		p = p->next;

	}
	*head = NULL;
}

完整代码

#include<stdio.h>
#include<malloc.h>

typedef char DataType;
typedef struct Node
{	//单链表的储存结构
	DataType data; //存放数据
	struct Node* next;  //存放指针
}SLNode;

void ListInitiate(SLNode** hear)
{	//单链表的初始化
	*hear = (SLNode*)malloc(sizeof(SLNode));
	(* hear)->next = NULL;  //链尾标记NULL
}

int ListLength(SLNode* hear)
{	//单链表的长度
	SLNode* p = hear;  //p 指向头结点
	int size;
	for (size = 0; p->next != NULL; size++)
	{
		p = p->next;
	}
	return size;
}

int ListInsert(SLNode* head, int i, DataType x)
{	//在顺序表的第i个位置之前插入数据值x
	//插入成功返回1，插入失败返回0
	SLNode* p, * q;
	p = head;
	int j = 0;
	for (j; p->next != NULL && j < i - 1; j++)
	{
		p = p->next;
	}
	if (j != i - 1)
	{
		printf("插入地方错误！\n");
		return 0;
	}
	q = (SLNode*)malloc(sizeof(SLNode));
	q->data = x;
	q->next = p->next;
	p->next = q;
	return 1;

}

int ListDelete(SLNode* head, int i, DataType* x)
{	//删除顺序表L中位置i的数据元素值并存放到参数x中
	//删除成功返回1，失败返回0
	SLNode* p, * s;
	p = head;
	int j = 0;
	for (j; p->next != NULL && j < i - 1; j++)
	{
		p = p->next;
	}
	if (j != i - 1)
	{
		printf("删除位置错误！\n");
		return 0;
	}
	s = p->next;
	*x = s->data;
	p->next = s->next;
	free(s);
	return 1;

}

int ListGet(SLNode* head, int i, DataType* x)
{	//查看
    //取顺序表中第i个元素存于x中
	//取出成功返回1，失败返回0
	SLNode* p;
	p = head;
	int j = 0;
	for (j; p->next != NULL && j < i; j++)
	{
		p = p->next;
	}
	if (j != i)
	{
		printf("参数i不合法！\n");
		return 0;
	}
	*x = p->data;
	return 1;

}

void Destroy(SLNode **head)
{	//撤销单链表
	SLNode* p, * q;
	p = *head;
	for (p; p != NULL; free(q))
	{
		q = p;
		p = p->next;

	}
	*head = NULL;
}

void main(void)
{
	SLNode* head;
	DataType x;
	ListInitiate(&head);
	ListInsert(head, 1, 'a');
	ListInsert(head, 2, 'b');
	ListInsert(head, 3, 'c');
	printf("%d\n", ListLength(head));
	ListGet(head, 3, &x);
	printf("%c\n", x);
	ListDelete(head, 2, &x);
	printf("%d\n", ListLength(head));
	ListGet(head, 2, &x);
	printf("%c\n", x);
	Destroy(&head);

}

二  循环单链表

在初始化函数中，将语句(*head)->next = NULL改为(*head)->next =head。

void ListInitiate(SLNode** hear)
{	//单链表的初始化
	*hear = (SLNode*)malloc(sizeof(SLNode));
	(* hear)->next = hear;  //链尾标记hear
}

 在删除与查看函数中，将更改其判断语句。

int ListDelete(SLNode* hear, int i, DataType* x)
{	//删除
	SLNode* p, * q;
	p = hear;
	int j = 0;
	for (j; j < i - 1; j++)
	{
		p = p->next;
		if (p->next == hear)
		{
			p = p->next;
		}
	}
	
	if (j != i - 1)
	{
		printf("删除位置错误！\n");
		return 0;
	}
	q = p->next;
	*x = q->data;
	p->next = q->next;
	free(q);
	return 1;

}

int ListGet(SLNode* head, int i, DataType* x)
{	//查看
	SLNode* p;
	p = head;
	int j = 0;
	for (j; j < i - 1; j++)
	{
		p = p->next;
		if (p->next == head)
		{
			p = p->next;
		}
	}
	
	if (j != i - 1)
	{
		printf("参数！不合法！\n");
		return 0;
	}
	*x = (p->next)->data;
	return 1;
}

在撤销函数中， 增加一标志点以判断循环链表已清空。

void Destroy(SLNode** head)
{	//撤销
	SLNode* p, * q;
	p = *head;
	int i = 0;
	for (p; i != 0 && p->next != *head; free(q))
	{
		q = p;
		p = p->next;
		i++;

	}
	*head = NULL;
}

完整代码，输出卡牌游戏，卡牌第一个位置输出 1 ，第二个位置输出 2 ，以此类推。

#include<stdio.h>
#include<malloc.h>

typedef char DataType;
typedef struct Node
{	
	DataType data; //存放数据
	struct Node* next;  //存放指针
}SLNode;

void ListInitiate(SLNode** head)
{	//初始化
	*head = (SLNode*)malloc(sizeof(SLNode));
	(*head)->next = *head;  //链尾标记hear
}

int ListLength(SLNode* hear)
{	//长度
	SLNode* p = hear;
	int size;
	for (size = 0; p->next != hear; size++)
		p = p->next;
	return size;
}


int ListInsert(SLNode* head, int i, DataType x)
{	//插入
	SLNode* p, * q;
	p = head;
	int j = 0;
	for (j; p->next != head && j < i - 1; j++)
	{
		p = p->next;
	}
	if (j != i - 1)
	{
		printf("插入地方错误！\n");
		return 0;
	}
	q = (SLNode*)malloc(sizeof(SLNode));
	q->data = x;
	q->next = p->next;
	p->next = q;
	return 1;

}

int ListDelete(SLNode* hear, int i, DataType* x)
{	//删除
	SLNode* p, * q;
	p = hear;
	int j = 0;
	for (j; j < i - 1; j++)
	{
		p = p->next;
		if (p->next == hear)
		{
			p = p->next;
		}
	}
	
	if (j != i - 1)
	{
		printf("删除位置错误！\n");
		return 0;
	}
	q = p->next;
	*x = q->data;
	p->next = q->next;
	free(q);
	return 1;

}

int ListGet(SLNode* head, int i, DataType* x)
{	//查看
	SLNode* p;
	p = head;
	int j = 0;
	for (j; j < i - 1; j++)
	{
		p = p->next;
		if (p->next == head)
		{
			p = p->next;
		}
	}
	
	if (j != i - 1)
	{
		printf("参数！不合法！\n");
		return 0;
	}
	*x = (p->next)->data;
	return 1;
}

void Destroy(SLNode** head)
{	//撤销
	SLNode* p, * q;
	p = *head;
	int i = 0;
	for (p; i != 0 && p->next != *head; free(q))
	{
		q = p;
		p = p->next;
		i++;

	}
	*head = NULL;
}


void main(void)
{
	SLNode* hear;
	DataType x;
	ListInitiate(&hear);
	ListInsert(hear, 1, '1');
	ListInsert(hear, 2, 'K');
	ListInsert(hear, 3, '2');
	ListInsert(hear, 4, '8');
	ListInsert(hear, 5, '3');
	ListInsert(hear, 6, '0');
	ListInsert(hear, 7, '4');
	ListInsert(hear, 8, 'j');
	ListInsert(hear, 9, '5');
	ListInsert(hear, 10, '9');
	ListInsert(hear, 11, '6');
	ListInsert(hear, 12, 'q');
	ListInsert(hear, 13, '7');

	ListDelete(hear, 1, &x);
	printf("%c", x);
	ListDelete(hear, 2, &x);
	printf("%c", x);
	ListDelete(hear, 3, &x);
	printf("%c", x);
	ListDelete(hear, 4, &x);
	printf("%c", x);
	ListDelete(hear, 5, &x);
	printf("%c", x);
	ListDelete(hear, 6, &x);
	printf("%c", x);
	ListDelete(hear, 7, &x);
	printf("%c", x);
	ListDelete(hear, 8, &x);
	printf("%c", x);
	ListDelete(hear, 9, &x);
	printf("%c", x);
	ListDelete(hear, 10, &x);
	printf("%c", x);
	ListDelete(hear, 11, &x);
	printf("%c", x);
	ListDelete(hear, 12, &x);
	printf("%c", x);
	ListDelete(hear, 13, &x);
	printf("%c", x);
	Destroy(&hear);



}

三  双向链表

双向链表：链表中每个结点除后继指针域和数据域外还有一个前驱指针域。
它有带头结点和不带头结点，循环和非循环结构。双向链表是解决查找前驱结点问题的有效途径。

1.  双向链表表的存储结构、初始化

 初始化时，前驱指针和后继指针各自构成自己的循环单链表。

2.  双向链表的插入、删除

shijiuhuaR
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用C语言实现数据结构中的线性表（链式表示）
11-15
本人在学习数据结构时使用的是严蔚敏的《数据结构》，并根据课本内容完成了这个头文件，这个头文件把课本中的线性表的链式表示和实现都囊括在内了。部分实现中也做了相应的优化处理。如果想看线性表的顺序表示表示和实现可以在我的主页中查找。头文件是可以直接用的，把文件复制到自己新建的项目所在的文件夹里，然后用VS（或者其他编程软件）中添加这个头文件就可以用了。默认存储的数据都是int形的。需要的可以下载下来借鉴一下。
c语言数据结构实验：掌握线性表的链式存储结构 熟练掌握循环链表的存储特征和建立方法，掌握线性表的链式存储结构 下面是源码的txt
最新发布
10-13
01 02 03分别代表三个题 每个实验只有前两个题写了~ 运行都没有问题~ 已知带头结点的动态单链表L中的结点是按整数值递增排序的，试写一算法将值为的结点插入到表L中，使L仍然有序。要求算法的时间复杂度为 O()，空间复杂度为 O(1)。2、设计一算法，逆置带头结点的动态链表L。要求利用原表的结点空间，并要求用尽可能少的时间完成。 假设在长度大于1的单循环链表中，既无头结点也无头指针。s 为指向某个结点的指针，试编写算法删除结点*s 的直接前驱结点。 2、已知由单链表表示的线性表中，含有三类字符的数据元素(如:字母、数字和其它字符)，设计算法构造三个以循环链表示的线性表，使每一个表中只含同一类的字符，且利用原表中的结点空间作为这三个表的空间。(头结点可以另辟空间) 设单链表中存放着n个字符，设计算法，判断该字符串中是否有中心对称关系。例如:xyzzyx、xyzyx都算是中心对称的字符串。 2、设计算法判断一个算术表达式的圆括号是否配对。(提示:对表达式进行扫描，遇“(进栈，遇“)’退掉栈顶的“(，表达式被扫描完毕，栈为空)
用C语言实现数据结构中的线性表
11-15
本人在学习数据结构时使用的是严蔚敏的《数据结构》，并根据课本内容完成了这个头文件，这个头文件把课本中的线性表的顺序表的表示和实现都囊括在内了。部分实现中也做了相应的优化处理。由于一次性只能发一个文件，所以如果想看线性表的链式表示和实现可以在我的主页中查找。头文件是可以直接用的，把文件复制到自己新建的项目所在的文件夹里，然后用VS（或者其他编程软件）中添加这个头文件就可以用了。默认存储的数据都是int形的。需要的可以下载下来借鉴一下。
数据结构 Ｃ语言版　线性表的链式存储
05-07
数据结构 Ｃ语言版　线性表的链式存储 数据结构 Ｃ语言版　线性表的链式存储
数据结构 二叉树的存储表示以及二叉树的遍历
qq_53334934的博客
11-10 1057
二叉树的顺序存储 #define maxSize 127 typedef char DataType; typedef struct { DataType data[maxSize]; int n; //当前结点个数 }SqBTree; 二叉树的顺序存储对于一般的二叉树不适用，一般的二叉树采用链式存储结构。 二叉树的链式存储结构 二叉树的二叉链表存储表示 typedef char DataType; //结点数据类型 typedef struct Nod
关于数据结构（c语言）中，线性表中链式结构的大部分操作的代码实现
weixin_60700743的博客
09-13 605
本篇文章将要介绍的，是线性表（逻辑结构）中的链式结构（存储结构），是线性表的基础之一，而在下列程序中，将要通过对链表的创建、判空、遍历输出、长度输出、升序排序（冒泡排序）、插入、删除的分段过程，对整体代码进行分析与解剖。
线性表的链式表示与实现 (C语言实现，使用Clion客户端编写)
zzuli-ycz的博客
12-03 461
项目结构 单链表的基本运算项目结构定义结构体单链表的初始化判断单链表是否为空按序号查找操作按内容查找操作定位操作插入操作删除操作表的长度和销毁表 定义结构体 typedef int DataType; /** 定义单链表结构体 */ typedef struct Node { DataType date; //数据域 struct Node *next; //指针域 } ListNode, *LinkList; //ListNode为链表的节点类型，LinkList为指向链表
数据结构（C语言） 线性表的链式表示和实现
AtomQQ_2022313691的博客
06-26 993
预定义常量和类别 见预定义常量和类型 存储结构 //----线性表的单链表存储结构---- typedef struct LNode { ElemType data; struct LNode* next; }LNode,*LinkList; 基本操作的函数原型说明 void CreateList_L_head(LinkList& L, int n); //操作结果：逆位序输入n个元素的值，建立带头结点的单链线性表L。 void CreateList_L_tail(LinkList&
数据结构总结
vivid的技术专栏
10-22 3449
栈和队列是两种特殊的线性表，它们的逻辑结构和线性表相同，只是其运算规则较线性表有更多的限制，故又称它们为运算受限的线性表。栈和队列被广泛应用于各种程序设计中。队列（头尾都可以动）1、定义    　队列（Queue）是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表　　（1）队头（Front）端允许删除     （2）队尾（Rear）端允许插入　　（3）当队列中没有元素时称为空队列（有两次
五、【线性表】线性表的链式表示和实现
fujz123的博客
05-27 639
线性表的链式表示和实现 上节提到，由于顺序表的特点是逻辑关系上相邻的两个元素在物理位置上也相邻，因此可以随机存取表中任一元素。然而，这也导致了顺序表在执行插入或删除操作时，需要移动大量元素。本节来讨论线性表的另一种存储方式——链式存储结构。 1 线性表的链式表示 1.1 单链表的定义 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这些存储单元可以连续也可以不连续。因此，为了表示每个数据元素与其后驱的逻辑关系，除了存储其信息本身外，还需要存储一个指示其后驱的信息（即其后驱的存储地址
线性表的链式表示和实现 C语言 数据结构
11-12
用C语言编写数据结构 线性表的链式表示和实现
线性表的链式存储结构及代码实现（单链表，双链表，循环链表）
weixin_43800761的博客
07-08 3161
  在上一篇博文中介绍了线性表的顺序存储方式，它最大的缺点就是在插入和删除操作时会移动大量的元素，这显然会耗费很多时间。后来人们便想到了用链式存储方式来解决上面这一问题。链式存储线性表时，不需要使用地址连续的存储单元，即不要求逻辑上相邻的元素在物理位置上也相邻，它通过 “链” 建立起数据元素之间的逻辑关系，因此插入和删除操作不需要移动元素，而只需修改指针，但也会失去顺序表可随机存取的优点。 一、单链表 1.1 单链表的定义   线性表的链式存储又称单链表，它是指通过一组任意的存储单元来存储线性表中的数据元素
【数据结构与算法】线性表的链式表示和实现，超详细【C语言版】
胡毛毛的博客
09-24 3024
目录链式存储结构与链式存储有关的术语头指针、头结点和首元结点讨论1. 如何表示空表？2. 在链表中设置头结点有什么好处？3. 头结点的数据域内装的是什么？链表（链式存储结构）的特点链表的优缺点优点缺点2.5.1 单链表的定义和实现单链表的存储结构定义指针变量和结点变量2.5.2 单链表基本操作的实现1、初始化2、取值3、查找算法描述4、插入算法步骤算法描述5、删除算法步骤算法描述链表的运算时间效率分析1. 查找:2. 插入和删除:单链表的建立（前插法）单链表的建立（前插法）算法描述单链表的建立（尾插法）单链
线性表的链式表示和实现
02-24 1039
硬核： 线性表中的链表表就是在内存中用一组地址不连续的存储单元依次存储线性表的数据元素 下面是常用的方法： #include<cstdio> #include<cstdlib> #define ElemType int #define Status int using namespace std; //链表的结构 （数据域和指针域） typedef stru...
数据结构:单链表
rosefun96的博客
01-23 391
1、描述 单链表描述： typedef char DataType; //假设结点的数据域类型为字符 typedef struct node{ //结点类型定义 DataType data; //结点的数据域 struct node *next;//结点的指针域 }ListNode; typedef ListNode *LinkList;
线性表的链式表示（代码带注释和运行截图含完整代码）
pro_daily的博客
03-08 1370
问题描述 实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。 基本要求 （1）依次从键盘读入数据，建立带头结点的单链表； （2）输出单链表中的数据元素 （3）求单链表的长度； （4）根据指定条件能够取元素和修改元素； （5）实现在指定位置插入和删除元素的功能。 源代码（加注释） #include <stdio.h> #include <stdlib.h> #define ERROR NULL typedef enum {fals
线性表链式表示和实现（C语言)
世纪末的架构师的博客
11-07 1万+
线性表链序表示和实现（C语言) 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素，而线性表的链式存储特点则是用一组任意的存储单元存储线性表的数据元素。这组存储单元既可以是连续的，也可以是不连续的。 对于链式存储的每个数据元素而言，除了存储其本身的信息之外，还需要存储一个指示其直接后继的信息，即直接后继的存储位置。这两部分信息组成了数据元素的存储映像，称为结点。 链式存储的结构包含两个域：一个用于存储数据元素的信息，另一个用于存储直接后继的存储位置；存储数据元素信息的域称为数据域，存储直
数据结构之线性表的链式存储实现（附完整代码）
热门推荐
玥玥的博客博客博客
08-10 2万+
顺序表插入、删除时需要通过移动数据来实现，影响了执行效率。 而链表不要求逻辑上相邻的两个数据元素物理上也相邻，因此对线性表的插入、删除不需要移动数据元素，只需要修改链。 下面介绍带头结点的链式表： 数据结构： typedef int ElementType; typedef struct LNode * PtrToLNode; struct LNode{ ElementType Dat...
数据结构C语言版的线性表知识点
03-28
1. 线性表的定义和基本操作 - 线性表是一种数据结构，由零个或多个数据元素组成，数据元素之间是有序的，且每个数据元素只有一个前驱和一个后继。 - 基本操作包括插入、删除、查找、遍历等。 2. 线性表的顺序存储结构 - 线性表的顺序存储结构是指将线性表中的数据元素存储在一段连续的存储单元中。 - 顺序存储结构的优点是随机存取，操作简单高效。 - 顺序存储结构的缺点是插入、删除操作需要移动大量元素。 3. 线性表的链式存储结构 - 线性表的链式存储结构是指将线性表中的数据元素存储在一些不连续的存储单元中，这些存储单元可以是任意的物理位置。 - 链式存储结构的优点是插入、删除操作方便，不需要移动元素。 - 链式存储结构的缺点是不能随机存取，需要遍历整个链表才能访问某个元素。 4. 线性表的单链表和双向链表 - 单链表是指每个节点只有一个指针指向下一个节点。 - 双向链表是指每个节点有两个指针，一个指向前一个节点，一个指向后一个节点。 5. 线性表的循环链表 - 循环链表是指链表的最后一个节点的指针指向链表的第一个节点，形成一个环。 - 循环链表可以解决单链表遍历到最后一个节点时需要特殊处理的问题。 6. 线性表的静态链表 - 静态链表是指使用数组来实现链表的存储结构。 - 静态链表可以解决动态分配内存的问题，但是插入、删除操作仍然需要移动元素。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值