【数据结构之单链表】

数据结构学习笔记---003

  • 数据结构之单链表
    • 1、什么是单链表?
      • 1.1、概念及结构
    • 2、单链表接口的实现
      • 2.1、单链表的SList.h
        • 2.1.1、定义单链表的结点存储结构
        • 2.1.2、声明单链表各个接口的函数
      • 2.2、单链表的SList.c
        • 2.2.1、遍历打印链表
        • 2.2.2、销毁单链表
        • 2.2.3、打印单链表元素
        • 2.2.4、单链表的基本操作
      • 3.3、单链表的main.c
        • 3.3.1、TestSL1()
        • 3.3.2、TestSL2()
    • 4、单链表巩固练习
      • 4.1、单链表巩固练习题01 --- 求链表的中间节点
      • 4.2、单链表巩固练习题02 --- 移除链表元素
      • 4.3、单链表巩固练习题03 --- 链表分割
    • 5、单链表总结

数据结构之单链表

前言:
前篇学习了 数据结构的顺序表 那么这篇继续学习数据结构线性表的第二种存储方法,链式存储的单链表。
/知识点汇总/

1、什么是单链表?

1.1、概念及结构

概念:单链表是一种物理存储结构上非连续、非顺序的存储结构,但链表在逻辑上是连续的,顺序的,而数据元素的逻辑顺序是通过链表中的指针连接次序实现的。

由于顺序表的插入删除操作需要移动大量的元素,影响了运行效率,因此引入了线性表的链式存储——单链表。

单链表通过一组任意的存储单元来存储线性表中的数据元素,不需要使用地址连续的存储单元,因此它不要求在逻辑上相邻的两个元素在物理位置上也相邻。

单链表(Singly Linked List)是一种常用的数据结构,它由若干个节点组成,每个节点包含两部分:数据域和指针域。
数据域用于存储数据,而指针域则用于指向下一个节点的地址。 单链表中每个节点只有一个指针域,指向下一个节点,最后一个节点的指针域指向NULL,表示链表的结尾。

2、单链表接口的实现

在实际应用中,单链表的存储思想就是用指针表示各结点之间的逻辑关系。 本质就是掌握好结点间的链式处理。

然后与前篇学的顺序表不同,就不存在扩容的问题了,但仍然需要注意及时释放动态开辟的内存空间等问题
实现过程继续采用阶段性测试,既方便调试也方便及时解决问题。
另外单链表又分为带头结点和不带头结点的方式,这里用不带头的进行编写,具体可根据实际符合的应用场景决定。

2.1、单链表的SList.h

2.1.1、定义单链表的结点存储结构

因为是采用的多种类型的数据,所以适用于结构体类型。然后知道了需要一个数据域和指针域,所以定义结构体如下所示:

//定义单链表的动态存储
typedef int SLNDataType;//这里的重命名主要作用是,不能保证每次使用都是整型,所以只需要改这里为其它类型更健壮和便利
//Single List
typedef struct SLNode    //定义单链表结点类型为结构体类型包括数据域和指针域
{
	SLNDataType val;         //结点数据域
	struct SLNode* next; //结点指针域,存放下一个结点的地址
}SLNode;
2.1.2、声明单链表各个接口的函数
//遍历打印链表
void SLPrint(SLNode* pphead);
//尾插
void SLTPushBack(SLNode** pphead, SLNDataType x);
//头插
void SLTPushFront(SLNode** pphead, SLNDataType x);
//尾删
void SLTPopBack(SLNode** pphead);
//头删
void SLTPopFront(SLNode** pphead);
//查找
SLNode* SLTFind(SLNode* phead, SLNDataType x);
//pphaed = NULL ,错误
//*pphead = NULL,空表
//(*pphead)->next = NULL,一个结点
//在pos位置的前面插入
void SLTInsert(SLNode** pphead,SLNode* pos, SLNDataType x);
//删除pos的位置结点
void SLTErase(SLNode** pphead, SLNode* pos);
//在pos的位置之后的操作,就不存在头插头删的情况,参数就不用传plist了
//在pos的位置之后插入
void SLTInsertAfter(SLNode* pos, SLNDataType x);
//在pos的位置之后删除
void SLTEraseAfter(SLNode* pos);
//销毁单链表
void SLTDestory(SLNode** pphead);

2.2、单链表的SList.c

主要还是要完成 SList.h 接口对应的 .c 功能函数。
有了前篇的意识和基础,对于单链表的初始化可以有但没必要,因为不带头结点本身不用就是空表,那么就体现在后面建立结点函数的写法中对初始化的处理了。但为了对比和理解,把带头结点的常规写法也写一下,但后面继续以不带头的结点写。
初始化单链表(带头结点)

Node* InitList()
{
  Node* first = (Node*)malloc(sizeof(Node)); //生成头结点
  first->next = NULL;                        //头结点的指针域置空
  return first;
}
2.2.1、遍历打印链表

为了打印单链表的元素,这里需要像顺序表那样遍历,所以引用一个工作指针,依次访问指针域打印各个结点的数据域中元素。工作指针的本质是读数据域而不作更改,防止写动数据等问题。

//遍历打印链表
void SLPrint(SLNode* phead)
{
	SLNode* cur = phead;//定义工作指针,防止更改了phead的地址
	while (cur != NULL)
	{
		printf("%d->", cur->val);//读数据域
		cur = cur->next;        //偏移指针域
	}
	printf("NULL\n");
}
2.2.2、销毁单链表

为了避免忘记销毁开辟的动态内存空间。所以这里使用动态存储方法,那么通常把初始化和销毁一块就写出来了。

//顺序表的销毁
void SLDestory(SL* ps1)
{
	//暴力检查
	assert(ps1);//一定不能为空
	if (ps1->a != NULL)
	{
		free(ps1->a);
		ps1->a = NULL;
		ps1->size = 0;
		ps1->capacity = 0;
	}
}
2.2.3、打印单链表元素

为了直观的体现数据元素是否成功操作,所以接着写出打印接口函数。

//打印顺序表
void SLPrint(SL* ps1)
{
	//暴力检查
	assert(ps1);//一定不能为空
	for (int i = 0; i < ps1->size; i++)
	{
		printf("%d ", ps1->a[i]);
	}
	printf("\n");
}
2.2.4、单链表的基本操作

完成了上述函数的功能,那么就可以实现单链表的基本操作了。插入和删除以及查找(无非就是增删改查)。
头插和头删;尾插和尾删。
其次,对于开辟新结点的操作多个函数都涉及到,所以可以封装成单独的CreateNode函数,如下所示:

//开辟新结点,且next置空
SLNode* CreateNode(SLNDataType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		//return;
		exit(-1);
	}
	newnode->val = x;
	newnode->next = NULL;
	return newnode;
}

尾插、头插、尾删、头删的操作,需要注意一下,判空和空表的情况。

//尾插
void SLTPushBack(SLNode** pphead, SLNDataType x)
{
	assert(pphead);
	//空结点的处理
	SLNode* newnode = CreateNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找尾(链表不为空,只需要下面的部分,但尽可能的健壮代码,所以需要考虑链表为空的情况)
		SLNode* tail = *pphead;
		//while (tail != NULL),容易掉的坑,这样写画图很清楚的看到,链表并没有链接起来;而且除了作用域tail销毁,尾结点会存在内存泄漏的问题
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		//因为多个函数都需要开辟新节点,所以直接封装为函数
		//而且不能直接SLNode* newNode:来定义结构体来开辟,因为这里只能作用域为局部变量,所以需要malloc才行。
		//SLNode* newNode = (SListNode*)malloc(sizeof(SLNode));
		//SLNode* newnode = CreateNode(x);已放开头
		tail->next = newnode;
	}
}

//头插
void SLTPushFront(SLNode** pphead, SLNDataType x)
{
	assert(pphead);
	SLNode* newnode = CreateNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}
//尾删
void SLTPopBack(SLNode** pphead)
{
	//注意pphead一定不能为空,所以需要检查
	assert(*pphead);
	assert(pphead);
	//区分一个结点和多个结点

	//这两句的位置不同,对应的写法不同
	/*
	SLNode* tail = *pphead;
	//Node* prev = *pphead;//错误,初始化为*phead时,如果首结点被free时,那么prev就会成为野指针。
	SLNode* prev = NULL;
	if (tail->next == NULL)//一个节点
	{
		free(tail);
		tail = NULL;
	}
	*/
	if ((*pphead)->next == NULL)//一个节点
	{
		free(*pphead);
		*pphead = NULL;
	}
	else//找尾
	{
		//这两句的位置可以写这儿
		SLNode* tail = *pphead;
		//Node* prev = *pphead;//错误,初始化为*phead时,如果首结点被free时,那么prev就会成为野指针。
		SLNode* prev = NULL;

		while (tail->next != NULL)
		{
			/*tail = tail->next;
			prev = tail;*/
			//错误,注意顺序是不可以交换的,因为当tail到空时,还赋给prev就导致为野指针了
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		prev->next = NULL;
		//一种简化写法
		/*
		SLNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);//释放的是指针指向的内存空间,而不是指针本身
		tail->next = NULL;
		*/
	}
}
//头删
void SLTPopFront(SLNode** pphead)
{
	assert(*pphead);
	assert(pphead);
	//if ((*pphead)->next == NULL)//一个节点
	//{
	//	free(*pphead);
	//	*pphead = NULL;
	//}

	//一个以及以上结点都能处理
	//方法1:
	//SLNode* tail = *pphead;
	//tail = tail->next;
	//free(*pphead);
	//*pphead = tail;
		//方法2:
	//SLNode* tail = *pphead;
	//*pphead = (*pphead)->next;
	//free(tail);

	//方法3:
	SLNode* tmp = (*pphead)->next;;
	free(*pphead);//注意顺序不能交换
	*pphead = tmp;
}

查找、在pos位置的前面插入、删除pos的位置、在pos的位置之后插入和在pos的位置之后删除操作。

//查找
SLNode* SLTFind(SLNode* phead, SLNDataType x)
{
	assert(phead);
	SLNode* cur = phead;//定义工作指针,防止更改了phead的地址
	while (cur != NULL)
	{
		if (cur->val == x)
			return cur;
		cur = cur->next;        //偏移指针域
	}
	return NULL;
}
//在pos位置的前面插入
void SLTInsert(SLNode** pphead, SLNode* pos, SLNDataType x)
{
	/*assert(pphead);
	assert(*pphead);
	assert(pos);*///这种检查严格限定了pos一定为链表里的有效节点

	assert(pphead);
	assert((!pos && !(*pphead)) ||(pos && *pphead));//要么都是空,要么都不是空

	//对空处理
	if (*pphead == pos)
	{
		//调用头插
		SLTPushFront(pphead, x);
	}
	else//找插入结点的前一个结点
	{
		SLNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLNode* newnode = CreateNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}
//删除pos的位置
void SLTErase(SLNode** pphead, SLNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	//头结点梳理
	if ((*pphead)->next == NULL)
	{
		//调用头删
		SLTPopFront(pphead);
	}
	else
	{
		SLNode* prev = *pphead;
		if (prev == pos)
		{
			//调用头删
			SLTPopFront(pphead);
		}
		else
		{
			while (prev->next != pos)
			{
				prev = prev->next;
			}
			prev->next = pos->next;
			free(pos);
			pos = NULL;
		}
	}
}

//在pos的位置之后插入
void SLTInsertAfter(SLNode* pos, SLNDataType x)
{
	assert(pos);
	SLNode* newnode = CreateNode(x);
	//经典错误,单链表断开,自己指向了自己
	/*pos->next = newnode;
	newnode->next = pos->next;*/

	newnode->next = pos->next;
	pos->next = newnode;
}

//扩展:只给pos位置,如何完成想在pos之前插入呢?
//只需要在pos后面插入,交换pos的结点值即可

//在pos的位置之后删除
void SLTEraseAfter(SLNode* pos)
{
	assert(pos);
	assert(pos->next);//因为当只有一个结点时,cur=pos->next,为空,所以对pos->next访问就非法访问了。
	SLNode* cur = pos->next;
	pos->next = cur->next;
	free(cur);
	cur = NULL;
}

3.3、单链表的main.c

简单的写几个测试应用,目的是检测各个接口函数是否满足需求,是否存在一些bug。

3.3.1、TestSL1()

主要检测尾插、头插、打印和销毁接口函数,以及参数的传址调用和传值调用。

#include "SList.h"
//测试1:
void TestSLT1()
{
	SLNode* plist = NULL;
	//SLTPushBack(plist, 1);//传参为SLNode*,要想实现操作,还得使用二级指针,所以这里必须传地址 ==>不然phead只是plist的临时拷贝
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);//尾插
	SLPrint(plist);//打印
	
	SLTPopBack(&plist);//尾删
	SLPrint(plist);
	
	SLTPushFront(&plist, 5);//头插
	SLPrint(plist);
	SLTPushFront(&plist, 6);//头插
	SLPrint(plist);
	
	SLTPopBack(&plist);//尾删
	SLPrint(plist);
	SLTPopBack(&plist);//尾删
	SLPrint(plist);
}
int main()
{
	TestSLT1();
	//TestSLT2();
	//TestSLT3();
	//TestSLT4();
	//TestSLT5();
	return 0;
}

测试效果展示
【数据结构之单链表】_第1张图片

3.3.2、TestSL2()

主要检测接口函数是否满足需求,并深刻认识指针、二级指针的应用。

#include "Seqlist.h"
//测试二:
void TestSLT2()
{
	SLNode* plist = NULL;
	//SLTPushBack(plist, 1);//传参为SLNode*,要想实现操作,还得使用二级指针,所以这里必须传地址 ==>不然phead只是plist的临时拷贝
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);//尾插
	SLPrint(plist);//打印

	SLTPopFront(&plist);
	SLPrint(plist);
}
int main()
{
	//TestSL1();
	TestSL2();
	//TestSL3();
	//TestSL4();
	//TestSL5();
	//TestSL6();
	//TestSL7();
	return 0;
}

效果展示
【数据结构之单链表】_第2张图片

4、单链表巩固练习

4.1、单链表巩固练习题01 — 求链表的中间节点

求链表的中间节点 — 经典快慢指针

#include "SList.h"
//定义单链表的结构体类型
struct ListNode
{
	int val;
	struct ListNode* next;
};
struct ListNode* middleNode(struct ListNode* head)
{
	struct ListNode* slow = head;
	struct ListNode* fast = head;
	while (fast && fast->next)
	{
		slow = slow->next;
		fast = fast->next->next;
	}
	return slow;
}

int main()
{
	SLNode* plist = NULL;
	//SLTPushBack(plist, 1);//传参为SLNode*,要想实现操作,还得使用二级指针,所以这里必须传地址 ==>不然phead只是plist的临时拷贝
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);//尾插
	SLPrint(plist);//打印

	struct ListNode* pos = middleNode(plist);
	printf("pos = %d\n", pos->val);
	return 0;
}

4.2、单链表巩固练习题02 — 移除链表元素

移除链表元素 – 返回新的头结点
方法1:遍历删除

#include "SList.h"
//定义单链表的结构体类型
struct ListNode
{
	int val;
	struct ListNode* next;
};
struct ListNode* removeELements(struct ListNode* head, int val)
{
	struct ListNode* prev = NULL;//prev的作用,是在于删除对应结点后,能找到next断开之后再链接
	struct ListNode* cur = head;
	while (cur)
	{
		if (cur->val == val)
		{
			struct ListNode* tmp = cur->next;
			free(cur);
			if (prev)//必须判断首节点是否val,被free后,可能为空
				prev->next = tmp;
			else//否则,新的头结点更新
				head = tmp;
			cur = tmp;
		}
		else
		{
			prev = cur;
			cur = cur->next;
		}
	}
	return head;
}

int main()
{
	struct ListNode* n1 = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* n2 = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* n3 = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* n4 = (struct ListNode*)malloc(sizeof(struct ListNode));

	n1->val = 7;
	n2->val = 7;
	n3->val = 2;
	n4->val = 3;

	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = NULL;

	struct ListNode* head = removeELements(n1, 7);
	SLPrint(head);
	return 0;
}

方法2:遍历把不是val的结点链接到新链表,添加尾指针

#include "SList.h"
//定义单链表的结构体类型
struct ListNode
{
	int val;
	struct ListNode* next;
};
//打印链表
void SLPrint1(struct ListNode* phead)
{
	struct ListNode* cur = phead;//定义工作指针,防止更改了phead的地址
	while (cur != NULL)
	{
		printf("%d->", cur->val);//读结点域
		cur = cur->next;        //偏移指针域
	}
	printf("NULL\n");
}
struct ListNode* removeELements(struct ListNode* head, int val)
{
	struct ListNode* newnode = NULL;
	struct ListNode* tail = NULL;
	struct ListNode* cur = head;
	while (cur)
	{
		//如果不是val把结点拿到新链表(新链表为空)
		if (cur->val != val)
		{
			//尾插:两种情况
			if (tail == NULL)
			{
				newnode = tail = cur;
			}
			else
			{
				tail->next = cur;
				tail = tail->next;
			}
			cur = cur->next;
		}
		else
		{
			struct ListNode* tmp = cur;
			cur = cur->next;
			free(tmp);
		}
	}
	if(tail)//注意最后尾节点的判空,防止野指针,同时判空处理空表
		tail->next = NULL;
	head = newnode;
	return head;
}

int main()
{
	struct ListNode* n1 = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* n2 = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* n3 = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* n4 = (struct ListNode*)malloc(sizeof(struct ListNode));

	n1->val = 7;
	n2->val = 7;
	n3->val = 2;
	n4->val = 3;

	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = NULL;

	struct ListNode* head = removeELements(n1, 7);
	SLPrint1(head);
	return 0;
}

方法3:添加哨兵位头结点
哨兵位的头结点,不存储有效数据置NULL

#include "SList.h"
//定义单链表的结构体类型
struct ListNode
{
	int val;
	struct ListNode* next;
};
//打印链表
void SLPrint1(struct ListNode* phead)
{
	struct ListNode* cur = phead;//定义工作指针,防止更改了phead的地址
	while (cur != NULL)
	{
		printf("%d->", cur->val);//读结点域
		cur = cur->next;        //偏移指针域
	}
	printf("NULL\n");
}
struct ListNode* removeELements(struct ListNode* head, int val)
{
	struct ListNode* newnode = NULL;
	struct ListNode* tail = NULL;
	struct ListNode* cur = head;
	//添加哨兵位
	newnode = tail = (struct ListNode*)malloc(sizeof(struct ListNode));
	while (cur)
	{
		//如果不是val把结点拿到新链表(新链表为空)
		if (cur->val != val)
		{
			//尾插:两种情况
			tail->next = cur;
			tail = tail->next;
			cur = cur->next;
		}
		else
		{
			struct ListNode* tmp = cur;
			cur = cur->next;
			free(tmp);
		}
	}
	//哨兵位方法前面简化,而这里就需要处理
	tail->next = NULL;
	struct ListNode* tmp = newnode;
	newnode = newnode->next;
	free(tmp);
	head = newnode;//头结点next为首节点符合题目要求
	return head;
}

int main()
{
	struct ListNode* n1 = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* n2 = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* n3 = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* n4 = (struct ListNode*)malloc(sizeof(struct ListNode));

	n1->val = 7;
	n2->val = 7;
	n3->val = 2;
	n4->val = 3;

	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = NULL;

	struct ListNode* head = removeELements(n1, 7);
	SLPrint1(head);
	return 0;
}

4.3、单链表巩固练习题03 — 链表分割

链表分割 — 返回重新排列后的头指针,相对顺序不变
3 6 1 8 4 6 9 — val=5分割
3 1 4 (5)6 8 6 9
思路1:不带哨兵位,比较val小的放一个链表,大于等于val的放一个链表,再合并两个链表,同时注意判断两边链表为空的情况,即全比val大或者小的处理,所以相对于带头结点的操作就比较复杂。
思路2:带2个哨兵位,直接比较后,执行相应的尾插操作即可,最后合并。
建议采用带头结点的方法,更好处理这题

#include "SList.h"
//#include 

//定义单链表的结构体类型
struct ListNode
{
	int val;
	struct ListNode* next;
};
//打印链表
void SLPrint1(struct ListNode* phead)
{
	struct ListNode* cur = phead;//定义工作指针,防止更改了phead的地址
	while (cur != NULL)
	{
		printf("%d->", cur->val);//读结点域
		cur = cur->next;        //偏移指针域
	}
	printf("NULL\n");
}
struct ListNode* removeELements(struct ListNode* phead, int x)
{
	struct ListNode* head1;
	struct ListNode* head2;
	struct ListNode* tail1;
	struct ListNode* tail2;
	//oj题,一般malloc不会申请失败,可不作检查
	head1 = tail1 = (struct ListNode*)malloc(sizeof(struct ListNode));
	head2 = tail2 = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* cur = phead;
	while (cur)
	{
		//尾插 -- < val -->tail1
		if (cur->val < x)
		{
			tail1->next = cur;
			tail1 = tail1->next;
		}
		else//尾插 -- >= val -->tail2
		{
			tail2->next = cur;
			tail2 = tail2->next;
		}
		cur = cur->next;//判断一个走一个
	}
	//链接tail1和tail2
	tail1->next = head2->next;
	tail2->next = NULL;
	//更新头结点
	phead = head1->next;
	free(head1);
	free(head2);
	return phead;
}

int main()
{
	struct ListNode* n1 = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* n2 = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* n3 = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* n4 = (struct ListNode*)malloc(sizeof(struct ListNode));

	n1->val = 7;
	n2->val = 7;
	n3->val = 2;
	n4->val = 3;

	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = NULL;

	struct ListNode* head = removeELements(n1, 6);
	SLPrint1(head);
	return 0;
}

5、单链表总结

主要有以下两点
与顺序表不同,单链表的元素不是连续存储的,而是通过指针相连形成链式结构。因此,单链表具有以下优缺点。
优点
支持动态内存分配。由于单链表不需要预先分配一段连续的空间,因此可以根据实际需求动态地申请、释放节点空间,避免浪费内存。
支持高效的插入、删除操作。由于单链表中的节点是通过指针相连的,因此在插入、删除一个节点时,只需要修改其前驱节点或后继节点的指针即可,时间复杂度为O(1)O(1)O(1)。
缺点
不支持随机访问。由于单链表中的节点不是连续存储的,因此不能像数组一样通过下标来直接访问一个元素,需要从头节点开始遍历整个链表才能访问任意位置的元素。

你可能感兴趣的:(数据结构,数据结构,单链表,顺序表,malloc,calloc,笔记,算法,C语言)