笔记-线性表-链表-单链表的定义 建立 插入 删除 查找

最新推荐文章于 2024-05-16 19:21:42 发布
最新推荐文章于 2024-05-16 19:21:42 发布
阅读量839 收藏 14
点赞数 10
分类专栏： 数据结构 文章标签： 笔记 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Maolianwika/article/details/136464933
版权

注：

本文若未声明是否带头结点的代码，默认都是带头结点的 

定义

相对于顺序表：

优点：不需要大片连续的空间，改变表长方便

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

单链表的简单模型：

a1指针指向a2a2

指针指向a3

a3NULL

a1也会有一个指针指向，每一个结点的存储空间包括：数据元素+指向下一个结点的指针

代码：

定义一个单链表结点

struct LNode{    //定义单链表结点类型
    ElemType data;    //数据域：存放数据元素（每个节点存放一个数据元素）
    struct LNode *next;    //指针域：存放指向下一个结点的指针
}

增加新结点要在内存中申请结点所需的空间，并且用一个指针指向这个结点

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

创造一个新的结点，并用指针p指向这个结点

可以使用typedef将数据类型重命名来简化操作

typedef struct LNode LNode;   //typedef关键字+数据类型struct LNode+别名LNode
LNode *p=(LNode *)malloc(sizeof(LNode));

也可以这样进行替代

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

//等价于
struct LNode{
    ElemType data;
    struct LNode *next;
};

typedef struct LNode LNode;
typedef struct LNode *LinkList;

这种替代方式，可以让想定义结点时候，强调返回的是结点就用LNode定义，强调定义的是单链表就用LinkList定义

查找单链表L的第i个元素：（带头节点）

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


LNode* GetElem(LinkList L, int i) {
    int j = 1;
    LNode* p = L->next; //1
    if (i == 0) //2
        return L;
    if (i < 0) //3
        return NULL;
    while (p != NULL && j < i) { //4
        p = p->next;
        j++;
    }
    return p; //5
}

函数的两个参数：指向单链表头节点的指针L  元素的位序i

1        先定义一个p指针指向头节点的下一个节点

2        如果查找的是第零个元素的位置，则直接返回头节点L

3        如果查找的位置是负数，则判断查找的数据不合理

4        如果p指针不是指向空位置（链表还有数据），p指针就一直移动到第i个位置，即p指针此时指向第i个元素，就可以直接返回p得出该元素

打印链表的数据

void printList(LNode *L) {
    LNode *p = L->next;  // 跳过头节点
    while (p != NULL) {
        printf("%d    ", p->data);
        p = p->next;
    }
    printf("\n");
}

求表长

int length(LinkList L) {
    int len = 0;
    LNode* p = L;
    while (p->next != NULL) {
        p = p->next;
        len++;
    }
    return len;
}

建立

判断单链表是否为空

bool Empty(LinkList L) {
    if (L == NULL)
        return true;
    else
        return false;
}

//或者
bool Empty(LinkList L) {
    return (L == NULL);
}

初始化单链表：

不带头结点：

bool InitL(LinkList& L) {
    L = NULL;   //保证链表是空的
    return true;
}

带头结点：

bool InitL(LinkList& L) {
    L = (LNode*)malloc(sizeof(LNode));  //分配头结点空间
    if (L == NULL)  //内存不足分配失败
        return false;
    L->next = NULL; //保证头结点下一个指向一个空位，单链表是空的
    return true;
}

头结点可以方便为什么进行操作，头结点本身不存储数据

头插法建立单链表：

LinkList List_Head(LinkList &L) {
    LNode* s;
    int x;
    L = (LinkList)malloc(sizeof(LNode));    //1
    L->next = NULL;    //2
    printf("输入第一个节点的值：");
    scanf("%d", &x);    //3
    while (x != 000) {    //4
        s = (LNode*)malloc(sizeof(LNode));    //5
        s->data = x;    //6
        s->next = L->next;    //7
        L->next - s;    //8
        printf("请输入下面的节点值（输入000结束输入）：");
        scanf("%d", &x);    //9
    }
    return L;    
}

1        创建头结点，为其分配空间

2        头结点的下一个指向一个空位置，保证链表初始是空的

3        输入第一个节点的值

4        接下来输入其他节点的值，设置一个规则：输入000即可结束输入

5        为接下来的节点分配空间

6        保存之前输入过的值，存到下一个新节点

7 8     将新的节点插入到头结点之后       

9        输入下一个节点的值，依次循环，如果输入000就结束输入

头插法的作用：链表的逆置

尾插法建立单链表：

LinkList List_Tail(LinkList& L) {
    int x;
    L = (LinkList)malloc(sizeof(LNode));
    LNode* s, * r = L;    //1
    scanf("%d", &x);
    while (x != 000) {
        s = (LNode*)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;    //2
        r = s;    //3
        printf("请输入下面的节点值（输入000结束输入）：");
        scanf("%d", &x);
    }
    r->next = NULL;    //4
    return L;
}

1        开始s和r都指向头结点，r指针会在后面作为表尾指针

2        将新的节点，插入到尾结点的后面

3        更新尾结点为新插入的节点

4        尾结点指针置空

插入

按位序插入

带头结点

bool ListInsert(LinkList& L, int i,int e) {
    if (i < 1)
        return false;
    LNode* p;    //1
    int j = 0;    //2
    p = L;    //3
    while (p != NULL && j < i - 1) {    //4
        p = p->next;
        j++;
    }
    if (p == NULL)
        return false;
    LNode* s = (LNode*)malloc(sizeof(LNode));
    s->data = e;    //5
    s->next = p->next;    //6
    p->next = s;    //7
    return true;
}

1        设置一个指针p，指向当前扫描到的结点

2        设置一个计数器，表示当前指向的是第几个结点

3        将p结点指向头结点，这个时候计数器是0，依据这个定义进行下面的循环判断

4        循环到第i个元素停止，下面就进行插入了

5        先将e值赋给s指向的数据域

6        将第i个节点的下一个置给新的节点

7        将原来的第i个节点的下一个指向新的节点

67两步完成了对s的插入

平均时间复杂度：O（n）


不带头结点

bool ListInsertNohead(LinkList& L, int i, int e) {
    if (i < 1)
        return false;
    if (i == 1) {    //1
        LNode* s = (LNode*)malloc(sizeof(LNode));
        s->data = e;
        s->next = L;
        L = s;
        return true;
    }
    LNode* p;
    int j = 1;
    p = L;
    while (p != NULL && j < i - 1) {    //2
        p->next;
        j++;
    }
    if (p == NULL) {
        return false;
    }
    LNode* s = (LNode*)malloc(sizeof(LNode));
    s->data = e;        //3
    s->next = p->next;
    p->next = s;
    return true;
}

1        插入第一个节点的操作和其他的节点操作不一样，所以要单独拎出来，要把元素e值赋给s的数据域，并且用头指针指向新的节点

2        指针扫描到第i个结点

3        逻辑和带头结点的一样不再赘述

很明显不带头结点的更加不方便，所以我们尽量都要带头结点

平均时间复杂度：O（n）

指定节点的插入

前插

bool InsertPriorNode(LNode* p, int e) {
    if (p == NULL)
        return false;
    LNode* s = (LNode*)malloc(sizeof(LNode));
    if (s == NULL)    //1
        return false;
    s->next = p->next;    //2
    p->next = s;    //3
    s->data = p->data;    //4
    p->data = e;    //5
    return true;    //6
}

1        内存分配失败导致插入失败

2        将新节点s的下一个指向的设置为原来p结点下一个指向的东西

3        将p节点的下一个指向新的节点s，完成s的插入

4        将p的数据赋给新节点s

5        将e赋给p节点，作为p位置的新值

形成实际上的将e插到了p的前面（实际上是e代替了原来p的位置，但是将p赋到了新的节点，这个节点在原来p的后面）

时间复杂度：O（1） 

后插

bool InsertNextNode(LNode* p, int e) {
    if (p == NULL)
        return false;
    LNode* s = (LNode*)malloc(sizeof(LNode));
    if (s == NULL)    //1
        return false;
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

将s节点插入到p的后面

1        某些情况下可能会有分配失败的情况，例如内存不足

时间复杂度：O（1）

删除

按位序删除

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) {    //1
        p = p->next;
        j++;
    }
    if (p == NULL)
        return false;
    if (p->next == NULL)
        return false;
    LNode* q = p->next;    //2
    e = q->data;    //3
    p->next = q->next;    //4
    free(q);    //5
    return true;
}

还未删除时是这样的

p        q        q的下一个节点

          ↑

    要被删除的

1        循环到第i-1个结点（p这是指向的不是要被删除的节点）

2        设置一个新的节点q指向被删除的节点

3        用e来存放将被删除的节点的数据域并且我们这个函数要使用这个值，所以在定义的时候要加&

4        将p指向的节点的下一个设置为q下一个节点，这里就相当于把q从链表的链中剔除了

5        删除p节点（要被删除的第i个基点）

指定节点的删除

void DeletNodeP(LinkList L, LNode*p) {
    LNode* pre = L;
    LNode* thisone = L->next;

    while (thisone != NULL) {
        if (thisone == p) {    //1
            pre->next = thisone->next;
            free(thisone);
            
            break;
        }
        pre = thisone;
        thisone = thisone->next;
    }
}

也是设置两个指针，一个是当前节点一个是前一个节点

1        当设置的thisone和p是一个位置时进行对p的删除操作

我们来展示一下王道上面的解决方法：

bool DeletNode(LNode* p) {
    if (p == NULL)
        return false;
    LNode* q = p->next;
    p->data = p->next->data;    //1
    p->next = q->next;
    free(q);
    return true;
}

这种方法的局限在于，如果要删除的是最后一个节点，那只能另外处理这种情况

1        如果是最后一个节点的next是没有数据的，所以这句代码没有办法操作

但是好处是时间复杂度为O（1），不需要循环处理非常方便

我这种方法需要循环，时间复杂度高一些，所以大家自行取舍

指定数据的删除

void DeletNode(LinkList& L, int e) {
    LNode* p = L->next;    //1
    LNode* q = L;

    while (p != NULL) {
        if (p->data == e) {    //2
            q->next = p->next;
            free(p);
            p = q->next;    //3
        }
        else {    //4
            q = p;
            p = p->next;
        }
    }
}

1        设置两个指针，一个p指向当前节点，一个q指向p的前一个节点（删除时会使用q）

2        如果遍历过程中发现了数据域等于e的位置， 就进行p的删除

3        p删除之后继续遍历寻找是否还有跟e相等的位置继续删除

4        当前节点不是e的值时，就继续遍历

查找

按位查找

返回第i个元素的值

完整代码

LNode* GetElem(LinkList L, int i) {
    if (i < 0)
        return NULL;
    LNode* p;    //1
    int j = 0;    //2
    p = L;    //3
    while (p != NULL && j < i) {    //4
        p = p->next;
        j++;
    }
    return p;
}

1        设置一个指针p，指向当前扫描到的节点

2        定义一个j，让j作为计数器，指示出当前p指向的第几个结点

3        p设置在头结点上开始（并且上面j设置为0，表示头结点是第0个节点）

4        循环找到第i个结点

时间复杂度

O（n）

按值查找

找到数据域等于e的结点

完整代码

LNode* LocateElemData(LinkList L, int e) {
    LNode* p = L->next; //1
    while (p != NULL && p->data != e)   //2
        p = p->next;
    return p;
}

1        设置一个p指针从第一个数据域开始依次比较

2        p指针指的数据不等于e就依次下移动，直到有一个数据等于e即得出结果

 最后p指针只会返回结点指针，或者NULL

时间复杂度

O（n）

参考资料：

王道考研 数据结构

以上文章为个人理解内容，如有缺漏或错误，麻烦评论区告知我，十分感谢，希望能对你有所

Goldenglows
关注
  • 10
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构学习--线性表及其应用--链表
06-25
本程序的主要目的在于帮助同学熟练掌握线性表的基本操作在链式存储结构上的实现， 链表的优点是“按需分配”，且增删方便，缺点是不能随机访问。在实际当中，有许多应用 是频繁变动，但并不要求随机访问，在这样的...
408计算机综合数据结构笔记--线性表（2）链表
weixin_45734483的博客
05-18 255
408计算机综合数据结构笔记–线性表（2）链表 分类 单链表，双链表，循环链表，静态链表 单链表的定义 每个节点除了存放数据外还要存放指向下一个节点的指针 代码定义 struct LNode{ //定义单链表节点类型 ElemType data;//定义存放数据类型 struct *LNode next;//存放下一个节点位置的指针 }LNode,*LinkList; //新增一个节点，申请该节点所需空间，并用指针p指向该节点 LNode*p=(LNode*)malloc(sizeof(LNode))
【Java数据结构实现二】-- 线性表 -- 顺序表＋单链表+双向链表（增删改查遍历等）
hannah2233的博客
11-27 551
参考视频： 【黑马程序员】2020最新数据结构与算法教程（求职面试必备） 参考leetcode学习资料： 图解算法数据结构 注意 目录结构呦！！！按本文目录 在src文件夹下 创建项目和文件，直接粘代码即可运行 文章目录算法和数据结构简述+排序的笔记MywritelinearSequenceList（顺序表）LinkList（单链表）TwoWayLinkList（双向链表） 算法和数据结构简述+排序的笔记 【Java数据结构笔记一】-- 数据结构与算法概述–【时间复杂度+空间复杂度】 【Java.
大话数据结构学习笔记 - 线性表、顺序存储、单链表及静态链表
hao555sky
05-16 381
大话数据结构学习笔记之(3) - 线性表、顺序存储、单链表及静态链表 定义 线性表(List)： 零个或多个数据元素的有限序列 数学定义： 若将线性表记为(a1,...,ai−1,ai,ai+1,...,an)(a1,...,ai−1,ai,ai+1,...,an) (a_{1}, ..., a_{i-1}, a_{i}, a_{i+1}, ..., a_{n})， 则表中 ai−1ai−1...
数据结构笔记-线性表
weixin_43586481的博客
04-19 139
第二章 线性表 #1、顺序表：随机访问、存储密度高、但拓展容量不方便，插入删除不方便 //定义: #define MaxSize 10 typdedf struct{ int data[MaxSize]; int length; }SqList; #define InitSize 10 typdedf struct{ ElemType *data; //指示动态分配数组的指针 int MaxSize； int length; }...
2.3.1笔记-线性表的链式表示和实现
上官云霆的博客
01-18 1958
和顺序表相比，链表存储结构在实现插入、删除的操作时，不需要移动大量数据元素(但不容易实现随机存取线性表的第i个数据元素的操作)。所以，链表适用于经常需要进行插入和删除操作的线性表，如飞机航班的乘客表等。线性链表中单链表的结构(教材P28)struct LNode{//线性表的单链表结构 ElemType data; LNode *next; };下面程序中用到的单链表是带有头结点的单
数据结构复习笔记-------线性表的链式存储
xrzyxbc的博客
08-06 395
1.线性表的链式存储 知识点 1 链表：任意的存储结构（连续与否均可以） 知识点 2 链表中数据元素的逻辑顺序和存储顺序可能不一致 知识点 3 结点结构定义 typedef struct node{ Datatype data； struct node *next； }Node； 知识点 4 1.无头结点的单链表 (1) 无头结点的单链表非空链表 (2) first 空表 first NULL 无头结点的单链表为空的条件是first=NULL 2.有头结点的单链表 ..
数据结构与算法学习笔记-线性表
qq_53548177的博客
12-10 573
声明：本博客仅为本人学习途中做的笔记 采自青岛大学王卓老师的视频教学 主要内容为算法思路，具体代码实现还需修改后才能运行，望各位看官多多包涵，您的点赞与评论是对我最大的肯定！ # 1.线性表的定义和特点 线性表是具有相凤特性的数据元素的一个有限序列 (a1,a2,...ai−1,ai,ai+1,...,an) (a_1, a_2, ... a_i-_1, a_i,a_i+_1, ..., a_n) (a1​,a2​,...ai​−1​,ai​,ai​+1​,...,an​)\qquad\qquad\q.
数据结构笔记2 线性表-链式表示-单链表
m0_49372475的博客
04-19 406
二、线性表的顺序表示与实现-单链表 一些基本操作
数据结构笔记---线性表
派小汤的博客
04-17 381
数据结构笔记二、线性表1.线性表的定义和基本操作1.1 基本概念和术语1.2 线性表的基本操作 二、线性表 1.线性表的定义和基本操作 1.1 基本概念和术语 线性表：线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列，n为表长。若用L命名线性表，则表示为：(a1a_1a1​,a2a_2a2​,a3a_3a3​…aia_iai​,ai+1a_{i+1}ai+1​…,ana_nan​...
数据结构-线性表-单链表的查找、插入、删除.doc
10-10
数据结构-线性表-单链表的查找、插入、删除.doc
数据结构---线性表之单链表（C语言）
03-28
数据结构---线性表之单链表，包括单链表的创建、插入、删除等，C语言编写
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
12-02
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
数据结构---线性表之双链表（C语言）
03-29
数据结构---线性表之双链表，创建、插入、删除，完整的C代码
Linux知识点笔记
最新发布
exercise_smile的博客
05-16 802
Linux 主要的发行版(release):Ubuntu(乌班图)、 RedHat(红帽)、 CentOS、 Debain[蝶变]、 Fedora、 SuSE、 OpenSUSE [示意图]在 linux 中的每个用户必须属于一个组， 不能独立于组外。在 linux 中每个文件 有所有者、 所在组、 其它组的概念。ls -l 中显示的内容如下：0-9 位说明：第 0 位确定文件类型(d, - , l , c , b)l 是链接， 相当于 windows 的快捷方式。
《大数据分析-数据仓库项目实战》学习笔记
LANXIAMAO的博客
05-09 954
文章部分内容参考《大数据分析-数据仓库项目实战》一书，仅供学习，喜欢可购买正版书籍，如有不妥请联系删除。
推荐系统学习笔记（一）
weixin_44880995的博客
05-15 140
同类策略（精排中的两种模型）天然互斥，并且（两条召回通道）效果会相互影响，避免干扰。反转：有的指标立刻影响，有的需要长期观测-------尽快推全也可以长期观测。10%作为holdout桶，实验使用剩余的90%，做diff（需要归一化）不同策略（添加召回通道，优化粗排模型）通常不会干扰，可以作为正交的两层。保留10%，完全不受实验影响，可以考察整个部门对业务指标的贡献。同层互斥----避免一个用户被两个实验影响。不同层正交----每层独立随机分配用户。推全：新层，与其他层正交，90%用户。
英语学习笔记13——A new dress
AllenAC的博客
05-15 1010
英语学习笔记13——A new dress
数据结构与算法-线性表
09-13
数据结构与算法-线性表是一种用于存储数据的数据结构，它可以...线性表可以使用顺序表或链表来实现，顺序表适合于随机访问，而链表适合于插入和删除操作。对于链表来说，需要注意不同类型的链表有不同的操作和特点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值