数据结构 链表

最新推荐文章于 2024-09-25 09:12:27 发布
最新推荐文章于 2024-09-25 09:12:27 发布
阅读量249 收藏 2
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq2410030025/article/details/115184278
版权
本文详细介绍了单链表的概念、优缺点以及两种实现方式（带头节点与不带头节点），并通过C语言实现了一系列操作，包括初始化、插入、删除、查找等。此外，还讨论了带头节点与不带头节点的区别，以及在实际应用中的选择。
摘要由CSDN通过智能技术生成

本教程来自 本人博客 越行勤‘s Blog ，欢迎大家访问
域名 https://yingwiki.top/

文章目录

线性存储的链式存储

链式存储又叫链表，分可以分为单链表 双链表，循环链表，静态链表。

单链表

何为单链表：使用链式存储的结构实现线性存储（逻辑结构）。顺序表在物理上是连续存放的，单链表无需这样，原因就是 每个简单除了存放数据元素之外，还存储了指向下一个节点的指针

优点： 不要求大片连续存储空间，改变容量方便。

缺点： 不可以随机读取，要花费一定的空间存储指针。

单链表有两种实现方式，带头节点和不带头节点的。

实现单链表
typedef struct
{
    int data;           //数据域
    struct LNode *next; //指针域
} LNode;

增加一个新的结点：在内存中申请空间，并用指针p指向这个节点

LNode *P = (LNode *)malloc(sizeof(struct LNode));

typedef 的使用

基本语法: typedef <数据类型> <别名> 。

使用typedef 我们可以简化很多。

typedef struct LNode
{
    int data;           //数据域
    struct LNode *next; //指针域
} LNode, *LinkList;

其实 只要把 struct LNode{} 看出一个整体就好理解了，结合 typedef <数据类型> <别名> ，是不用一目了然。

等价于 typedef struct LNode LNode; typedef struct LNode* linkList;

我们就可 声明 LinkList 声明头指针， LNode 声明结构体。

初始化单链表 和判断是否为空
不带头节点

不带头节点其实非常好理解

bool InitList(LinkList &L)//无比传入引用，要不然操作的就是局部变量
{
    L = NULL;
    return true;
}
//判断是否为空
bool Empty(LinkList L)
{
    return (L==NULL);
}

使用话 用 LinkList 开辟头指针就好了。

void test()
{
    LinkList L; //声明指向单链表的指针
    InitList(L);
}
带头节点

其实带头节点有一点点不好理解。

bool InitList(LinkList &L)
{
    //开辟头节点，并且是头指针指向头节点
    L = (LNode *)malloc(sizeof(LNode));
    //开辟空间失败retrun flase
    if (L == NULL)
    {
        return false;
    }
    L->next = NULL;
    return true;
}
bool Empty(LinkList L)
{
    return (L->next == NULL);
}

void test()
{
    LinkList L; //声明指向单链表的指针
    InitList(L);
}

头指针

首先加了头节点是为了实现某些操作方便，头节点不存储数据。

image-20210210153422747

带头节点和不带头节点有何区别

不带头节点，写代码比较麻烦，因为第一个数据点和后续数据不一样，所以需要不同的代码逻辑，并且对空表和非空表的处理也需要不同的逻辑。

结论：我们使用带头节点的，不适用不带头节点的。

单链表插入
带头节点

插入操作，在第i个位置上出入指定元素e。头节点可以作为第零个节点。

其实我们要做的事情就是

  1. 判断 i是否合法
  2. 在 i处 插入节点，就获取它前面一个节点 i-1
  3. 判断找到的i-1个节点是否存在
  4. 开辟新的节点并 连接到链表中
bool ListInsert(LinkList &L, int i, int e)
{
    if (i < 1)//i表示为序 不允许小于1
        return false;
    LNode *p = L; //p 指向当前扫描到的节点
    int j = 0;    //当前p指向的是那个节点
    //循环时为了获取 i-1节点
    while (p != NULL && j < i - 1) //扫描到 第i-1节点 当p == NULL说明到了表尾
    {
        p = p->next;
        j++;
    }
    // 如果在大于表尾的地方插入数据，那节点存在 ，那么插入失败
    if (p == NULL)
        return false;
    //开始新的节点，并存储数据 e
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    // 将s指向下一个节点，并且p（第i-1）节点的next指向 s
    s->next = p->next;
    p->next = s;
    return true;
}
不带头节点

其实就多了一个处理插入第一个位置的特殊情况 ，由于没有头节点 ，那么就要改 头地址LinkList的指向，

if(i==1)
{
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    // 将s指向原来的下一个节点，并且头指针指向 s
    s->next = L->next;
    L->next = s;
    return true;
}

所以不带头节点就有点麻烦,以后的情况就说明有头节点。

任意节点后插操作
bool InsertNextNode(LNode* p,int e)
{
    //传入节点不存在 失败
    if(p==NULL)
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if(s==NULL)//开辟空间失败
        return false;
    s->data=e;
    s->next = p->next;
    p->next = s;
    return true;
}
前插操作

由于我们单链表，知道某一个节点就可以知道它后面的所有节点，但是在他之前的呢，就单单这个条件的话无法知道的。

所以还要传入参数 头指针 LinkList，通过它来找到它前面节点，但是这样的算法时间复杂度无疑是 O(n);没有更简单的方法呢？

偷天换日

虽然节点是死的，但是数据是活的。找不到前驱节点就创造节点

  1. 我们继续指向后插操作
  2. 插入的节点覆盖插入节点的数据
  3. 原来的节点覆盖新数据。
bool InsertPriorNode(LNode *p, int e)
{
    //传入节点不存在 失败
    if (p == NULL)
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if (s == NULL) //开辟空间失败
        return false;
    // 继续查到后面
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data = e;
    return true;
}

很妙。

删除节点

删除操作,我们就需要进行如下几步

  1. 找到删除节点的前驱节点
  2. 让前驱节点的next指针跳过删除节点指向下一个节点。
  3. 释放删除节点的空间
按位序删除
// 按序位删除
bool ListDelete(LinkList &L, int i, int &e)
{
    if (i < 1)
        return false;
    LNode *p;
    int j = 0;
    p = L;
    // 扫描它前面一个节点
    while (p != NULL && j < i - 1)
    {
        p = p->next;
        j++;
    }
    if (p == NULL)
        return false;
    if (p->next == NULL) //发现i-1节点是 尾巴 就失败
        return false;
    //删除节点i
    LNode *q = p->next; //q是被删除节点
    e = q->data;//e是返回删除节点的值
    p->next = q->next;
    free(q);
    return true;
}
删除指定节点

和前插操作一样，我们这样进行

  1. 让它的后驱节点和自己交换数据域data 和指针域
  2. 释放后驱节点
bool DeleteNode(LNode *p)
{
    if (p == NULL)
        return false;
    LNode *q = p->next;
    p->data = q->data;
    p->next = q->next;
    free(q);
    return true;
}

但是这样是有bug的时候，假如删除最后一个节点就无法后驱节点（此时后驱节点是NULL）和自己交换数据域data 和指针域。

所以当时最后一个节点的时候，就要扫描到它的前驱节点

查找
按位查找

其实这个就简单多了，一个循环就可以解决

LNode *GetElem(LinkList L, int i)
{
    if (i < 0)
        return NULL;
    LNode *p = L;
    int j = 0;
    while (p != NULL && j < i)
    {
        p = p->next;
        j++;
    }
    return p;
}
按元素查找
LNode *LocaleElem(LinkList L, int e)
{
    LNode *p = L->next;
    while (p != NULL && p->data != e)
        p = p->next;
    return p;
}
求表的长度
int Length(LinkList L)
{
    int len = 0;
    LNode *p = L;
    while (p->next != NULL)
    {
        p = p->next;
        len++;
    }
    return len;
}
建立单链表
尾插法

所谓尾插法就是在链表的后面的节点插入数据。

LinkList List_TailInsert(LinkList &L)
{
    int x;
    L = (LinkList)malloc(sizeof(LNode));
    LNode *s, *r = L; //s表示开创的节点,r 为尾指针
    scanf("%d", &x);
    while (x != 9999) //9999 作为退出标志
    {
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s; //新开辟的节点接入s 链表
        r = s;       //r有和新开创的节点重合
        scanf("%d", &x);
    }
    r->next = NULL;
    return L;
}
头插法

所谓头插法就是 一致在头节点插入数据

我们使用头插法，插入数据的话，插入数据是输入数据的逆序。

输入的数据是 1 2 3 那么存储数据恰好是 3 2 1, 这就叫逆置

LinkList List_HeadInsert(LinkList &L)
{
    int x;
    L = (LinkList)malloc(sizeof(LNode));
    LNode *s;
    L->next = NULL;
    scanf("%x", &x);
    while (x != 9999)
    {
        s = (LNode *)malloc(sizeof(LNode));
        //头插入操作
        s->data = x;
        s->next = L->next;
        L->next = s;
        scanf("%x", &x);
    }
    return L;
}

我们就可以更具这个写出一个逆置的函数, 其实就把后一个元素前插到前一个元素

void Inverse(LinkList &L)
{
    LNode *p, *q;
    p = L->next;
    L->next = NULL; //初始化空表
    while (p != NULL)
    {
        q = p; //p,q同时指向next结点
        p = p->next;//p为下一个指针。

        //头插操作
        q->next = L->next; //第一次执行时L->next为NULL
        L->next = q;
    }
}
总结

其实获取单链表这么多运算离不开，前插，后插操作，扫描节点的这几个操作。

分享一下 个人写的c语言实现(未完善)的单链表

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

/**********************
线性表的实现:单链表
by 越行勤 2021年 3月 9日
***********************/

typedef struct LNode 
{
	int data;						//数据域
	struct LNode* next;				//指针域
}LNode,*LinkList;

/*
LNode 特指结点
LinkList 等于 LNode * 特指  单链表这个数据结构

头节点相当于 0号结点 不存储数据也就是 L所指向的节点
本LinkList是 带头节点的
*/
bool Init_LinkList(LinkList& L);					//初始化单链表
bool Empty_LinkList(LinkList L);					//判断单链表是否为空
bool GetElem_LinkList(LinkList L,int i,int &e);		//获取第i个元素
bool DelteList_LinkList(LinkList &L, int i, int& e); //按位删除结点
bool InsertLisk_LinkList(LinkList& L, int i, int e); //按位插入元素
void Print_LinkList(LinkList L);					//打印出每一个链表的数据



bool GetNode_LinkList(LinkList L, int i, LNode*& p);	//获取第i个结点Node
bool InsertNext_LinkList(LNode* L, int e);			//在任意结点之后插元素---后插
bool InsertPrior_LinkList(LNode* L, int e);			//再任意结点之前插元素---前插
bool DeleteNode_LinkList(LNode* L, int &e);         //删除指定结点



void test()
{
	LinkList L;
	int e;
	LNode* p;

	Init_LinkList(L);
	printf("初始化完成^_^\n");

	for (int i = 1; i <= 10; i++)
	{
		InsertNext_LinkList(L, i);
	}
	printf("后插数据完成 ^_^\n");

	InsertLisk_LinkList(L, 5,44);
	printf("往5号插入元素完成\n");

	Print_LinkList(L);

	DelteList_LinkList(L, 5, e);
	printf("删除第5个节点成功\n");
	Print_LinkList(L);
	
	getchar();
}
int main()
{
	test();
	return 0;
}

bool Init_LinkList(LinkList& L)
{
	//头指针L 指向 头节点
	L = (LNode*)malloc(sizeof(LNode));
	if (L == NULL)
		return false;
	//头结点的后驱结点为 NULl
	L->next = NULL;
	return true;
}

bool Empty_LinkList(LinkList L)
{
	//直接判断头节点是否指向 NULl
	if (L->next == NULL)
		return true;
	return false;
}

bool GetNode_LinkList(LinkList L, int i, LNode* & p)
{
	LNode* q = L->next; 
	int j = 1;//负责计数
	while (q != NULL && j < i)
	{
		q = q->next; 
		j++;
	}
	if (!q || j > i)// 说明i结点不存在
		return false;
	p = q;
	return true;
}
bool GetElem_LinkList(LinkList L, int i, int& e)
{
	LNode* p;
	if (!GetNode_LinkList(L, i, p))
		return false;
	e= p->data;
	return true;
}
bool InsertNext_LinkList(LNode* L, int e)
{
	if (L == NULL)
		return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	// 分配空间失败
	if (s == NULL)
		return false;

	s->data = e;
	//插入结点s
	s->next = L->next;
	L->next = s;
	return true;
}
/*
前插结点：
虽然我们没有办法直接找到前一个结点 但是可以先进行后插操作
然后 再交换  插入结点和 插入点结点的数据
就相当于 向前插入结点了一样
*/
bool InsertPrior_LinkList(LNode* L, int e)
{
	if (!InsertNext_LinkList(L, e))
		return false;
	// 交换  插入结点和 插入点结点
	int t = L->data;
	L->data = L->next->data;
	L->next->data = t;
	return true;
}

/*
删除指定结点 其实向前插入节点的思想一致 、
和将后继节点的数据存储到当前节点 然后删除原来的后继节点
其实就相当于删除自己了

但是如果删除表尾元素 遍历找到前驱节点 才可以 
*/
bool DeleteNode_LinkList(LNode* L, int& e)
{
	if (L == NULL)
		return false;
	if (L->next==NULL) //说明删除表尾元素
	{
		LNode* p;
		p = L;
		//扫描到倒数第二个节点
		while (p->next)
			p = p->next;
		free(p->next);
		p->next = NULL;
		return true;
	}
	//如果不是表尾节点
	e = L->data;
	LNode* p = L->next;
	L->next = p->next;
	L->data = p->data;
	free(p);
	return true;
}

bool DelteList_LinkList(LinkList& L, int i, int& e)
{
	if (L == NULL)
		return false;
	LNode* p=L->next;
	int j = 1;
	//扫描到到第 i-1个节点
	while (p->next && j < i - 1)
	{
		p = p->next;
		j++;
	}
	if (p->next == NULL || j > i - 1)    //删除位置不合理
		return false;
	// 将第 i个位置上的节点剔除链表
	LNode* q = p->next;
	p->next = q->next;
	e = q->data;
	free(q);
	return true;
}

void Print_LinkList(LinkList L)
{
	printf("---------------------------\n");
	if (L->next == NULL)
	{
		printf("此链表为空表");
	}
	else
	{
		LNode* p = L->next;//头节点
		int i = 1;
		while (p)
		{
			printf("第%4d数据：        %4d\n", i, p->data);
			p = p->next;
			i++;
		}
		printf("打印完毕 此链表长%4d\n",i-1);
	}
	printf("---------------------------\n");
}
bool InsertLisk_LinkList(LinkList& L, int i, int e)
{
	LNode* p;
	if (!GetNode_LinkList(L, i, p))
		return false;
	return (InsertPrior_LinkList(p, e));
}
越行勤
关注
用C语言编写链式存储的线性表（含代码实现）
ewha_rain的博客
11-05 1396
单链表 单链表 单链表是由头指针唯一确定，因此单链表医科用头指针的名字来命名 与链式存储有关的术语 结点：数据元素的存储映像。由数据域和指针域两部分组成。 链表：n个结点由指针链组成一个链表。这是线性表的链式存储映像，称为线性表的链式存储结构。 单链表、双链表、循环链表： 结点只有一个指针域的链表，称为单链表或线性链表。 结点只有两个指针域的链表，称为双链表。 首尾相接的链表称为循环链表。 头指针、头节点和首元结点 头指针：是指向链表中第一个结点的指针 首元结点：是指链表中存储第一个数
数据结构-线性表的连接存储结构及实现
qq_45300403的博客
09-20 553
周六
数据结构和算法——线性表（链式存储）
upc122的博客
04-06 965
线性表是最常见和常用的ADT。假设线性表的元素为整数，请基于单链式存储结构实现线性表ADT。 基本功能包括： （1）建立线性表； 输入有两行：第一行一个整数，是输入元素的结束标志，例如0，则在输入结束时输入0，就表示输入结束了。第二行是线性表的各个元素，最后一个是结束标志。 （2）插入： 输入两个整数，即元素插入的位置和元素值 （3）删除： 输入一个整数，即要删除的元素值 （4）搜索： 输入一个整...
数据结构头歌实验梳理
m0_63192871的博客
09-17 3782
数据结构头歌实验
数据结构与算法 - 线性表(完整代码)
JKR10000的博客
03-27 5583
样例输入: 3 //输入一个数a，后面将输入a个数据元素 8 9 3 //a个数据元素，依次插入尾结点后。形成单链表结点序列：8,9,3 3 //输入一个数b，后面将再输入b个数据元素 10 89 22 //b个数据元素，依次插入0号结点后。形成单链表结点序列：8,22,89,10,9,3 89 //删除一个值为89的结点 1 //删除1号结点 样例输出: 8 10 9 3 #inc...
C语言 数据结构链表的实例（十九种操作）
08-29
C语言数据结构链表的实例（十九种操作） 在计算机科学中，数据结构是指计算机中存储、组织和管理数据的方式。链表是一种基本的数据结构，广泛应用于计算机科学和软件开发中。今天，我们将讨论C语言中的数据结构链表...
湖南大学数据结构链表实验1.zip
03-08
在本实验中，我们将深入探讨数据结构中的一个重要概念——链表。链表是一种线性数据结构，与数组不同，它不连续存储元素。在链表中，每个元素（称为节点）包含两部分：数据和指向下一个节点的指针。这个实验来自湖南...
数据结构链表入门.docx
01-13
《数据结构链表入门》 链表是一种基础且重要的数据结构，在计算机科学中扮演着不可或缺的角色。本资料主要介绍链表的基本概念、操作以及如何在C++中实现链表。以下将详细阐述链表的原理及其在代码中的体现。 1. ...
lb.rar_数据结构 链表
09-20
本资源"lb.rar_数据结构 链表"提供了一些关于链表的C++实现，对学习数据结构的初学者尤其有帮助。 链表是一种线性数据结构，与数组不同，它的元素并不在内存中连续存储。每个元素（节点）包含两部分：数据域，用于...
pp.zip_数据结构链表实验
09-21
在"pp.zip_数据结构链表实验"中，我们聚焦于一个具体的应用场景——学生信息管理。这个实验旨在帮助学生深入理解链表的运作机制，并能够实际操作链表来解决实际问题。 链表是一种线性数据结构，与数组不同，它的...
数据结构与算法 - 线性表
m0_46478866的博客
03-27 3943
数据结构与算法 - 线性表前言第1关：实现一个顺序存储的线性表第2关：实现一个链接存储的线性表总结 前言 线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中，数据元素之间通过一对一首尾相接的方式连接起来。具体实现时，线性表可以采用顺序存储，也可以采用链接存储。本实训项目的主要目标是学习和掌握基于 C 语言实现线性表，主要内容包括基于顺序存储和链接存储的方式来实现线性表。 提示：以下是本篇文章正文内容，下面案例可供参考 第1关：实现一个顺序存储的线性表 本关任务：实现 step1/Seqlist
实现一个链式存储的线性表
konnisan的博客
11-05 5173
实现一个链式存储的线性表任务描述相关知识编程要求测试说明代码实现 任务描述 本关任务：完成一个链接存储的线性表的小程序。 相关知识 线性表的存储也可以采用链接存储方式来实现。链接存储方式包括单链表、双链表和循环链表等形式。 下面描述了一种基于单链表的线性表实现方案： 为了讨论简单，假设数据元素的类型为整型： typedef int T; 在链表中，每个数据元素为一个链表结点，结点的具体定义为： struct LinkNode { T data; LinkNode* next; }; 如
实现一个链接存储的线性表（数据结构与算法 - 线性表）
韶言大雅
04-23 8562
完成一个链接存储的线性表的小程序。 相关知识 线性表的存储也可以采用链接存储方式来实现。链接存储方式包括单链表、双链表和循环链表等形式。 下面描述了一种基于单链表的线性表实现方案： 为了讨论简单，假设数据元素的类型为整型： typedef int T; 在链表中，每个数据元素为一个链表结点，结点的具体定义为： struct LinkNode { T data; LinkNode...
数据结构之线性表的链式存储实现（链表）
Roger's Blogs
05-27 7275
链表由一系列在内存中相连的结点组成, 每个结点均含有数据域和指针域, 数据域存储数据, 指针域存储指向下一个结点的指针. 链表的结构如图:
数据结构 第二章 :双链表，循环链表，静态链表以及对比总结
qq2410030025的博客
03-24 530
本教程来自 本人博客 越行勤‘s Blog ，欢迎大家访问 域名 https://yingwiki.top 文章目录双链表定义初始化双链表和判断是否为空向后插入元素前向插入元素删除后继节点q销毁双链表遍历节点循环链表循环单链表初始化和判断是否为空循环双链表初始化和判空向后插入和删除小小总结静态链表初始化判空向后插入e按元素查找删除数据静态链表的优点静态链表的缺点：适用场景第二章总结 ：顺序表VS链表顺序表链式存储基本操作顺序表 创建和删除销毁 插入链表 创建和删除销毁顺序表查找链表 查找使用哪一个？ .
数据结构
qq2410030025的博客
03-24 192
本教程来自 本人博客 越行勤‘s Blog ，欢迎大家访问 域名 https://yingwiki.top 文章目录数据结构绪论1.1 基本概念数据，数据元素，数据项，结构，数据结构，数据对象1.2三要素的基本概念逻辑结构存储结构补充数据运算1.3数据类型和抽象数据类型**数据类型**抽象数据类型1.4 探讨数据结构的方法算法绪论2.1 什么是算法2.2算法的特性一个优秀的算法的特性2.3 效率的度量：时间复杂度练习一下平均时间复杂度 ，最好时间复杂度，最坏时间复杂度2.4 效率的度量 ：空间复杂度 作.
树——数据结构
b19839356939的博客
09-18 639
树、数据结构、树的定义、树的概念、树的应用、结点
matlab的‌基础语法和数据类型
最新发布
weixin_45710581的博客
09-25 385
MATLAB中的函数用于封装可重复使用的代码块。
数据结构：二叉树（一）
2303_78940834的博客
09-21 923
ps：偷懒了几天，接着更新。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值