数据结构的单链表

已于 2022-11-28 12:22:09 修改
阅读量408 收藏 3
点赞数
文章标签： 数据结构 链表
于 2022-11-23 11:41:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/str_lai/article/details/127924717
版权

数据结构的单链表

单链表的定义

定义

用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的，也可以是不连续的)。因此，为了表示每个数据元素a，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息(直接后继的存储位置)。这两部分信息组成数据元素a的存储映像，称为节点(node)。它包括两个域：其中存储数据元素信息的域称为数据域；存储直接后继存储位置的域称为指针域。指针域中存储的信息称作指针或链。n个节点[a(1＜i＜n)的存储映像]链接成一个链表，即为线性表：

                           (aj, a2,…,an)

的链式存储结构。又由于此链表的每个节点中只包含一个指针域，故又称线性链表或单链表。

typedef struct LNode {
    int data;
    struct LNode* next;
}LNode, * LinkList;

单链表的存储结构

下图所示为线性表的单链表存储结构，整个链表的存取必须从头指针开始进行，头指针指示链表中第一个节点(第一个数据元素的存储映像，也称首元节 第点)的存储位置。同时，由于最后一个数据元素没有直接后继，则单链表中最后一个节点的指针为空(NULL)。
请添加图片描述

单链表的逻辑状态

通常将链表画成用箭头相链接的节点的序列，节点之间的箭头表示链域中的指针。上图所示的单链表可画成下图所示的形式，这是因为在使用链表时，关心的只是它所表示的线性表中数据元素之间的逻辑顺序，而不是每个数据元素在存储器中的实际位置。请添加图片描述

单链表操作

头节点

一般情况下，为了处理方便，在单链表的第一个节点之前附设一个节点，称之为头节点。上图所示的单链表增加头节点后如下图所示。
请添加图片描述

说明

  1. 首元节点是指链表中存储第一个数据元素a，的节点。如图2.8或图2.9所示的节点“ZHAO”
  2. 头节点是在首元节点之前附设的一个节点，其指针域指向首元节点。头节点的数据域可以不存储任何信息，也可存储与数据元素类型相同的其他附加信息。例如，当数据元素为整型时，头节点的数据域中可存放该线性表的长度。
  3. 头指针是指向链表中第一个节点的指针。若链表设有头节点，则头指针所指节点为线性表的头节点；若链表不设头节点，则头指针所指节点为该线性表的首元节点。

初始化

单链表的初始化操作就是构造一个只有头节点的空表。

void InitList(LinkList& L)
{
    L = (LNode*)malloc(sizeof(LinkList));
    L->next = NULL;
}

取值

和顺序表不同，链表中逻辑相邻的节点并没有存储在物理相邻的单元中，这样，根据给定的节点位置序号i，在链表中获取该节点的值不能像顺序表那样随机访问，而只能从链表的首元节点出发，顺着链域next逐个节点向下访问。

void GetElem(LinkList* L, int i, ElemType& e)
{//在带头节点的单链表L中根据序号1获取元素的值,用e返回L中第1个数据元素的值
    LinkList* p;
    p = L->next; int j = 1;       //初始化P指向首元节点,计数器初值赋为1
    while (p && j < i)        //顺链域向后查找,直到P为空或p指向第1个元素
    {
        p = p->next;           //p指向下一个节点
        j++;                //计数器j相应加1
    }
    if (!p || j > i)
    {
        return 0;      //i值不合法i>n或i<=0
    }
    e - p->data;         //取第i个节点的数据域
    return 1;
}

查找

链表中按值查找的过程和顺序表类似，从链表的首元节点出发，依次将节点值和给定值e进行比较，返回查找结果。

按值查找

//按值查找：查找x在L中的位置
LNode* LocateElem(LinkList L, int x)
{
    LNode* p = L->next;
    while (p && p->data != x) {
        p = p->next;
    }
    return p;
}

按位查找

//按位查找：查找在单链表L中第i个位置的结点
LNode* GetElem(LinkList L, int i) {
    int j = 1;
    LNode* p = L->next;
    if (i == 0)return L;
    if (i < 1)return NULL;
    while (p && j < i) {
        p = p->next;
        j++;
    }
    return p; //如果i大于表长，p=NULL,直接返回p即可
}

插入

假设要在单链表的两个数据元素a和b之间插入一个数据元素x，已知p为其单链表存储结构中指向节点a的指针，如图(a)所示。
请添加图片描述
为插入数据元素x，首先要生成一个数据域为x的节点，然后将之插入单链表中。根据插入操作的逻辑定义，还需要修改节点a中的指针域，令其指向节点x，而节点x中的指针域应指向节点b，从而实现3个元素a、b和x之间逻辑关系的变化。插入后的单链表如图(b)所示。

void Insert(LinkList& L, int i, int x)
{
    LNode* p = GetElem(L, i - 1);
    LNode* s = (LNode*)malloc(sizeof(LNode));
    s->data = x;
    s->next = p->next;
    p->next = s;
}

删除

要删除单链表中指定位置的元素，同插入元素一样，首先应该找到该位置的前驱节点。如下图所示，在单链表中删除元素b时，应该首先找到其前驱节点a。为了在单链表中实现元素a、b和c之间逻辑关系的变化，仅需修改节点a中的指针域即可。
但在删除节点b时，除了修改节点a的指针域外，还要释放节点b所占的空间，所以在修改指针前，应该引入另一指针q，临时保存节点b的地址以备释放。

void Delete(LinkList& L, int i)
{
    if (i<1 || i>Length(L)) {
        cout << "delete failed: index is wrong." << endl;
        return;
    }
    LNode* p = GetElem(L, i - 1);
    LNode* q = p->next;
    p->next = q->next;
    free(q);
}

创建单链表

前插法

前插法是通过将新节点逐个插入链表的头部(头节点之后)来创建链表，每次申请一个新点，读入相应的数据元素值，然后将新节点插入到头节点之后。
下图所示为线性表(b，c，d，e)前插法的创建过程，因为每次插入在链表的头部，所以应逆位序输入数据，依次输入e、d、c、b，输入顺序和线性表中的逻辑顺序是相反的。
请添加图片描述

LinkList HeadInsert(LinkList& L)
{
    InitList(L); //初始化
    int x;
    cin >> x;
    while (x != 9999) {
        LNode* s = (LNode*)malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
        cin >> x;
    }
    return L;
}

后插法

后插法是通过将新节点逐个插入链表的尾部来创建链表。同前插法一样，每次申请一个新节点，读入相应的数据元素值。不同的是，为了使新节点能够插入表尾，需要增加一个尾指针r指向链表的尾节点。
请添加图片描述

LinkList TailInsert(LinkList& L)
{
    InitList(L);
    LNode* s, * r = L;
    int x;
    cin >> x;
    while (x != 9999) {
        s = (LNode*)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;
        cin >> x;
    }
    r->next = NULL;
    return L;
}

完整代码

#include <stdlib.h>
#include <iostream>
using namespace std;

typedef struct LNode
{
    int data;
    struct LNode* next;
}LNode, * LinkList;

//初始化
void InitList(LinkList& L)
{
    L = (LNode*)malloc(sizeof(LinkList));
    L->next = NULL;
}

//遍历操作
void PrintList(LinkList L)
{
    LNode* p = L->next;
    while (p) {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}

//求单链表的长度
int Length(LinkList L) {
    LNode* p = L->next;
    int len = 0;
    while (p) {
        len++;
        p = p->next;
    }
    return len;
}

//按值查找：查找x在L中的位置
LNode* LocateElem(LinkList L, int x)
{
    LNode* p = L->next;
    while (p && p->data != x) {
        p = p->next;
    }
    return p;
}

//按位查找：查找在单链表L中第i个位置的结点
LNode* GetElem(LinkList L, int i) {
    int j = 1;
    LNode* p = L->next;
    if (i == 0)return L;
    if (i < 1)return NULL;
    while (p && j < i) {
        p = p->next;
        j++;
    }
    return p; //如果i大于表长，p=NULL,直接返回p即可
}

//将x插入到单链表L的第i个位置上
void Insert(LinkList& L, int i, int x)
{
    LNode* p = GetElem(L, i - 1);
    LNode* s = (LNode*)malloc(sizeof(LNode));
    s->data = x;
    s->next = p->next;
    p->next = s;
}

//删除操作:将单链表中的第i个结点删除
void Delete(LinkList& L, int i)
{
    if (i<1 || i>Length(L)) {
        cout << "delete failed: index is wrong." << endl;
        return;
    }
    LNode* p = GetElem(L, i - 1);
    LNode* q = p->next;
    p->next = q->next;
    free(q);
}


//头插法建立单链表
LinkList HeadInsert(LinkList& L)
{
    InitList(L); //初始化
    int x;
    cin >> x;
    while (x != 9999) {
        LNode* s = (LNode*)malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
        cin >> x;
    }
    return L;
}

//尾插法建立单链表
LinkList TailInsert(LinkList& L)
{
    InitList(L);
    LNode* s, * r = L;
    int x;
    cin >> x;
    while (x != 9999) {
        s = (LNode*)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;
        cin >> x;
    }
    r->next = NULL;
    return L;
}

//按值查找：查找x在L中的位置
LNode* LocateElem(LinkList L, int x)
{
    LNode* p = L->next;
    while (p && p->data != x) {
        p = p->next;
    }
    return p;
}

//按位查找：查找在单链表L中第i个位置的结点
LNode* GetElem(LinkList L, int i) {
    int j = 1;
    LNode* p = L->next;
    if (i == 0)return L;
    if (i < 1)return NULL;
    while (p && j < i) {
        p = p->next;
        j++;
    }
    return p; //如果i大于表长，p=NULL,直接返回p即可
}

//将x插入到单链表L的第i个位置上
void Insert(LinkList& L, int i, int x)
{
    LNode* p = GetElem(L, i - 1);
    LNode* s = (LNode*)malloc(sizeof(LNode));
    s->data = x;
    s->next = p->next;
    p->next = s;
}

//删除操作:将单链表中的第i个结点删除
void Delete(LinkList& L, int i)
{
    if (i<1 || i>Length(L)) {
        cout << "delete failed: index is wrong." << endl;
        return;
    }
    LNode* p = GetElem(L, i - 1);
    LNode* q = p->next;
    p->next = q->next;
    free(q);
}
str_lai
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构之单链表
xhuyang111的博客
02-05 259
线性链表 文章目录线性链表一、什么是线性链表？二、单链表基本功能的实现1.创建结构体以及初始化单链表（不带头结点）2.单链表的插入和删除操作整个单链表的实现代码，以及测试函数 一、什么是线性链表？ 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素（这组存储单元既可以是连续的，也可以是不连续的）。因此，为了表示每个数据元素ai与其直接后继数据元素ai+1之间的逻辑关系，对数据ai来说，除了存储其本身的信息之外，还需要存储一个指示其直接后继的信息。这两部分构成数据ai的存储映像，称为结点
链表的定义和运算
yikuaidabin的博客
12-06 633
数据结构，链表的定义和运算
数据结构-顺序表相关操作
程国华的专栏
03-11 553
#include #include #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define OVERFLOW -2 #define OK 1 #define ERROR 0 typedef int ElemType; //顺序表结构 typedef struct { ElemType *elem; int l
单链表--在第i个位置前插入新元素/在第j个位置删除一个元素
find1star的博客
09-16 2922
【代码】单链表--在第i个位置前插入新元素/在第j个位置删除一个元素。
Leap Day5——数据结构与算法 线性表基础练习题
胖虎虎
01-11 1209
目录 1、顺序表 1.1 存储定义 1.2 构造顺序表 1.3 静态初始化顺序表 1.4 顺序表的元素输出 1.5 顺序表的 插入 1.6 顺序表的删除 1.7 顺序表的取值 1.8 顺序表的查找 2、单链表 2.1 单链表的存储定义 2.2 头插法创建单链表 2.3 单链表的插入 2.4 单链表的删除 2.5 单链表的取值 2.6 单链表的查找 1、顺序表 1.1 存储定义 顺序表的存储定义 typedef st...
数据结构单链表制作QQ名片最终稿
04-27
绝对干货直接就是源代码 采用顺序表，设计一个QQ群名片，主要包含：QQ号码、昵称、性别、年龄、生日等属性。完成基本功能如下： （1）初始化群名片； （2）添加某一个QQ群中10名成员的名片信息；...
数据结构 单链表 约瑟夫问题
08-27
数据结构 单链表 约瑟夫问题
数据结构单链表
01-08
数据结构的一些讲解，供学习者参考，也顺带作为复习需要源代码的欢迎下载，免积分，共同学习，家下来每天都会分享一篇，持续一个星期
数据结构单链表的详细介绍
09-03
单链表是计算机科学中数据结构的基础之一，它在存储和操作数据方面具有灵活的特点。在本资源中，我们将深入探讨单链表的概念、实现、操作以及其在C语言中的应用。 首先，单链表是一种线性数据结构，其中每个元素...
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
＜顺序表—链表＞题目练习《数据结构(C语言版)》
m0_57859086的博客
06-03 877
＜顺序表—链表＞题目练习《数据结构(C语言版)》 ——By 作者：新晓·故知
数据结构习题
闲的没事干
08-05 217
动态顺序表 顺序表算法 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示； 增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示； 全新的 KaTeX数学公式 语法； 增加了支持甘特图的mermaid语法1 功能； 增加了 多屏幕编辑 Markdown文章功能； 增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间； 增加了 检查列表 功能。
链表详解（单链表、双向链表、链表逆序）
别呀的博客
04-07 1944
单链表 想了解单链表的一些概念可以看我另一篇博客： 链表基础 单链表结构体定义 //单链表的结构定义 typedef struct LNode { int data; //data存放结点数据域 struct LNode *next; //指向后继结点的指针 }LNode; 单链表的建立 （1）定义单链表的数据结构； （2）读取数据； （3）生成新结点； （4）将数据存入结点的成员变量中； （5）将新结点连接到表头或表尾。 重复（2）~（5）直到输入结束。 //头插法建立单链表 void c
单链表的基本操作
代码改变世界，keep coding。
10-12 3217
1、定义单链表节点类； 2、定义单链表类，并实现单链表的创建、插入、删除、取元素操作和将单链表中的最小元素移到最前面的操作； 3、从键盘上依次输入21、75、30、18、42、56，顺序或逆序创建单链表，并输出单链表中的各元素值； 4、分别在单链表的第3个位置和第9个位置插入67和10，给出插入成功或失败的信息，并输出单链表中的各元素值； 5、删除单链表中的第6个数据元素和第8个数据元素，
单链表逆置算法图解
热门推荐
站在人文与技术的交汇点
12-05 2万+
 链表的各种操作逻辑性较强，初学者如果不能很好的理解链表的概念和结构，往往会“蒙圈”！而对于初学者，链表逆置更是比较难以理解！--------------------------------------------------------------------       首先说明一下链表逆置的概念：链表逆置不同于数组逆置，其首节点需要保持不变！这是因为链表的输出是以头节点指向首节点，然后根据各...
单链表内部逻辑详解
qq_42898629的博客
12-12 687
在线性表的链式存储结构中，为了便于插入和删除算法的实现,每个链表都带有一个头指针(用Head表示),并通过头指针唯一标识该链表,从头指针所指的头结点出发,沿着结点的指针域可以访问到每个结点. 下面是单项链表的代码实现: /// <summary> /// 单项链表. /// </summary> public class LinkedLi...
初识集合和数据结构
最新发布
m0_51821434的博客
08-03 723
这次文章就浅浅的介绍了一下数据结构的基础知识，集合的框架，算法的一些特性
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值