数据结构-线性表之单链表

最新推荐文章于 2023-03-01 11:18:01 发布

快乐江湖

最新推荐文章于 2023-03-01 11:18:01 发布

阅读量684

点赞数 6

分类专栏：【其它|未分类】文章标签：数据结构单链表

本文链接：https://blog.csdn.net/qq_39183034/article/details/110826040

版权

【其它|未分类】专栏收录该内容

81 篇文章 6 订阅

订阅专栏

一：相关概念

（1）什么是链表

官方定义：链表是一种物理存储结构上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的
用一张图表示如下：
在这里插入图片描述

可以这样描述：结点散落的分布在内存区域中，每个结点地址保存在前一个结点的指针域中，同时该结点的指针域又保存下一个结点的地址。
指向第一个结点的指针叫做头指针

在这里插入图片描述

（2）链表的优点和缺点

链表的优点是相对于顺序表而言的，由于顺序表一次开辟一大片空间，而且增容时也会造成一定空间的浪费。所以链表可以按需索取，同时其插入和删除也十分方便
当然链表也是有缺点的，最大的缺点在于它不能像顺序表那样随机访问，就拿最普通的单链表而言，要想找到它最后一个结点，那么必须完整访问前n-1个结点，类似于按图索骥。

（3）链表的分类

链表的分类很多，带头结点，不带头结点，单链表，双链表等等。但是我们最常用的就是以下两种
在这里插入图片描述

二：实践

（1）准备工作

和前面一样，也是三个文件
在这里插入图片描述

（2）结构体定义

对比顺序表，顺序表就像是许多相同的结构体，依次排列，虽然这样说不准确，但是有助于理解。那么对于链表来说，可以比喻为把顺序表中的每个结点“打散”，分散于内存中，以前对于顺序表来说，整个结点全放数据就很OK，那是因为下一个数据一定在该结点后面，不用担心找不见。但是对于链表来说，把它“打散”之后，就存在一个问题，如何去找下一个元素？就像一条链子，其中一环断了，整个也就断了。也就是说，对于链表，它的结点内不能只存放数据，还必须腾出一定空间来放一个指针，这个指针指向下一个结点
通过上述描述，可以定义单链表中每个结点的结构体如下

在这里插入图片描述

（3）操作

A：创造头结点(初始化)

①：头结点？头指针？

一个单链表一定会有一个头指针，头指针一定指向第一个结点，如果它指向的第一个结点没有存放数据（这个结点也经常叫做哨兵结点），这样的链表称为带头结点的链表，相反如果它指向的第一个结点存放了数据，这样的链表称为不带头结点的链表（不带头结点的链表是oj题的“常客”）
在这里插入图片描述

这两种链表在插入第一个结点时情况稍有不同：假设头结点已经申请好，此时要插入第一个结点NewNode

head=NewNode//不带头结点
head->next=NewNode//带头结点

可以发现，带头结点链表虽然浪费了一个空间，但是它把许多操作都归一化了，使得第一个结点不那么特殊，也就是不需要特殊处理
但是oj题给你永远都是不带头结点的链表。

②：初始化

初始化时，按需索取，开始只有一个头结点
在这里插入图片描述

B：打印

C：单链表尾插

①：如何尾插？

顺序表由于可以随机访问，所以把数组传过去，然后直接找到末尾元素即可。那么对于链表就有点不同了，我能传过去的只是第一个结点，由第一个结点可以知道第二个结点，由第二个结点可以知道第三个几点····依次类推。所以我要尾插时**，就必须找到尾结点**，那么怎么就知道它是尾节点呢？其实也很容易，尾节点它是最后一个结点，那么它的next肯定为NULL，所以我只需将第一个结点传过去，然后创建一个循环指针（一定要创建一个循环指针，不能直接拿上第一个节点的指针循环，这样头指针变了，整个链表丢了），从第一个结点的位置开始循环访问，直到你所指向的这个结点的next分量为NULL时，这个结点就是尾结点。

②：尾插代码第一种

根据以上的分析，我们似乎可以写出下面的代码
在这里插入图片描述
但是运行之后，却什么都没有

这是为什么呢？我们通过调试可以一探究竟

那这个问题就是我前面说过的不带头结点链表和带头结点链表的问题。这里我们申请的是不带头结点的链表，head指针开始时NULL，因为链表为空，它没有结点可以指向。所以在进入尾插函数，用把head赋值给了tail，tail也为空，也就不能进行“->”这样的操作。
那么你可能会想，那直接把newNode的值赋值给tail就可以了，但是需要明白，tail确实此时会指向newNode，但是head还处于游离状态，如果不能把head指向第一个结点，那么这个链表等于没有构造，因为“火车头”都按不上，还能叫火车吗？
所以这里就必须分为两种情况，这就是不带头结点的链表的一个小弊端，也就体现在插入第一个结点时的这种尴尬情况。所以改写如下

在这里插入图片描述
但是运行之后，依旧没有东西

仍然通过调试，一探究竟

可以发现，进入尾插函数后，把NeNode值赋值给了Phead，但是head依旧没变，所以就不可能打印。
所以这也是大多数人最容易犯错的地方，因为我们对于指针的第一映像，总感觉它是万能的，但是我们没有意识到一点是，指针为什么能发挥作用？这是因为指针的解引用操作。
但凡是学过C语言的人，在接触指针这一节时，绝对会知道一个关于指针交换变量的值的例子。如果传值就不能交换，而为什么传值，或者是什么情况下叫做传值，这个问题是很多人没有想过的。这里我的体会是，调用函数时传入的变量的类型和形参接受的变量的类型一致时这就是传值，所以我们上述尾插时，传入尾插函数的是一级指针变量，被调函数形参也用一级指针接受，所以一旦涉及到赋值操作，也就是上面的phead=NewNode，就不可能成功，相反咋们在else语句中写的那个却是正确的，因为此时我们拿到一级指针没有用它来赋值，而是进行解引用，也就是指针的本职工作。但是为什么最后依旧没有输出呢，就是因为第一次这个特殊情况，head没有被修改，自然而然整个队列都找不见。
经过以上分析，改写如下
在这里插入图片描述
（这里，终于成功了！）

②：尾插代码第二种

上述代码实现了尾插。但是有什么缺陷呢？观察尾插函数可以知道，其中有一个关键步骤，就是寻找尾节点，虽然计算机对于比较这样的一个操作执行起了不会费太大力气，但是这种写法总让我们感觉有点“傻”，总感觉是在做无用功一样。我们能不能想一种方法，定位它的尾节点，使其在进入尾插函数后，不用比较，直接根据记录进行插入。

在这里插入图片描述

D：单链表尾删

对于单链表来说，初学者最容易犯错的就是尾插处的二级指针问题，只要把尾插明白了，尾删还是很容易的。
在尾删时要考虑三种情况，分别是单链表尾空，单链表内只有一个元素和正常情况

如果单链表是空的，那么删除时就要报错
如果单链表只有一个元素，那么删除完一个后，头指针就要置空
在正常情况下删除，最后一个节点空间释放后，前一个结点就作为了尾节点。
对于上面的第三题删除逻辑如下

E：单链表头插

①：如何头插？

头插的逻辑如下
在这里插入图片描述

②：头插代码

在这里插入图片描述

F：单链表头删

①：如何头删？

头删时注意讨论情况（这种删法粗暴直接，但是容易出现内存泄漏的问题）
头删逻辑如下在这里插入图片描述

②：头删代码

在这里插入图片描述

G：单链表查找

在这里插入图片描述

H：单链表任意位置插入

在某位置插入时，首先得到该位置的地址，所以要调用上述查找函数
逻辑如下
在这里插入图片描述
代码如下
请添加图片描述

I：单链表任意位置删除

删除逻辑如下
在这里插入图片描述
代码如下

三：全部代码

头文件

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SlistDataType;

//结点类型定义
typedef struct SlistNode
{
	SlistDataType data;//数据域
	struct SlistNode* next;//指向下一个结点的指针
}SlNode;

void SlistPushBack(SlNode** head,SlNode** tail, SlistDataType x);//尾插
//void SlistPushBack(SlNode** phead, SlistDataType x);//尾插
void SlistPopBack(SlNode** phead);//尾删
void SlistPushFront(SlNode** phead,SlistDataType x);//头插
void SlistPopFront(SlNode** phead);//头删

SlNode* SlistFind(SlNode* head, SlistDataType x);//找元素

SlNode* Slistinsert(SlNode* pos, SlistDataType x);//任意位置插入
SlNode* Slistdelete(SlNode* pos);//任意位置删除

void SlistPrint(SlNode* head);//打印

函数文件

#include "Slist.h"

void SlistPushBack(SlNode** phead, SlNode** ptail, SlistDataType x)//尾插-带尾节点
{

	SlNode* NewNode = (SlNode*)malloc(sizeof(SlNode));
	NewNode->data = x;
	NewNode->next = NULL;

	if ((*phead) == NULL)
	{
		(*phead)= NewNode;
		(*ptail) = NewNode;
	}
	else
	{
		(*ptail)->next = NewNode;
		(*ptail) = NewNode;
	}
	
}

//void SlistPushBack(SlNode** phead, SlistDataType x)//尾插
//{
//	SlNode* NewNode = (SlNode*)malloc(sizeof(SlNode));
//	if (NewNode == NULL)
//	{
//		printf("申请结点失败\n");
//		exit(-1);
//	}
//	NewNode->data = x;
//	NewNode->next = NULL;
//	SlNode* tail =(*phead);
//	if ((*phead)== NULL)
//	{
//		(*phead) = NewNode;
//	}
//	else
//	{
//		while (tail->next != NULL)
//		{
//			tail = tail->next;
//		}
//		tail->next=NewNode;
//	}
//	
//
//
//}

void SlistPopBack(SlNode** phead)//尾删
{
	if ((*phead) == NULL)
	{
		printf("错误，空链表");
		exit(-1);
	}
	else if ((*phead)->next == NULL)
	{
		free(*phead);
		(*phead) = NULL;
	}
	else
	{
		SlNode* current = (*phead);
		SlNode* pre = NULL;
		while (current->next != NULL)
		{
			pre = current;
			current = current->next;
		}
		free(current);
		pre->next = NULL;
	}

}
void SlistPushFront(SlNode** phead, SlistDataType x)//头插
{
	SlNode* newNode = (SlNode*)malloc(sizeof(SlNode));
	newNode->data = x;
	newNode ->next= NULL;
	if (*phead == NULL)
	{
		(*phead) = newNode;
	}
	else
	{
		newNode->next = (*phead);
		(*phead) = newNode;
	}
	

	
}
void SlistPopFront(SlNode** phead)//头删
{
	if ((*phead) == NULL)
	{
		printf("错误，链表为空\n");
		exit(-1);
	}
	if((*phead)->next==NULL)
	{
		(*phead) = NULL;
	}
	else
	{
		(*phead) = (*phead)->next;
	}

}
SlNode* SlistFind(SlNode* head, SlistDataType x)
{
	SlNode* current = head;
	while (current->data != x)
	{
		current = current->next;
	}
	return current;

}
SlNode* Slistinsert(SlNode* pos, SlistDataType x)
{
	SlNode* newNode = (SlNode*)malloc(sizeof(SlNode));
	newNode->data = x;
	newNode->next = NULL;
	newNode->next = pos->next;
	pos->next = newNode;

}
SlNode* Slistdelete(SlNode* pos)
{
	assert(pos);
	if (pos->next != NULL)
	{
		SlNode* current = pos->next;
		pos->next = current->next;
		free(current);
		current = NULL;
	}


}
void SlistPrint(SlNode* head)//打印
{
	SlNode* current = head;//申请一个遍历指针，因为头指针不能乱跑
	while (current!= NULL)
	{
		printf("%d->", current->data);
		current = current->next;//指针后移
	}
	printf("NULL");
}

测试文件

#include "Slist.h"

void test()//增删测试
{
	SlNode* head=NULL;
	SlNode* tail = head;
	SlistPushFront(&head, 1);
	SlistPushFront(&head, 2);
	SlistPushFront(&head, 3);
	SlistPushFront(&head, 4);
	SlistPushFront(&head, 5);
	SlistPrint(head);
	printf("\n");

	//要删元素4后面的3，首先拿到元素4的地址
	SlNode* find= SlistFind(head, 4);
	Slistdelete(find);
	SlistPrint(head);
	printf("\n");
}

int main()
{

	test();//增删测试
	return 0;
}

快乐江湖

关注

6
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
1
评论
数据结构-线性表之单链表

文章目录一：相关概念（1）什么是链表（2）链表的优点和缺点（3）链表的分类二：实践（1）准备工作（2）结构体定义（3）说明一：相关概念（1）什么是链表官方定义：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的用一张图表示如下：当然这种表示总感觉和顺序表没有区别，所以我觉得这样表示可能更为形象：结点散落的分布在内存区域中，每个结点地址保存在前一个结点的指针域中，同时该结点的指针域又指向下一个结点的位置这里第一个结点比较特殊，所以我们用一个指针
复制链接

扫一扫