链表的实现

于 2023-09-16 18:51:42 发布
阅读量62 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Bit_qnw/article/details/132920549
版权

1.1链表的概念和结构

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。链式结构在逻辑上的存储的连续的，而在物理上不一定是连续的，不同于顺序表，链表没有所谓的容量大小，也不需要扩容的操作，链表的使用是存储一个数据就开辟一块内存空间，链表间通过指针来寻找访问。

1.2链表的种类

链表的种类比较复杂，详细分类的可以分为8种结构，通过链表：单向或者双向、带哨兵卫或不带、循环或者不环，其中哨兵卫为一个指向链表头结点的一个不存储数据的结点，而这些结构总共可以组成8种之多结构的链表，但实际上我们使用最多的仅仅只有两种：不带哨兵卫的单向非循环链表 和 带哨兵卫的双向循环链表，我们只要学会了这两种结构的链表，其他结构的链表自然就没有太大问题。下面要将的单、双向链表也都是这两种最常见的。

2.1单链表的实现（不带哨兵卫的单向非循环链表）

单链表的结构是由一个包含存储数据和指针两部分的结构体类型组成的，其中存储数据的我们通常称之为数据域，存放指针的称之为指针域，其中数据域中所存储的数据类型可以是任意的，这个由具体需求决定，而指针域中存放的指针是我们所自定义的结构体指针，它指向的是下个链表，存放下个链表的地址。

2.11定义链表的基本结构

typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

 2.12实现链表的增删查改

生成链表结点：

通过传递链表要存储的数据，动态开辟一块内存用于存储数据。

SLTNode* BuySListNode(SLTDataType x)
{
	SLTNode* NewNode = (SLTNode*)malloc(sizeof(SLTNode));
	if (NewNode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	NewNode->data = x;
	NewNode->next = NULL;
}

头插法/尾插法储存数据：

由于头插法是需要更改单链表的头结点的地址，所以需要使用二级指针，如果使用一级指针来传递参数，接收头结点的存储地址，通过形参的改变则无法对实参产生影响。而尾插的数据为第一个元素时，此时要更改头结点，任然需要传参二级指针。而尾插中还需要注意单链表要找到尾结点，只能通过头结点依次往下查找，这里要注意找到尾结点时的终止条件。

void SLTPushFront(SLTNode** phead, SLTDataType x)//头插
{
	assert(phead);
	SLTNode* newNode = BuySListNode(x);
	if (*phead == NULL)//空表
	{
		*phead = newNode;
	}
	else
	{
		newNode->next = *phead;
		*phead = NewNode;
	}
}

void SLTPushBack(SLTNode** phead, SLTDataType x)//尾插
{
	assert(phead);
	SLTNode* newnode = BuySListNode(x);
	SLTNode* tail = *phead;
	if (*phead == NULL)//空链表
	{
		*phead = newnode;
	}
	else
	{
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

头删除/尾删除：

利用assert断言能很好的知道知道程序产生的错误从而终止程序。头删除中，存储头结点的地址phead，以及存放头结点地址的地址这两者都不能为空。

void SLTPopFront(SLTNode** phead)//头删
{
	assert(*phead && phead);
	SLTNode* newhead = (*phead)->next;
	free(*phead);
	*phead = newhead;
}

void SLTPopBack(SLTNode** phead)//尾删
{
	assert(*phead && phead);
	SLTNode* tail = *phead;
	if ((*phead)->next == NULL)//一个结点的链表
	{
		free(*phead);
		*phead = NULL;
	}
	else
	{
		while (tail->next->next)
		{
			tail = tail->next;
		}
		free(tail->next);//释放最后一个结点
		tail->next = NULL;
	}
}

查找链表元素：

查找链表元素本质是通过遍历列表依次查找是否有对应元素，找到后返回结点的地址，找不到则返回NULL。

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	if (phead == NULL)
	{
		return NULL;
	}
	else
	{
		SLTNode* Pos = phead;
		while (Pos)
		{
			if (Pos->data == x)
				return Pos;
			else
				Pos = Pos->next;
		}
		return NULL;
	}
}

定点插入/删除：

同过传递要插入元素的位置，将新的元素插入到当前位置的前面或者删除当前结点。

//定点插入
void SLTInsert(SLTNode** phead, SLTNode* pos, SLTDataType x)
{
	assert(*phead != pos);
	assert(pos);
	SLTNode* tail = *phead;
	SLTNode* newnode = BuySListNode(x);
	if (tail==pos)//插入到第一个位置前
	{
		newnode->next = tail;
		*phead = newnode;
	}
	else
	{
		while (tail->next != pos)
		{
			tail = tail->next;
		}
		newnode->next = tail->next;
		tail->next = newnode;
	}
}
//定点删除
void SLTErase(SLTNode** phead, SLTNode* pos)
{
	assert(pos);
	SLTNode* tail = *phead;
	if ((*phead)->next == pos)//删除第一个
	{
		*phead = tail->next;
		free(tail);
		tail->next = NULL;
	}
	else
	{
		while (tail->next->next != pos)
		{
			tail = tail -> next;
		}
		SLTNode* temp = tail->next;
		tail->next = tail->next->next;
		free(temp);
		temp->next = NULL;
	}
}

删除链表：

在使用完链表后我们应当需要对结点依次删除，防止造成内存泄露。

void SLTDestroy(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur)
	{
		SLTNode* Next = cur->next;//保存下一结点
		free(cur);
		cur = Next;
	}
}

2.2双链表的实现（带哨兵卫的双向循环链表）

与单链表相比，双链表中多存放了一个指向上一结点的指针，避免了单链表只能从头往下找某一元素的缺点，双链表的结点可以同时找到上一结点和下一结点，与单链表相比，更加具有实用性。此外在结构上，循环链表的尾指针的所指向的后继结点为头结点，而头结点所指向的前驱结点为尾结点。

2.11定义双链表的基本结构

typedef int LTDataType;
typedef struct LTNode
{
	struct LTNode* prev;//前驱
	struct LTNode* next;//后继
	LTDataType data;
}LTNode;

  2.21实现双向链表的增删查改

初始化哨兵卫结点：

带有哨兵卫的链表在插入元素时首先需要对哨兵卫结点进行初始化

LTNode* LTInit()
{
	LTNode* phead = (LTNode*)malloc(sizeof(LTNode));
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

生成链表结点：

通过传递链表要存储的数据，动态开辟一块内存用于存储数据，与单链表一致。

LTNode* BuyLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

头插法/尾插法储存数据：

与单链表相比，双向链表的头插、尾插更为方便，不需要考虑对头结点做出的改变，只需要更改结点中前驱和后继所指向的结点，所以在传递参数上也只需要传递一级指针。

void LTPushFront(LTNode* head, LTDataType x)//头插
{
	assert(head);
	LTNode* newnode = BuyLTNode(x);
	LTNode* first = head->next;
	newnode->next = first;
	first->prev = newnode;
	newnode->prev = head;
	head->next = newnode;
}

void LTPushBack(LTNode* head, LTDataType x)//尾插
{
	assert(head);
	LTNode* newnode = BuyLTNode(x);
	LTNode* tail = head->prev;
	tail->next = newnode;
	newnode->prev = tail;
	head->prev = newnode;
	newnode->next = head;
}

头删除/尾删除：

头删尾删时要注意哨兵卫的后继结点指向向的不是自己，而是其他结点，这是判断链表是否为空的依据。

void LTPopFront(LTNode* head)//头删
{
	assert(head);
    assert(head->next!=head);
	LTNode* first = head->next;
	LTNode* second = first->next;
	head->next = second;
	second->prev = head;
	free(first);
	first = NULL;
}

void LTPopBack(LTNode* head)//尾删
{
	assert(head);
    assert(head->next!=head);
	LTNode* tail = head->prev;
	head->prev = tail->prev;
	tail->prev->next = head;
	free(tail);
	tail==NULL;
}

定点插入/删除：

定点的插入删除可以复用于头插头删、尾插尾删中，为预防前驱后继指针指向错误，我们可以多定义几个指针保存要删除位置的前驱后继结点。

void LTInsert(LTNode* pos, LTDataType x)//定点插入
{
	assert(pos);
	LTNode* newnode = BuyLTNode(x);
	LTNode* posPrev = pos->prev;
	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
}

void LTErase(LTNode* pos)//定点删除
{
	assert(pos);
	LTNode* posPrev = pos->prev;
	LTNode* posNext = pos->next;
	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
	pos = NULL;
}

 查找链表元素：

与单链表一样，同样是遍历链表，不同的是，作为循环链表，遍历的终止条件有所不同，循环链表结束遍历的条件为指针指向哨兵卫结点，而非循环链表结束遍历的条件为指针指向空。

LTNode* LTFind(LTNode* head, LTDataType x)
{
	LTNode* cur = head->next;
	while (cur != head)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

删除链表：

同样的，在使用完链表后我们也应当需要对结点依次删除，防止造成内存泄露。通过遍历链表依次删除每个结点，最后的哨兵卫结点也要删除

void LTDestory(LTNode* head)
{
	assert(head);
	LTNode* cur = head->next;
	while (cur!=head)
	{
		LTNode* curNext = cur->next;
		free(cur);
		cur = curNext;
	}
	free(head);
}

结语：

本期关于链表的相关知识到这就介绍完了，如果感觉对你有帮助的话还请点个赞支持一下！有不对或者需要改正的地方还请指正，感谢各位的观看。

爱摸鱼的阿Q
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构实验一 用链表实现大整数加减法
m0_61506053的博客
03-31 4081
题目： 用链表实现大整数加减法操作： 32位机器直接操作的数据最大为32个bit，若超过32bit，则需要单独设计算法。在这里，可以用链表每个结点存储大整数的每一位的十进制数字，则可以进行大整数的算数运算，该实验仅实现加减法操作。 要求: 随机产生2个1~50位的数字串，并存储到2个链表中。 进行加法或减法操作，结果存储到新的链表中。 打印运算结果。 目录 BigInteger.h BigInteger.cpp function.h function.cpp main.cpp ..
链表实现单词本管理.docx
12-23
C语言链表实现单词本管理 本文档主要介绍了使用C语言实现单词本管理系统的设计和实现过程。该系统使用链表结构来存储单词及其对应的中文解释，并提供了插入、删除、查找和输出单词的功能。 1. 链表结构的实现 在...
C语言的链表实现
weixin_73728044的博客
10-16 1628
C语言各种链表学习记录
C语言链表实现栈
wu1217的博客
09-07 4148
/** 链表实现带头结点的栈，入栈用头插法 环境codeblocks */ #include <stdio.h> #include <stdlib.h> #include <stdbool.h> typedef int ElemType; typedef struct Node { ElemType data; struct...
C#中 简单链表实现
weixin_43542114的博客
07-04 1999
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)
多项式加法运算（链表实现）
热门推荐
2021dragon的博客
04-24 1万+
文章目录创建结点类型打印多项式尾插选择排序多项式相加代码总览 + 结果展示 创建结点类型 我们用链表存储一个多项式，那么该链表的每一个结点就代表多项式的某一项。所以我们的每一个结点必须包含三个信息：多项式的系数、多项式的指数以及指向下一个结点的指针。 typedef int SLTDataType;//指数、系数类型 typedef struct SListNode { SLTDataType coef;//系数 SLTDataType expon;//指数 struct SListNode* ne
栈——链表实现
m0_53223094的博客
11-21 2621
链栈的一些基本操作，附带源码
【C语言】链表实现队列
weixin_43757283的博客
07-14 4880
前言 利用动态数组实现了循环队列，这是静态的队列，缺点是需要预设大小，当队列满时，无法再插入新的数据，只有等队头的数据被取走以后才能往队列放入新的数据。 除了动态数组分配实现的队列之外，还可以使用链表实现队列，这种方式动态创建节点需要的内存，当有新的数据节点要加入时，才去申请内存空间，不需要预设大小，整个队列需要的内存空间不需要连续，并且插入删除更容易实现。但是同时也带来存取速度慢的缺点，操作也比数组的方式更加复杂。 其实用链表实现队列的方式十分简单，只需要在单链表的基础上，增加一个尾指针即可。因为队列的.
Java用链表实现队列
daBai_Zzz的博客
01-08 1849
/** * 链表实现队列 */ public class LinkedQueue { class Node{ int val; Node next; public Node(int val){this.val=val;} public Node(int val,Node next){this.val=val;this.next=next;} } // 队头指针 Node front; // 队尾指针
学生管理系统——用链表实现
Longlong的博客
03-11 4814
前言 该程序是大一上学期的课设，在上学期的基础上对此程序进行了细节上的优化，以及将程序分成多个文件，第一次对多文件开发有了了解(再也不要将几千行代码放在一个文件内了) 一、 软件功能描述 假设学生成绩信息描述如下： 学号，姓名，身份证号，性别，民族，家庭住址，课程成绩，年龄 要求：程序能够实现，（１）增加、删除、修改学生的基本信息；（２）查询功能：查询学生人数；按性别查询学生人数；按民族查询学生人数；统计学生的平均分数；给学生排榜；按课程统计学生分数；查询获得某课程的最高分的学生信息；(3)、存储学生信
使用链表实现栈
Maggieq8324的博客
07-10 1899
前言 使用自定义链表实现栈，自定义链表的实现：自定义链表 具体实现 栈接口 public interface Stack<T> { /** * 添加元素 * @param t */ void push (T t); /** * 元素出栈 * @return */ T pop(); /** * 查看栈顶元素 * @return */ T peek()
链表实现集合运算 链表实现集合交并差运算
12-27
链表实现集合运算 链表实现集合交并差运算
C语言学生考试系统（链表实现）
05-25
《C语言学生考试系统——链表实现》 在信息技术领域，C语言作为一种基础且强大的编程语言，被广泛用于系统编程、软件开发以及教学实训。本项目“C语言学生考试系统”便是利用C语言来实现的一个简易考试管理工具，其...
python双向链表实现实例代码
12-25
python双向链表实现代码： 复制代码 代码如下:#!/usr/bin/python# -*- coding: utf-8 -*- class Node(object): def __init__(self,val,p=0): self.data = val self.next = p self.prev = p class LinkList...
用数据结构-链表实现通讯录管理系统
04-12
本项目以"用数据结构-链表实现通讯录管理系统"为主题，通过C语言实现了这一功能，旨在帮助用户管理他们的联系人信息。下面我们将深入探讨这个系统所涉及的主要知识点。 首先，我们来了解**链表**这一数据结构。链表...
数据结构实验报告-利用链表实现简易学生信息管理系统(C语言)
04-07
数据结构实验报告-利用链表实现简易学生信息管理系统，内容包含实验目的，实验环境，实验源代码，实验运行截图，实验小结等。 说明：如有bug，还请反馈！
图书管理系统（C语言链表实现）含实验报告
05-25
大学期间用C语言链表实现的一个图书管理系统，主要功能有 a. 设备申请。由专业人员填写“申请表”送交领导批准购买。 b. 设备入库。新设备购入后要立即进行设备登记（包括类别、设备名、型号、规格、单价、数量、...
linkedList:javascript中的链表实现
07-03
链表javascript中的链表实现请通过 mocha 测试文档npm 测试链表堆栈： ✓ allows adding elements through array inside constructor ✓ allows adding elements ✓ allows taking out elements at top ✓ has an ...
C语言链表实现的贪吃蛇小游戏 .zip
最新发布
03-16
C语言链表实现的贪吃蛇小游戏。.zipC语言链表实现的贪吃蛇小游戏。.zipC语言链表实现的贪吃蛇小游戏。.zipC语言链表实现的贪吃蛇小游戏。.zipC语言链表实现的贪吃蛇小游戏。.zipC语言链表实现的贪吃蛇小游戏。.zipC...
python链表实现
07-27
一个常见的链表实现是单链表。单链表由节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。在Python中，可以使用类来定义单链表。例如，可以定义一个SingleLinkedList类，其中包含一个头节点和链表的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值