单链表笔记

最新推荐文章于 2021-12-16 11:58:40 发布
最新推荐文章于 2021-12-16 11:58:40 发布
阅读量189 收藏 1
点赞数
分类专栏： 数据结构 王道 文章标签： 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44029810/article/details/116244422
版权

单链表

线性表的链式存储又称为链表，它是指的是通过任意一组的存储单元来存储线性表中的数据元素。

单链表的存储

typedef int ElemType;
typedef struct LinkedNode {
    ElemType data;//存放数据元素
    struct LinkedNode* next;//指向下一个链表结点
}*LinkedList,LinkNode;

Notes:

  1. 利用链表可以接解决顺序表需要大量连续存储单元的缺点。
  2. 由于单链表元素离散地分布在存储空间中，所以单链表是非随机存取地存储结构，查找某个特定结点时，需要从表头开始遍历，依次查找。
  3. 引入头节点后可以带来两个优点
    1. 由于第一个数据结点的位置存放在头节点的指针域内，无需进行特殊处理。
    2. 无论链表是否为空，其头节点都指向头结点的非空指针(空表中头结点的指针域为空)，因此空表和非空表的处理也得到了处理

单链表基本操作实现

建立单链表

  • 采用头插法建立单链表

带头结点的实现

LinkedList List_HeadInsert(LinkedList& L)
{
    LinkNode* s;
    int x;
    InitList(L);//先构造一个空表

    scanf_s("%d", &x);//先读入一个x值
    while (x != -1)// -1作为读取结束的标志，当然也可以用其他标志
    {
        s = (LinkNode*)malloc(sizeof(LinkNode));
        s->data = x;
        s->next = L->next;
        L->next = s;//这两行代码是插入的关键代码，
        //先将L->next赋值给s->next,然后s赋值给L->next;
        scanf_s("%d", &x);
    }
    return L;
}
  • 采用尾插法建立单链表
LinkedList List_TailInsert(LinkedList& L)
{
    LinkNode* s;
    int x;
     InitList(L);

    scanf_s("%d", &x);
    LinkNode* pt = L;
    while (pt->next != NULL)
    {
        pt = pt->next;//首先找到尾结点，利用边界条件。
    }
    while (x != -1)
    {
        s = (LinkNode*)malloc(sizeof(LinkNode));
        s->data = x;
        pt->next = s;
        pt = s;
        scanf_s("%d", &x);
    }
    pt->next = NULL;//这句代码用来指令尾部结点的next是NULL，要不然容易指向野指针！

    return L;
}

查找值

  • 按序号查找结点值
    在单链表从第一个出发，顺着指针next域逐个往下搜索，直到找个第i个结点为止，否则返回最后一个结点指针域NULL
    算法如下：
  LinkNode* GetElem(LinkedList L, int index)
{
    if (index < 0 || index > Length(L))
    {
        std::cout << "index的值不合法！" << std::endl;
        return NULL;
    }//若index无效，则返回NULL;

    if (index == 0)
    {
        return L;
    }
    if (L == NULL)
    {
        return NULL;
    }

    int j = 1;//计数。初始值为1

    LinkNode* pt = L->next;//头结点指针赋值给p

    while (pt != NULL && j < index)
       // while (pt && j < index)
    {
        pt = pt->next;
        j++;
    }
    return pt;//返回第i个结点的指针，若i大于表长，则返回NULL
}

按序查找操作的时间复杂度为O(n)

  • 按照值查找表结点

从单链表第一个结点开始，从前往后依次比较表中各节点指针域的值，若某结点数据域的值等于给定值e，则返回该结点的指针；若整个单链表中没有这样的结点，则返回NULL;

LinkNode* LocateElem(LinkedList L, ElemType e) {
    LinkNode* p = L->next;
    while (p != NULL  && p->data != e)
    {
        p = p->next;

    }
    return p;
}

时间复杂度为O(n),n为链表的长度

插入结点操作

插入结点操作将值为x的新节点插入到单链表的第i个位置上。先检查插入位置的合法性，然后找到待插入位置的前驱结点，即第i-1个结点，再在其后插入新节点

bool InsertLinkNode(LinkedList L, int index, ElemType e) {
    if (index <= 0 || index > Length(L))
    {
        cout << "index值不合法" << endl;
        return false;
    }
    LinkNode* s;
    if (index == 1)//若为第一个位置，直接在表头后面插入即可
    {
        s = (LinkNode*)malloc(sizeof(LinkNode));
        s->data = e;
        s->next = L->next;
        L->next = s;
        return true;
    }
    s = (LinkNode*)malloc(sizeof(LinkNode));
    LinkNode* p = GetElem(L, index - 1);//首先找到第index-1个位置的结点

    //执行插入操作

    s->next = p->next;
    p->next = s;
    s->data = e;

    return true;
}

本算法主要的时间开销在于查找i-1个元素，时间复杂度为O(N).若在给定的结点后面插入新节点，则时间复杂度为O(1)

删除结点操作

bool ListNodeDelete(LinkedList L, int index) {
    if (index <= 0 || index > Length(L))
    {
        cout << "index值不合法" << endl;
        return false;
    }

    LinkNode* p = GetElem(L, index - 1);

    LinkNode* pnext = p->next;
    p->next = pnext->next;
    free(pnext);
}

时间复杂度为O(n),主要时间开销主要在查找操作上

求表长操作

带头结点求表长

int Length(LinkedList L) {
    LinkNode *pt = L->next;
    int length = 0;
    while (pt != NULL)
    {
        length++;
        pt = pt->next;
    }
    return length;
}

单链表的原地逆置

LinkedList Reverse_1(LinkedList &L)
{
    LinkNode* p = L->next;
    LinkNode* q;
    L->next = NULL;//首先将原有链表置为空！

    while (p != NULL)
    {
        q = p->next;//q首先指向下一个
        p->next = L->next;
        L->next = p;//采用头插法插在L后面
        p = q;//p再取下一个
    }
    return L;
}

方法二

在这里插入图片描述

LinkedList Reverse_2(LinkedList &L) {
    LinkNode* pre, *p = L->next, *r = p->next;
    p->next = NULL;
    while (r != NULL)
    {
        pre = p;
        p = r;
        r = r->next;
        p->next = pre;
    }
    L->next = p;
    return L;
}

上述两个算法的时间复杂度为O(N),空间复杂度为O(1)

最后贴出完整代码

#include <iostream>
#include <stdio.h>

using namespace std;

typedef int ElemType;
typedef struct LinkedNode {
    ElemType data;
    struct LinkedNode* next;

}*LinkedList,LinkNode;

LinkNode* getHead(LinkedList L);
LinkNode* getTail(LinkedList L);

void  InitList(LinkedList &L);
int Length(LinkedList L);
LinkedList List_HeadInsert(LinkedList& L);
LinkedList List_TailInsert(LinkedList& L);
void Print(LinkedList L);
LinkNode * GetElem(LinkedList L,int index);
LinkNode* LocateElem(LinkedList L, ElemType e);
bool InsertLinkNode(LinkedList L, int index, ElemType e);
bool ListNodeDelete(LinkedList L, int index);
LinkedList Reverse_1(LinkedList &L);//单链表的原地逆置
LinkedList Reverse_2(LinkedList& L);
void reverseTravese(LinkedList head);
int main()
{
    LinkedList  L;
    List_HeadInsert(L);
    Print(L);
   /* std::cout << Length(L) << std::endl;
    LinkedList LL;
    List_TailInsert(LL);
    Print(LL);

    LinkNode* p = GetElem(L, 5);
    cout << p->data << endl;

    InsertLinkNode(L, 3, 22);
    Print(L);

    ListNodeDelete(L, 2);
    Print(L);*/

    reverseTravese(L);
    return 0;
}
void  InitList(LinkedList & L) {
    L = (LinkNode*)malloc(sizeof(LinkNode));
    L->data = 0;
    L->next = NULL;
}

int Length(LinkedList L) {
    LinkNode *pt = L->next;
    int length = 0;
    while (pt != NULL)
    {
        length++;
        pt = pt->next;
    }
    return length;
}
LinkedList List_TailInsert(LinkedList& L)
{
    LinkNode* s;
    int x;
     InitList(L);

    scanf_s("%d", &x);
    LinkNode* pt = L;
    while (pt->next != NULL)
    {
        pt = pt->next;//首先找到尾结点，利用边界条件。
    }
    while (x != -1)
    {
        s = (LinkNode*)malloc(sizeof(LinkNode));
        s->data = x;
        pt->next = s;
        pt = s;
        scanf_s("%d", &x);
    }
    pt->next = NULL;//这句代码用来指令尾部结点的next是NULL，要不然容易指向野指针！

    return L;
}
LinkedList List_HeadInsert(LinkedList& L)
{
    LinkNode* s;
    int x;
    InitList(L);//先构造一个空表

    scanf_s("%d", &x);//先读入一个x值
    while (x != -1)// -1作为读取结束的标志，当然也可以用其他标志
    {
        s = (LinkNode*)malloc(sizeof(LinkNode));
        s->data = x;
        s->next = L->next;
        L->next = s;//这两行代码是插入的关键代码，
        //先将L->next赋值给s->next,然后s赋值给L->next;
        scanf_s("%d", &x);
    }
    return L;
}

void Print(LinkedList L)
{
    LinkNode* pt = L->next;
    while (pt->next != NULL)
    {
        std::cout << pt->data << " ";
        pt = pt->next;
    }
    std::cout << pt->data << std::endl;
}
LinkNode* GetElem(LinkedList L, int index)
{
    if (index < 0 || index > Length(L))
    {
        std::cout << "index的值不合法！" << std::endl;
        return NULL;
    }
    if (index == 0)
    {
        return L;
    }
    if (L == NULL)
    {
        return NULL;
    }

    int j = 1;
    LinkNode* pt = L->next;
    while (pt != NULL && j < index)
       // while (pt && j < index)
    {
        pt = pt->next;
        j++;
    }
    return pt;
}
LinkNode* LocateElem(LinkedList L, ElemType e) {
    LinkNode* p = L->next;
    while (p != NULL  && p->data != e)
    {
        p = p->next;

    }
    return p;
}
bool InsertLinkNode(LinkedList L, int index, ElemType e) {
    if (index <= 0 || index > Length(L))
    {
        cout << "index值不合法" << endl;
        return false;
    }
    LinkNode* s;
    if (index == 1)
    {
        s = (LinkNode*)malloc(sizeof(LinkNode));
        s->data = e;
        s->next = L->next;
        L->next = s;
        return true;
    }
    s = (LinkNode*)malloc(sizeof(LinkNode));
    LinkNode* p = GetElem(L, index - 1);
    s->next = p->next;
    p->next = s;
    s->data = e;
    return true;
}
bool ListNodeDelete(LinkedList L, int index) {
    if (index <= 0 || index > Length(L))
    {
        cout << "index值不合法" << endl;
        return false;
    }

    LinkNode* p = GetElem(L, index - 1);

    LinkNode* pnext = p->next;
    p->next = pnext->next;
    free(pnext);
    return true;
}

LinkedList Reverse_1(LinkedList &L)
{
    LinkNode* p = L->next;
    LinkNode* q;
    L->next = NULL;//首先将原有链表置为空！

    while (p != NULL)
    {
        q = p->next;//q首先指向下一个
        p->next = L->next;
        L->next = p;//采用头插法插在L后面
        
        p = q;//p再取下一个
    }
    return L;
}
LinkNode* getHead(LinkedList L) {
    return L;
}
LinkNode * getTail(LinkedList L)
{
    LinkNode* p = L->next;
    while (p->next != NULL)
    {
        p = p->next;
    }
    return p;
}
LinkedList Reverse_2(LinkedList &L) {
    LinkNode* pre, *p = L->next, *r = p->next;
    p->next = NULL;
    while (r != NULL)
    {
        pre = p;
        p = r;
        r = r->next;
        p->next = pre;
    }
    L->next = p;
    return L;
}
void reverseTravese(LinkedList head) {
    LinkedList p = head->next;
    ElemType stack[20];
    int top = -1;
    while (p != NULL)
    {
        stack[++top]= p->data;
        p = p->next;
    }
    while (top != 0)
    {
        cout << stack[top--] << " ";
    }
    cout << stack[0] << endl;
}
努力的算算
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构笔记：单链表
qq_17679843的博客
09-22 157
顺序表 一.顺序储存结构 与对数组的操作类似，并无太大新知识点，顾略去。 二.链式储存结构 单链表的储存不连续，每个储存单元既储存数据元素，又储存后继元素的地址。 因此，节点结构定义 template<typename T> struct Node { T data; Node<T> *next; }; 为了实现基本操作，创建模板 template<typena...
单链表 - 数据结构复习笔记
No1anWan6的博客
11-01 145
数据结构复习笔记-单链表 什么是单链表 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。 构成 链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 特点 链表是以节点的方式来储存数据的 每个节点包括data域，next指向下一个节点 在内存中各节点不一定连续存储 分为带头节点和不带头节点的链表 ...
数据结构-单链表（学习笔记）
YYYJ_BOY的博客
04-26 1452
一、单链表的结点数据类型 typedef int DataType; struct Node { DataTpye data; struct Node *next; //next为指向下一结点的指针 }; 二、初始化单链表 int InitList(Node *&H) { H = new Node; //分配空间，作为头结点 if(!H) { cout<<"...
数据结构学习笔记——单链表
12-21
单链表每一个节点又包含两部分，1是存放数据的变量data，2是存放指向下一个结点的指针next 双向链表每一个节点包含三部分，在单链表的基础上多了一个指向前置节点的prev指针 链表的第一个节点被称为头节点，最后一个...
数据结构学习笔记-单链表
02-16
本学习笔记将聚焦于单链表的概念、操作以及在VS2022环境下如何实现。 单链表是一种线性数据结构，其元素（节点）不是在内存中连续存储的，而是通过指针链接在一起。每个节点包含两部分：数据域和指针域。数据域用于...
单链表.cpp
03-10
C语言数据结构单链表代码学习笔记，可以下载jiaoliuyixia
关于入门单链表的基本操作
04-01
单链表是数据结构中的基础概念，它是线性数据结构的一种形式，由一系列节点（也称为元素或项）组成，每个节点包含数据以及一个指向下一个节点的引用（或称为指针）。在本教程中，我们将深入探讨单链表的基本操作，这...
01-单链表和项目实战笔记
最新发布
07-03
01-单链表和项目实战笔记
【学习笔记】单链表（c语言）
Zero__two_的博客
10-03 591
1.单链表概念 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(s数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 2.链表分类 链表的结构多种多样有三个大分类： 1.单向、双向 2.带头、不带头 3.循环、不循环 而三组之间又可以互相组合，使得链表的结构多达8种，本篇的单链表主要是指单向不带头不循环链表，这也是本篇的重点。 2.1单向链表 单向
单链表初学笔记
fuhang95的博客
01-05 320
没什么好说的,添加头文件和创建单链表的形式 申明定义一个结构体,结构体类型名叫做 struct Node,为了便于理解,这个结构体里面的数据段只用来存储一个最简单的整形数据(data),然后定义一个(struct Node)类型的指针,用于指向后面一个链表元素的地址. 由于我们使用dypedef定义这个结构体类型为Nodelb,后面需要使用(struct Node)类型时就可以直接使用Nodelb #include <stdio.h> #include <stdlib.h> typ
学习笔记-单链表
touteng55的博客
02-07 190
单链表 单链表是由多个节点组成的。它是一种有序的链式存储，也就是在各节点的存储位置不一定相连。同时，单链表分为有头节点和没有头节点，具体通过工作的细节自己选择。而节点由数据和next指针组成。其中，next指针的作用是指向下一个节点。在java中，节点可以表示成一个类class，一些成员变量用来存储数据，比如name，sex等等，而next指针同样表示为一个成员变量，类型为该类。指向下一个类变量。 单链表的增删改查思路 创建单链表 首先需要创建节点类，类成员变量包括需要的数据属性和next指针。我这里创
单链表的C语言实现
Confession 的技术频道
01-23 394
一、单链表的建立 有了动态内存分配的基础，要实现链表就不难了。 所谓链表，就是用一组任意的存储单元存储线性表元素的一种数据结构。 链表又分为单链表、双向链表和循环链表等。我们先讲讲单链表。 所谓单链表，是指数据接点是单向排列的。一个单链表结点，其结构类型分为两部分： 1、数据域：用来存储本身数据 2、链域或称为指针域：用来存储下一个结点地址或者说指向其直接后继的指针。 例： typedef str
单链表详解（学习笔记）
m0_61608863的博客
12-16 1322
链表是一种链式储存结构，在C语言中有着重要的作用。 而在如同我一样的初学者的学习过程中，链表的操作很有难度，故而有必要用博客记录学习过程，分享给大家的同时也自我巩固。 一.链表的概念和定义 相对于线性表，链表有许多优点，例如在线性表中，删除或插入元素的操作很复杂，需要将插入或删除位置的前/后元素不停地移动，倘若涉及到频繁地插入或者删除的操作，链表的优点就凸显出来了。 链表作为一种链式存储结构，其的存储内容除了要存的数据元素信息之外，还储存着后继元素的存储地址。为了表示链表中每一个存储元素a（i...
学习笔记-单链表操作
touteng55的博客
02-07 105
求单链表中有效节点的个数 /** * * @param head 链表的头节点 * @return 返回的就是有效节点的个数 */ public static int getLength(HeroNode head) { if(head.next == null) { //空链表 return 0; } int length = 0; //定义一个辅助的变量, 这里我们没有统计头节点 HeroNode cur = head.next; while(cur != null) { lengt
单链表
学习笔记
08-28 134
单链表 1、链表的创建 由于需要改变主函数头指针的值，所以将头指针的地址传给一个二级指针 int create_list(pnode *head) { if((*head = (pnode)malloc(sizeof(node))) == NULL) { return -1; //失败返回-1 } (*head)-&gt;data = -1; //-1表示头指针不存储内容 (...
数据结构单链表学习笔记
qq_52544734的博客
05-27 334
数据结构上机 单链表 尾插法创建链表 头插法创建链表 销毁链表 求链表长度 求单链表中第i个元素 在第i个节点前插入值为x的节点 在链表中查找元素值为x的节点 删除元素第i个元素节点 在递增有序的单链表l中插入一个值为x的元素保持递增有序 将单链表中的奇数项和偶数项分解开 求递增有序单链表中l1和l2的公共元素 放入新的单链表l3 删除重复元素 递增有序单链表L1、L2，不申请新结点，利用原表结点对2表进行合并，并使得合并后成为一个集合，合并后用L1的头结点作为头结点，删除L2的头结点，要求时间性能最好。
考研复习知识笔记-数据结构
04-16
在考研复习笔记中，这部分内容涵盖了数据结构的核心要素，包括逻辑结构、存储结构和基本运算。 逻辑结构定义了数据元素之间的关系，例如，学生成绩记录可以看作是一个数据元素，它由多个数据项如姓名和性别组成，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

努力的算算

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值