线性表——单链表

已于 2024-01-27 11:06:47 修改
阅读量916 收藏 16
点赞数 27
分类专栏： 数据结构 文章标签： c语言 算法
于 2024-01-27 11:05:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77631043/article/details/135766206
版权

线性表——链表

  在前面的顺序表中我们提到了顺序表的优缺点，其中最大的不足是插入和删除元素需要移动大量的数据，这就对时间有一定的消耗。为了解决这个不足，本章将介绍一个成员——链表，接下来就开始本章的介绍。

1. 链式存储结构

  链式存储结构 特点： 用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。
  在链式结构中，除了要存储数据外，还需要存储下一个数据元素的地址，这样才能找到下一个元素，不然就是一盘散沙。我们把存储数据元素信息的域称为 数据域 ，存储后继元素地址的域称为 指针域 。这两个域在一起组成链表的一个元素，称之为 结点 。

  头指针是指向头结点的指针（若没有头结点就直接指向第一个结点），只用来存储地址。
  头结点是单链表 第一个结点前附设的一个结点（有时候也称为“ 哨兵 ”），目的是方便对链表的操作，它一样有数据域和指针域，而数据域可以不存储任何信息，当然也可以存储线性表长度或其他信息。
  单链表像火车车厢一样，车厢（结点）之间相互连接，有头就要有尾，最后一个结点不用指向其他元素，在指针域中放入NULL 即可，也相当于指向 NULL，以此收尾。

  头结点通常不是必须的，具体根据实际需求使用，而头指针是必须的，并且不为空。还一种情况，当头指针为空时，说明整个链表为空。

图解：

链式存储

2. 单链表的实现（无头结点）

  

2.1 结点的定义

typedef int LinkDataType;

typedef struct LinkNode		//单链表
{
	int val;	//数据域的信息
	struct LinkNode* next;	//指针域的信息
}LNode;

2.2 单链表的查找

  链表查找不需要对修改数据，所以直接传参，就不用再取地址（使用二级指针）。

LNode* LinkFind(LNode* phead, LinkDataType x)	//查找
{
	/*    注意返回值类型为LNode*    */

	LNode* cur = phead;
	while (cur)
	{
		if (cur->val == x)
		{
			return cur;	//找到了返回结点地址
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;	//找不到返回空
}

2.3 单链表的插入

  单链表的插入需要创建新的结点，我们可以对此操作进行封装。

2.3.1 新结点的创建

LNode* CreateNode(LinkDataType x)
{
	LNode* newnode = (LNode*)malloc(sizeof(LNode));	//为新结点开辟空间
	if (newnode == NULL)	//检查是否开辟成功
	{
		perror("malloc fail!");
		return -1;
	}
	newnode->val = x;		//数据域存入x
	newnode->next = NULL;	//指针域暂时指向NULL
}

2.3.2 头部插入（头插）

  这里我们创建的是一个 LNode*类型的指针：LNode* plist = NULL；所以我们就要使用二级指针来对一级指针进行操作。若外部直接创建的是LNode类型的变量，就说明创建的是一个带有头结点的链表。

就像在外部定义了 int a = 10 ；由于形参是实参的一份临时拷贝，形参的改变并不会影响实参，所以不会直接传递 int 类型，而会传递 int* ；因此，遇见 int* a = NULL；就传递 int**

void LinkPushFront(LNode** pphead, LinkDataType x)	//头插
{
	assert(pphead);		//检查pphead是否为空

	LNode* newnode = CreateNode(x);	//创建新结点
	newnode->next = *pphead;		//新结点的指针域存放原链表第一个结点的地址
	*pphead = newnode;			//*pphead再指向第一个结点
}

图解：
头插

2.3.3 尾部插入（尾插）

  尾插就需要判断链表是否为空

void LinkPushBack(LNode** pphead, LinkDataType x)	//尾插
{
	assert(pphead);

	LNode* newnode = CreateNode(x);	//新结点

	if (*pphead == NULL)
	{
		*pphead = newnode;		//如果链表为空就直接指向新结点
	}
	else
	{
		LNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;	//找尾（最终会在最后一个结点跳出循环）
		}
		tail->next = newnode;	//原链表最后一个结点指向新结点
	}
}

图解：
尾插

2.3.4 任意位置（前）插入

  这部分再在任意位置之 前 插入，需要结合链表查找的返回值进行。另外，关于pos，有些地方使用的int类型，这里根据需要自行变换。

void LinkInsert(LNode** pphead, LNode* pos, LinkDataType x)	//任意位置前插入
{
	//检查1：
	assert(pphead);
	assert(*pphead);	//检查链表是否为空
	assert(pos);	//pos是链表的一个有效结点（pos不为空）

	//检查2：
	assert((!pos && !(*pphead)) || (pos && *pphead));	//pos 和 *pphead 保持一致（都为空或都不为空）
	
	/*  检查1，检查2 根据需要任选其一即可  */
	
	if (*pphead == pos)		//pos为第一个结点时
	{
		LinkPushFront(pphead, x);	//头插
	}
	else
	{
		LNode* prev = *pphead;
		while (prev->next != pos)	//寻找 pos 的位置
		{
			prev = prev->next;
		}
		//插入：
		LNode* newnode = CreateNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

图解：
前插

2.3.5 任意位置（后）插入

  任意位置后插入就不用考虑头插的情况，也不用将链表传过来。

void LinkInsertAfter(LNode* pos, LinkDataType x)	//任意位置后插入
{
	assert(pos);
	LNode* newnode = CreateNode(x);

	newnode->next = pos->next;	//新结点指向原链表指向的位置
	pos->next = newnode;	//原链表指向新结点的位置
}

图解：
后插

2.4 单链表的删除

2.4.1 头部删除（头删）

void LinkPopFront(LNode** pphead)	//头删
{
	assert(pphead);
	assert(*pphead);
	
	//方法1：
	LNode* tail = (*pphead)->next;	//新建指针指向第二个结点
	free(*pphead);	//释放第一个结点空间
	*pphead = tail;	//头指针指向原链表第二个结点

	//方法2：
	//LNode* tail = *pphead;	//新建指针指向第一个结点
	//*pphead = (*pphead)->next;	//头指针指向第二个结点
	//free(tail);		//释放第一个结点空间
}

2.4.2 尾部删除（尾删）

void LinkPopBack(LNode** pphead)	//尾删
{
	assert(pphead);
	assert(*pphead);

	//方法1：
	//1.一个结点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//2.多个结点
	else
	{
		LNode* tail = *pphead;
		LNode* prev = NULL;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		/* 跳出循环 prev 停在倒数第二个结点，tail 停在最后一个结点 */
		
		free(tail);		//删除结点
		tail = NULL;

		prev->next = NULL;
	}

	//方法2:
	// /* 先删除，再判断链表的情况 */
	//LNode* tail = *pphead;
	//LNode* prev = NULL;
	//while (tail->next != NULL)
	//{
	//	prev = tail;
	//	tail = tail->next;
	//}
	//free(tail);
	//tail = NULL;

	//if (prev == NULL)
	//{
	//	*pphead = NULL;
	//}
	//else
	//{
	//	prev->next = NULL;
	//}

	//方法3:
	//（尽量使用以上两种）
	//LNode* tail = *pphead;
	//while (tail->next->next != NULL)
	//{
	//	tail = tail->next;
	//}
	/* tail在倒数第二个结点跳出循环 */
	//free(tail->next);
	//tail->next = NULL;

}

2.4.3 任意位置（前）删除

  需结合查找功能使用。

void LinkErase(LNode** pphead, LNode* pos)	//任意位置前删除
{
	assert(pphead);
	assert(*pphead);
	assert(pos);

	if (*pphead == pos)
	{
		LinkPopFront(pphead);	//头删
	}
	else
	{
		LNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;	// pos 前的结点直接指向 pos 后的结点
		free(pos);
		pos = NULL;
	}
}

2.4.4 任意位置（后）删除

  需结合查找功能使用。

void LinkEraseAfter(LNode* pos)		//任意位置后删除
{
	assert(pos);
	assert(pos->next);	//检查pos是否为最后一个结点

	//方法1：
	LNode* tail = pos->next->next;
	free(pos->next);
	pos->next = tail;

	//方法2：
	//LNode* tail = pos->next;
	//pos->next = pos->next->next;

	//free(tail);
	//tail = NULL;
}

2.5 单链表的打印

void LinkPrint(LNode* phead)
{
	LNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->val);
		cur = cur->next;
	}
	printf("NULL\n");
}

2.6 单链表的销毁

void LinkDestory(LNode** pphead)	//销毁
{
	assert(pphead);

	LNode* cur = *pphead;
	while (cur)
	{
		LNode* Next = cur->next;
		free(cur);
		cur = Next;
	}
	*pphead = NULL;
}

3. 功能综合

  以下综合会比较长，可以另外通过接口实现会更加清楚，可自行更改。

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

typedef int LinkDataType;

typedef struct LinkNode		//单链表
{
	int val;	//数据域的信息
	struct LinkNode* next;	//指针域的信息
}LNode;

LNode* LinkFind(LNode* phead, LinkDataType x)	//查找
{
	/*    注意返回值类型为LNode*    */

	LNode* cur = phead;
	while (cur)
	{
		if (cur->val == x)
		{
			return cur;	//找到了返回结点地址
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;	//找不到返回空
}

LNode* CreateNode(LinkDataType x)
{
	LNode* newnode = (LNode*)malloc(sizeof(LNode));	//为新结点开辟空间
	if (newnode == NULL)	//检查是否开辟成功
	{
		perror("malloc fail!");
		return -1;
	}
	newnode->val = x;		//数据域存入x
	newnode->next = NULL;	//指针域暂时指向NULL
}

void LinkPushFront(LNode** pphead, LinkDataType x)	//头插
{
	assert(pphead);		//检查pphead是否为空

	LNode* newnode = CreateNode(x);	//创建新结点
	newnode->next = *pphead;		//新结点的指针域存放原链表第一个结点的地址
	*pphead = newnode;			//*pphead再指向第一个结点
}

void LinkPushBack(LNode** pphead, LinkDataType x)	//尾插
{
	assert(pphead);

	LNode* newnode = CreateNode(x);	//新结点

	if (*pphead == NULL)
	{
		*pphead = newnode;		//如果链表为空就直接指向新结点
	}
	else
	{
		LNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;	//找尾（最终会在最后一个结点跳出循环）
		}
		tail->next = newnode;	//原链表最后一个结点指向新结点
	}
}

void LinkInsert(LNode** pphead, LNode* pos, LinkDataType x)	//任意位置前插入
{
	//检查1：
	assert(pphead);
	assert(*pphead);	//检查链表是否为空
	assert(pos);	//pos是链表的一个有效结点（pos不为空）

	//检查2：
	assert((!pos && !(*pphead)) || (pos && *pphead));	//pos 和 *pphead 保持一致（都为空或都不为空）

	/*  检查1，检查2 根据需要任选其一即可  */

	if (*pphead == pos)		//pos为第一个结点时
	{
		LinkPushFront(pphead, x);	//头插
	}
	else
	{
		LNode* prev = *pphead;
		while (prev->next != pos)	//寻找 pos 的位置
		{
			prev = prev->next;
		}
		//插入：
		LNode* newnode = CreateNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

void LinkInsertAfter(LNode* pos, LinkDataType x)	//任意位置后插入
{
	assert(pos);
	LNode* newnode = CreateNode(x);

	newnode->next = pos->next;	//新结点指向原链表指向的位置
	pos->next = newnode;	//原链表指向新结点的位置
}

void LinkPopFront(LNode** pphead)	//头删
{
	assert(pphead);
	assert(*pphead);

	//方法1：
	LNode* tail = (*pphead)->next;	//新建指针指向第二个结点
	free(*pphead);	//释放第一个结点空间
	*pphead = tail;	//头指针指向原链表第二个结点

	//方法2：
	//LNode* tail = *pphead;	//新建指针指向第一个结点
	//*pphead = (*pphead)->next;	//头指针指向第二个结点
	//free(tail);		//释放第一个结点空间
}

void LinkPopBack(LNode** pphead)	//尾删
{
	assert(pphead);
	assert(*pphead);

	//方法1：
	//1.一个结点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//2.多个结点
	else
	{
		LNode* tail = *pphead;
		LNode* prev = NULL;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		/* 跳出循环 prev 停在倒数第二个结点，tail 停在最后一个结点 */

		free(tail);		//删除结点
		tail = NULL;

		prev->next = NULL;
	}

	//方法2:
	// /* 先删除，再判断链表的情况 */
	//LNode* tail = *pphead;
	//LNode* prev = NULL;
	//while (tail->next != NULL)
	//{
	//	prev = tail;
	//	tail = tail->next;
	//}
	//free(tail);
	//tail = NULL;

	//if (prev == NULL)
	//{
	//	*pphead = NULL;
	//}
	//else
	//{
	//	prev->next = NULL;
	//}

	//方法3:
	//（尽量使用以上两种）
	//LNode* tail = *pphead;
	//while (tail->next->next != NULL)
	//{
	//	tail = tail->next;
	//}
	/* tail在倒数第二个结点跳出循环 */
	//free(tail->next);
	//tail->next = NULL;

}

void LinkErase(LNode** pphead, LNode* pos)	//任意位置前删除
{
	assert(pphead);
	assert(*pphead);
	assert(pos);

	if (*pphead == pos)
	{
		LinkPopFront(pphead);	//头删
	}
	else
	{
		LNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;	// pos 前的结点直接指向 pos 后的结点
		free(pos);
		pos = NULL;
	}
}

void LinkEraseAfter(LNode* pos)		//任意位置后删除
{
	assert(pos);
	assert(pos->next);	//检查pos是否为最后一个结点

	//方法1：
	LNode* tail = pos->next->next;
	free(pos->next);
	pos->next = tail;

	//方法2：
	//LNode* tail = pos->next;
	//pos->next = pos->next->next;

	//free(tail);
	//tail = NULL;
}

void LinkPrint(LNode* phead)
{
	LNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->val);
		cur = cur->next;
	}
	printf("NULL\n");
}

void LinkDestory(LNode** pphead)	//销毁
{
	assert(pphead);

	LNode* cur = *pphead;
	while (cur)
	{
		LNode* Next = cur->next;
		free(cur);
		cur = Next;
	}
	*pphead = NULL;
}

int main()
{
	LNode* plist = NULL;
	LinkPushBack(&plist, 1);
	LinkPushBack(&plist, 2);
	LinkPushBack(&plist, 3);
	LinkPushBack(&plist, 4);

	LinkPrint(plist);

	LNode* pos = LinkFind(plist, 1);
	LinkErase(&plist, pos);
	LinkPrint(plist);

	pos = LinkFind(plist, 3);
	LinkErase(&plist, pos);
	LinkPrint(plist);
	return 0;
}

4. 链表和顺序表的选择

  顺序表的优点主要是访问方便，而链表主要是在空间的扩容上和对数据的增删上占优势。

  • 当线性表需要大量对数据的增加和删除，同时对查找要求不高时使用链表；反之使用顺序表。
  • 当我们对元素的个数及变化范围不确定时，尽量使用单链表。
许小燚
关注
  • 27
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构--线性表(单链表C语言实现)
karmacode的博客
05-03 2593
//单链表的练习#include "stdlib.h" #include "stdio.h" void printLinkList(struct node *h);//单链表数据结构 typedef struct node { int data; //数据域 struct node *next; //指针域 }Lnode,*LinkList;//创建链表 带头结点 L
实验1-2 线性表-单链表.doc
04-11
### 实验1-2 线性表-单链表 #### 实验目的 本次实验旨在帮助学生理解和掌握单链表的基本概念与操作方法。通过实际编程实践，学生能够熟悉以下内容： 1. **掌握使用C Free 5.0进行程序调试的方法**：通过这个实验，...
线性表（三）——线性链表（单链表）
大前端程序员的自我修养
11-20 1401
一、介绍了线性表的一种链式存储结构——单链表的C语言实现原理； 二、介绍了单链表（线性链表）的基本操作的算法实现，包括求长度、创建单链表、插入结点、删除结点以及各个算法的时间复杂度。
理论基础 —— 线性表 —— 单链表
Alex_McAvoy的博客
03-09 1162
【实现类】 单链表的基本思想就是用指针表示结点之间的逻辑关系，因此要正确的对指针变量、指针、指针所指结点、结点的值进行区分。 设 p 是一个指针变量，则 p 的值是一个指针，若指针p 指向某个 Node 类型的结点，则该结点用 *p 来表示，并称*p 为结点变量，有时为了叙述方便，常将 " 指针变量 " 称为 " 指针 "，将 " 指针 p 所指的结点 " 称为 " 结点 p "。 在单...
线性单链表的实现和操作
人非生而知之者，孰能无惑？
06-04 691
首先，要明白一个问题，那就是，什么是链表，为什么有链表类？ 其实，说简单一点就是一种最基本的存储方式，可以是顺序存，也可以是链式存，各有优点，所以需要把以前的那些，该用链式存实现一次。 不过，申明一下，此代码是有关单链表的，而且仅仅实现表头的插入和删除操作，先熟悉一下吧 我们先定义一个线性单链表类.linked_List.h #include using namespace std; t
算法与数据结构（c语言）——线性单链表基本操作
掉了根毛的博客
10-14 4183
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef int Element; typedef char(*Status)[10]; #define ERROR "error" #define OK "ok"; // 定义一个线性单链表结构 typedef struct Node{ Element data; ...
数据结构线性表——单链表
2303_78442132的博客
11-06 674
单链表
数据结构与算法之线性表基础——单链表（C与C++双人打） 定义线性表节点的结构.pdf
04-18
"数据结构与算法之线性表基础——单链表（C与C++双人打）定义线性表节点的结构.pdf" 数据结构与算法之线性表基础——单链表（C与C++双人打）定义线性表节点的结构是数据结构与算法的重要基础。单链表是一种链式存储...
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
### 数据结构C++ 线性表——顺序表和单链表基本操作 #### 一、概述 在《数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx》文档中，作者详细介绍了如何在C++中实现顺序表和单链表的基本操作，并...
数据结构---线性表之单链表（C语言）
03-28
单链表是数据结构中的一种基础类型，尤其在C语言编程中经常被使用。它是一种线性的、非连续的数据组织形式，每个元素称为节点，每个节点包含数据和一个指向下一个节点的指针。本篇文章将深入探讨单链表的创建、插入...
数据结构——单链表（C语言版）.zip
11-02
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储...
【数据结构】线性链表(单链表)
weixin_33972649的博客
02-12 119
// // main.cpp // LinkList // // Created by T.P on 2019/1/31. // Copyright © 2019 T.P. All rights reserved. // #include <stdio.h> #include <stdlib.h>//malloc free #define TRUE 1 #def...
Self-study Python Fish-C Note14 P50to51
weixin_46530456的博客
08-07 604
本节主要讲解函数的递归
C语言——查漏补缺
最新发布
2302_81486993的博客
08-09 793
本篇博客主要记录一些C语言的遗漏点，完成查漏补缺的工作，如果读者感兴趣，可以看看下面的内容。都是一些小点，下面进入正文部分。
【C语言】预处理详解（下）
tianxiawushanu的博客
08-07 1119
我们接着[详解预处理（上）](http://t.csdnimg.cn/yZvEl)内容给大家继续讲解预处理的有趣之处。
for(char c:s),std::vector＜int＞ numbers 和std::int numbers[],.size()和.sizeof()区别
hellow_xqs的博客
08-06 428
在C++的标准库容器（如std::vector, std::array, std::string等）中，用于获取容器中元素的数量的方法是.size()。：std::vector是一个动态大小的容器，可以在运行时动态添加或删除元素。例如，sizeof(int)将返回int类型的大小（通常是4个字节），而sizeof(numbers)将返回numbers数组的总大小（以字节为单位）。如果需要动态大小的数组，应该使用动态分配的数组或者std::vector。例如，对于std::vector numbers;
C语言 --- 指针
qq_70030717的博客
08-06 925
指针就是地址 --- 内存单元的编号指针也是一种数据类型 --- 这种数据类型专门用来处理地址这种数据（1）基类型：就是结构体类型，表示该指针所指向的内存空间存放什么类型的数据（2）* ：表示此时定义的是一个 指针类型 的变量（3）指针变量名：符合标识符命名规则。
C语言：qsort详解
zm3rttqs9f的博客
08-05 1308
在上一篇文章我们大致的了解了回调函数的用法和作用，在这一篇让我们来了解一下在回调函数qsort的使用吧。
线性表与单链表实现：按值查找与基本运算
"这篇资料是关于数据结构导论中第2...总结来说，本文档深入介绍了线性表的概念、特性以及两种不同的实现方式——单链表和顺序表，还提供了单链表中按值查找操作的具体代码实现，这对于理解和操作线性表是非常有价值的。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值