线性表（链表的实现）

已于 2023-05-27 18:28:40 修改
阅读量156 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2023-05-27 15:59:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75413778/article/details/130900687
版权
本文介绍了链表的概念，包括非连续非顺序的存储结构以及通过指针链接实现逻辑顺序。文章详细阐述了无哨兵卫头节点链表的创建、初始化、节点创建、尾插、头插、尾删、头删、查找、插入和删除节点等操作，并提供了相应的C语言实现代码。此外，还讨论了使用二级指针的原因以及在操作链表时的注意事项。
摘要由CSDN通过智能技术生成

一.概念

链表是一种物理存储结构上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的

 写链表的方法有很多

  • 有哨兵卫头节点的链表
  • 无哨兵卫头节点的链表（需要传二级指针）

（1）有哨兵卫头节点的链表（head里面可以不赋值，就是随机值）

 （2）无哨兵卫头节点的链表（需要传二级指针）

二.链表的实现（无哨兵卫头节点）  

1.定义一个链表

typedef int SLTDataType;    //定义SLDataType为int型，方便更改数据类型

typedef struct SListNode
{
	SLTDataType data;         //要存的数据
	struct SListNode* next;   //指向下一个结点的地址
}SLTNode;

2.初始化链表

这种链表的初始化很简单（直接在主函数中定义为NULL）

SLTNode* plist = NULL;   //初始化链表为NULL

3.链表节点的创造 

这个函数是一个频繁要调用的函数，在插入数据时都需要调用这个函数去构造一个节点

//创造一个节点
SLTNode* BuyListNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));    //去malloc一个新的节点
	if (newnode == NULL)          //判断malloc是否成功
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;           //赋值
	newnode->next = NULL;        //节点的next定义为NULL
	return newnode;
}

4.尾插 

     为什么要传二级指针？

  • 前面初始化链表 SLTNode* plist = NULL; 要改变plist里的内容，就要传递地址，plist本身就是一个一级指针，一个一级指针的地址就需要二级指针来接收
  • 在运用时 
    	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);   //&plist是一个一级指针的地址，要用二级指针接受
//尾插
void SListPushBack(SLTNode** pphead, SLTDataType x)   //这里要用二级指针，要改变形参里的内容，就要传地址
{
	assert(pphead);                        //断言，第一次进去时 *pphead 是NULL,但 pphead 是*pphead的地址，不为空
	SLTNode* newnode = BuyListNode(x);     //调用函数，去创造一个节点
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else 
	{
		//找到尾节点
		SLTNode* tail = *pphead;
		while (tail->next != NULL)       //找到链表的结尾
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

5.头插

头插也要用二级指针（只要是改动链表中的数据的，都要传递二级指针）

//头插
void SListPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);                      //断言，好习惯

	SLTNode* newnode = BuyListNode(x);  //调用函数，去创造一个节点

	newnode->next = *pphead;
	*pphead = newnode;
}

 6.尾删

//尾删
void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead != NULL);        //链表不为NULL，如果为NULL,则会报错

	if ((*pphead)->next == NULL)    //只有一个节点，直接删空链表并释放空间
	{
		free(*pphead);
		*pphead = NULL;
	}
	else                            //链表有多个节点，遍历寻找尾节点，并且要记录尾节点的前一个结点
	{
		SLTNode* tail = *pphead;
		SLTNode* prev = NULL;      

		while (tail->next != NULL)
		{
			prev = tail;           //记录尾节点的前一个节点，链表没办法找到前面的那个节点
			tail = tail->next;
		}

		free(tail);                //释放尾节点的空间
		tail = NULL;

		prev->next = NULL;
	}
}

7.头删

头删比尾删简单，链表的头节点比尾节点好找

//头删
void SListPopFront(SLTNode** pphead)
{
	assert(pphead);

	SLTNode* front = *pphead;    //定义一个指针指向头节点
	if (*pphead == NULL)
	{
		return;
	}
	else
	{
		*pphead = front->next;   
	}

	free(front);                //释放头节点的空间
	front = NULL;
}

8.查找一个值（返回值是，这个数的地址）

不需要二级指针，查找数据，而不改变数据，所以不需要二级指针

SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)            //遍历，找到链表中的值
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;         //没有，返回NULL
}

9. 在pos后插入一个节点

也可以在pos前面插入一个节点：这个插入比在后面插入麻烦很多，需要判断pos是否是第一个节点（头节点），还需要找到pos的前一个节点进行插入，倒不如在pos后面插入，简单，适合。

//在pos后插入,这个更适合，也简单
void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);                          //pos不能为NULL

	SLTNode* newnode = BuyListNode(x);    //调用函数，创造新节点

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

10.删除pos后的一个节点

//删除pos后一个节点
void SListEraseAfter(SLTNode** pphead, SLTNode* pos)
{
	assert(pos);
	assert(pphead);
	assert(pos->next);      //删除的节点不能为NULL

	SLTNode* next = pos->next;
	pos->next = next->next;
	free(next);             //释放next空间
	next = NULL;            //可有可无，next是形参，置不置空，没有影响，养成好习惯，加上也行
}

11.打印链表

打印链表就传用一级指针就行，只访问链表里的数据，不对链表修改，所以一级指针就行

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

12.释放空间

//释放链表
void SListDestory(SLTNode** pphead)
{
	assert(pphead);

	SLTNode* cur = *pphead;
	while (cur)              //遍历链表，一个节点一个节点的释放
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = NULL;
		cur = next;
	}
	*pphead = NULL;
}

总结

  • 整个链表都是使用二级指针进行传参的，对于指针的应用应当更加熟练（知道一级指针是什么，二级指针是什么）
  • 尽量不要去动链表的第一个节点（*pphead）,要遍历或增删要定义指针去完成任务，最后 *pphead 就是这个链表的第一个节点，就能找到整个链表内容（可以通过定义的tail和cur去遍历链表）

全部代码 

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

typedef int SLTDataType;    //定义SLDataType为int型，方便更改数据类型

typedef struct SListNode
{
	SLTDataType data;         //要存的数据
	struct SListNode* next;   //指向下一个结点的地址
}SLTNode;

//创造一个节点
SLTNode* BuyListNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));    //去malloc一个新的节点
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;                                      //赋值
	newnode->next = NULL;
	return newnode;
}

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

//尾插
void SListPushBack(SLTNode** pphead, SLTDataType x)   //这里要用二级指针，要改变形参里的内容，就要传地址
{
	assert(pphead);
	SLTNode* newnode = BuyListNode(x);                //调用函数，去创造一个节点
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找到尾节点
		SLTNode* tail = *pphead;
		while (tail->next != NULL)               //找到链表的结尾
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

//头插
void SListPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);                      //断言，好习惯

	SLTNode* newnode = BuyListNode(x);  //调用函数，去创造一个节点

	newnode->next = *pphead;
	*pphead = newnode;
}


//尾删
void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead != NULL);

	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}

	else
	{
		SLTNode* tail = *pphead;
		SLTNode* prev = NULL;         //链表没办法找到前面的那个，所以要定义
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}

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

//头删
void SListPopFront(SLTNode** pphead)
{
	assert(pphead);

	SLTNode* front = *pphead;
	if (*pphead == NULL)
	{
		return;
	}
	else
	{
		*pphead = front->next;
	}

	free(front);
	front = NULL;
}

//查找
SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)            //遍历，找到链表中的值
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

//在pos后插入,这个 更适合，也简单
void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	SLTNode* newnode = BuyListNode(x);

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

//删除pos后一个
void SListEraseAfter(SLTNode** pphead, SLTNode* pos)
{
	assert(pos);
	assert(pphead);
	assert(pos->next);

	SLTNode* next = pos->next;
	pos->next = next->next;
	free(next);
	next = NULL;  //可有可无
}

//释放链表
void SListDestory(SLTNode** pphead)
{
	assert(pphead);

	SLTNode* cur = *pphead;

	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = NULL;
		cur = next;
	}

	*pphead = NULL;
}

int main()
{
	SLTNode* plist = NULL;
	printf("头插：");
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 4);
	SListPushFront(&plist, 5);
	SListPrint(plist);

	printf("头删：");
	SListPopFront(&plist);
	SListPrint(plist);

	printf("尾插：");
	SListPushBack(&plist, 10);
	SListPushBack(&plist, 20);
	SListPrint(plist);

	printf("尾删：");
	SListPopBack(&plist);
	SListPrint(plist);

	printf("在2后面插入200：");
	SLTNode* pos = SListFind(plist, 2);
	if (pos)                  //pos不为NULl
	{
		SListInsertAfter(pos, 200);
	}
	SListPrint(plist);

	printf("删除2后的200：");
	if (pos)
	{
		SListEraseAfter(&plist, pos);
	}
	SListPrint(plist);

	SListDestory(&plist);        //释放链表
 
	return 0;
}

感谢大家的观看，希望你能从这篇文章中学到一些东西（如有错误，提醒我，我会及时修改）

谢谢大家！！！

努力学英语lsd
关注
专栏目录
线性表与链表
weixin_52744725的博客
08-08 1480
1、线性结构在数据元素的非空有限集中：存在唯一的一个被称做“第一个”的数据元素存在唯一的一个被称做“最后一个”的数据元素除第一个之外，集合中的每个数据元素均只有一个前驱除最后一个之外，集合中的每个数据元素均只有一个后继2、线性表线性表是n个数据元素的有限序列，同一线性表中的元素必定具有相同特性，相阾的数据元素之间存在着序偶关系。线性表中元素的个数n(n>=0)定义为线性表的长度，0==n时称为空表，在非空表中每个数据元素都有一个确定的位置(下标)。...
数据结构之线性表（链表实现）
最新发布
SurpriseKuang的博客
03-22 430
首先，我们需要定义链表中的节点结构。每个节点包含两个部分：存储的数据（类型为T）和指向下一个节点的指针。// 链表节点public:// 存储的数据T data;// 指向下一个节点public:// 默认构造函数// 拷贝构造函数// 带参数构造函数使用链表实现的线性表是一种常见的数据结构，它通过链式存储方式来存储元素，每个元素都包含一个指向下一个元素的指针。相比于使用数组实现的线性表，链表在插入和删除操作上更加灵活，因为它们只需要更改相邻元素的指针即可，而不需要移动元素。
线性表的建立
wzy1414的博客
10-18 645
线性表的建立 #include <iostream> using namespace std; const int MaxSize=100; template<class DateType> class SepList { public: SepList(){length=0;}; SepList(DateType a[],int n); ~SepList(){}; int Length(){return length;} DateType
简单的线性单向链表
笔记
03-23 1303
链表，其实很简单
线性表的建立及操作详解 菜鸟都能看懂的教程
qq_43735092的博客
08-08 1617
线性表按照存储方式可以分为顺序存储和链式存储. 我们先来实现顺序表,借助一维数组来实现 定义顺序表 #include<stdio.h> #include<stdlib.h> #include<string.h> #include<assert.h> #define MAXSIZE 100 typedef struct List { int dat...
线性表的整表创建7
weixin_69149498的博客
10-24 47
那么此时的 r 就成了倒数第二的结点，新加入的 p 才是尾结点，r是指向尾结点的指针，r->next=p时你往 r 后面放了一个结点，r 是用来存放 尾结点的，因此，把新的尾巴赋值给 r，就有了 r=p，获取最新插入的尾结点。从一个空表开始，生成新结点，读取数据存放到新结点的数据域中，然后将新结点插当前链表的表头上，直到结束为止。创建单链表的过程界是一个动态生成链表的过程，从“空表”的初始状态起，依次建立各元素结点。一让L的头结点的指针指向NULL， 即建立一个带头结点的单链表;一初始化一空链表L;
线性表的基本操作（初始化、创建、增、删、查）
柯西从不收敛
02-02 7909
线性表的基本操作
C++语言实现线性表之链表实例
12-31
本文实例讲述了C++语言实现线性表之链表实现方法。分享给大家供大家参考。具体分析如下： 插入、删除结点的代码有点多，但这样提高了代码的可读性，且不增加时间复杂度，不会影响程序性能 #include using ...
数据结构 基本代码——线性表，链表实现 C语言
LloveN0128的博客
10-30 490
单链表功能的实现。
线性表的创建和基本操作
麻辣清汤的博客
09-14 9600
&&逻辑与 ||逻辑或 线性表是最基本、最简单、也是最常用的一种数据结构。 线性表结构中，数据元素之间通过一对一首位相接的方式连接起来。 具体实现时，线性表可 以采用不同的存储策略。 该方案将线性表存储在一片连续的空间里，通过data,len , 和max三个属性元素。 组织成为了一个结构： data: 给出线性存储空间的起始地址； max : 指明线性表存储空间最 len : 当前线性表里的数据元素个数。 为了讨论简化，我们假设每个数据元素是一个整数： .
C语言创建线性链表
u010513327的博客
07-08 4894
#include&amp;lt;stdio.h&amp;gt; //构造结点 typedef struct lnode{ int data; struct lnode *next; } lnode; //创建链表 lnode* creat() { lnode*p,*s,*head; head=new lnode; head-&amp;gt;next=NULL; p=hea...
线性链表的创建 C语言
qishubiao的博客
07-21 5550
我认为线性链表的创建主要需要以下几种： 1.需要一个结构体：有两部分组成，一部分用来表示节点的各个属性，另一部分是指针，用来指向下一个节点，只有这样才能构成线性； 2.定义一个头指针（head）：用来保存链表的首地址，有了首地址就可以找到其他节点； 3.分别定义一个动态指针 p 和 q ：主要用在链表创建 时期，p用来指向新创建的节点，q 用来指向上一个节点，通过q和p的连接来使链表连接；
创建单线性链表的不同表示方法和操作
wqthaha的专栏
08-04 2173
创建单线性链表，常见的有头插法、尾插法创建线性链表，常见的操作有：创建链表、查找、删除、增加元素、求逆链等操作。 这里首先才有头插法创建链表： //头指针唯一确定一个单链表 #define MaxSize 15 typedef int elem_type ; typedef struct linklist { elem_type data; str
线性链表的创建，显示，删除(c语言)2019-3.13
NPC3023653226的博客
03-13 566
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; struct student { char on[10]; int math; struct student *next; }; struct student *head; void create() { struct student *front,*back; int node_nu...
线性表的建立和使用
xiaorur的博客
09-05 9791
#include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;cstdio&gt; #include &lt;cmath&gt; const int Maxsize = 50; using namespace std; /* ADT list {     数据对象：         D = { ai | 1 &lt;= i &l...
线性表的建立以及基本操作
热门推荐
ciganxian的专栏
05-29 1万+
#include #include #define MaxSize 50 typedef char ElemType; typedef struct { ElemType elem[MaxSize]; //存放顺序表中的元素 int length; //存放顺序表的长度 } SqList; void InitList(
线性表的创建和操作
weixin_34092455的博客
06-17 933
//对顺序表的操作 #include<stdio.h> #include <stdlib.h> #include<malloc.h> #define MAXSIZE 1000 typedef char ElemType; typedef struct { ElemType data[MAXSIZE]; int le...
线性表的创建与使用
chineseITIce的博客
09-28 4026
我学的是数据结构这本书，开篇就是线性表，刚接触的时候真的事一窍不通，后来看了不少的博客才慢慢明白，下面是我的线性表代码，把main函数去掉就可以当头文件用，不会的朋友可以参考一下。 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define TRUE 1 #define FALSE 0 #define OK 1 #define OVERFL...
线性表的创建(C)
SHAUNG_YUE的博客
05-22 6263
main.c #define _CRT_SECURE_NO_WARNINGS #include "header.h" #include "SqList.h" void main(void) {     SqList LA;  //建立线性表      InitList_Sq(&amp;LA);//初始化线性表 。。。。。。。。。。。。。。。。。//添加自己的程序代码        whil...
线性表详解与双链表实现
"这篇文章除了简单介绍线性表的概念和分类，还重点讨论了数组、单向链表和双向链表，并提供了双向链表的C、C++和Java三种语言的实现示例。线性表是数据结构的基础，包括数组、单向链表和双向链表等组成部分。数组...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值