数据结构——单链表（1）

Understanding_movies

已于 2023-03-11 11:27:56 修改

阅读量180

点赞数 4

文章标签：数据结构链表

于 2023-03-11 10:59:22 首次发布

本文链接：https://blog.csdn.net/m0_65105533/article/details/129287535

版权

1.定义

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储的数据元素数据域，另一个是存储下一个结点地址的指针域。

2.链表的构造

链表由一系列结点组成，结点可以在运行时动态生成。且每一个节点都是一个结构体。

typedef int SLTDataType;
struct SListNode
{
	SLTDataType data;
	//存储的数据元素数据域
	struct SListNode* next;
	//存储下一个结点地址的指针域
	//【注意点1】：结构体不能进行嵌套，
	// 此处的"struct SListNode*"存放的时结构体类型的指针，
	//表示该指针指向的内存空间元素类型为结构体，实际上就是下一个节点。
	//【注意点2】：此处易写为"SLTNode* next"
	//错误！ 在结构体中，编译器进行编译时，从上向下编译，此时还未定义SLTNode类型。
}SLTNode;

3.链表的打印

void SLTPrint(SLTNode* phead) {
	//此处不需要进行断言，空链表也可以进行打印
	SLTNode* cur = phead;
	while (cur != NULL) {
		printf("%d->", cur->data);
		cur = cur->next;
		//cur++;
		//【易错点：】指针++表示在连续的空间中跳过一个类型（结构体）的大小的内存空间
		//但是链表是一种物理存储单元上非连续、非顺序的存储结构
	}
	printf("NULL\n");
}

cur=cur->next可以实现链表的向下链接的原因：

（上图为链表的逻辑结构）

cur->next是一个结构体指针，存放的是下一个节点的地址。

将cur->next赋给cur实际就是使cur指向下一个节点。

最后一个节点存放的地址是NULL。

【易错点：】循环判断条件易写为cur->next != NULL

此时将无法打印最后一个节点的数据4。

（上图为链表的物理结构）

4.链表的使用

4.1 创建新的链表节点

SListNode* BuySLTNode(SLTDataType x) {
	//创建一个新的节点
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	//对是否创建节点进行检验
	if (newnode == NULL) {
		perror("malloc fail");
		return;
	}
	//对已创建的节点进行初始化
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

4.2 尾插

尾插的本质：原尾节点中要存储新尾节点的地址。

void SLPushBack(SLTNode* phead, SLTDataType x)；
//尾插函数声明

此时链表的逻辑结构如下所示：

新的节点与之前的链表并未链接，需要进行找尾。

尾的特征：tail(表示尾)->next = NULL

	//找尾
	SLTNode* tail = phead;
	while (tail->next != NULL) {
		tail = tail->next;
	}
	tail->next = newnode;

【极端情况（链表为空）分析】

//判断首节点是否为NULL
	if (phead == NULL) {
		phead = newnode;

	}

将newnode赋值给phead实际上就是将newnode中存储的新开辟的内存空间的空间赋值给phead，使phead指向新开辟的内存空间。

但是，SLPushBack( )函数结束后，所有的局部变量将销毁。形参（phead）的改变不会影响实参（phead）。故此时phead仍为空。

【根据传址的经验】改变int类型的实参，需要使用int*

则改变int*类型的实参，需要使用int**.

此处指针类型为strcut, 则需要使用struct**类型进行改变

函数改变如下：

void SLPushBack(SLTNode** pphead, SLTDataType x){
	SLTNode* newnode=BuySLTNode(x);
	//判断首节点是否为NULL
	if (*pphead == NULL) {
		*pphead = newnode;
	}
	//找尾
	SLTNode* tail = *pphead;
	while (tail->next != NULL) {
		tail = tail->next;
	}
	tail->next = newnode;

}

4.3 头插

void SLTPushFront(SListNode** pphead, SLTDataType x) {
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	//*pphead即为phead,phead指向下一个节点
	*pphead = newnode;

}

【考虑极端情况（phead指向NULL）】

考虑代码 newnode->next=*pphead;

即newnode->next指向phead所指向的内存空间（存储NULL）

*pphead=newnode;

即将newnode设为头指针

情况成立！

4.4 尾删

在了解尾插的基础上我们进行尾删。

首先，我们需要找尾。注意：此处的尾是指尾的前一项。只有找到尾前一项并将其与NULL链接，才可以达到尾删的目的。

void SLPopBack(SLTNode** pphead) {
	//先找尾的前一项
	//找尾
	SLTNode* tail = *pphead;
	while (tail->next->next != NULL) {
		tail = tail->next;
	}
}

其次，我们需要释放尾指向的空间

	//释放tail所指向的空间
	free(tail->next);

最后，将尾前一项与NULL链接

	tail->next= NULL;

此时，尾删的代码如下：

void SLPopBack(SLTNode** pphead) {
	SLTNode* tail = *pphead;
	while (tail->next->next != NULL) {
		tail = tail->next;
	}
	free(tail->next);
	tail->next = NULL;
}

【考虑极端情况】：只有一个节点以及节点为空

//只有一个节点
if(*pphead->next==NULL){
    free(*pphead);
    *pphead=NULL;
}

//节点为空
//对节点进行断言
assert(*pphead!=NULL);

尾删函数的完整代码如下：

void SLPopBack(SLTNode** pphead) {
	//节点为空
	//对节点进行断言
	assert(*pphead != NULL);
	//只有一个节点
	if (*pphead->next == NULL) {
		free(*pphead);
		*pphead = NULL;
	}
	//先找尾的前一项
	//找尾
	else {
		SLTNode* tail = *pphead;
		while (tail->next->next != NULL) {
			tail = tail->next;
		}
		//释放tail所指向的空间
		free(tail->next);
		tail->next = NULL;
	}
	}

4.5 头删

由链表头删的逻辑结构图易知，头删时，不需要单独考虑只有一个节点的情况（只有一个节点和有多个节点的步骤相同）。

【注意！】不论是头删还是尾删，不能存在空节点（无法进行删除）。

void SLTPopFront(SListNode** pphead) {
	//节点为空
	//对节点进行断言
	assert(*pphead != NULL);
	SListNode* first = *pphead;
	*pphead = first->next;
	free(first);
	first = NULL;
}

5.最后，对所有的代码进行测试：

头文件（SList.h）

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

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;
void SLTPrint(SLTNode* phead);
void SLTPushBack(SLTNode** pphead, SLTDataType x);
void SLTPushFront(SLTNode** pphead, SLTDataType x);
void SLTPopBack(SLTNode** pphead);
void SLTPopFront(SLTNode** pphead);

源文件1（SList.c）

#include "SList.h"

void SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = BuySLTNode(x);

	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		// 找尾
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		tail->next = newnode;
	}
}

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}


void SLTPopBack(SLTNode** pphead)
{
	// 暴力检查
	assert(*pphead);
	// 1、只有一个节点
	// 2、多个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;
	}
}

void SLTPopFront(SLTNode** pphead)
{
	// 暴力检查
	assert(*pphead);
	SLTNode* first = *pphead;
	*pphead = first->next;
	free(first);
	first = NULL;
}

源文件2（Test.c）

#include"SList.h"
int main()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	return 0;
}

运行结果（尾插）：