数据结构与算法之美【5】-链表

已于 2022-09-19 23:14:17 修改
阅读量295 收藏
点赞数
分类专栏： 《数据结构与算法之美》读书笔记 文章标签： 数据结构 单链表 单向循环链表 双向链表 双向循环链表
于 2021-03-12 23:35:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Chiang2018/article/details/114710613
版权

关于链表，首先我们要了解它和数组的一个最大区别：数组需要一块连续的内存空间来存储，而链表恰恰相反，它通过“指针”将一组零散的内存块串联起来使用。而且因为在对链表执行插入和删除操作时无需保持内存数据的连续性，而仅仅是修改一下指定节点的next指针指向，所以对应的时间复杂度是 O(1)，但是因为它不支持随机访问，只能通过节点的next指针进行遍历，所以随机访问的时间复杂度是O(n)。

链表结构五花八门，今天重点介绍四种最常见的链表结构：单链表、双向链表、循环链表以及双向循环列表。

目录

一、单链表

二、循环链表

三、双向链表

（1）删除结点中“值等于某个给定值”的结点

（2）删除给定指针指向的结点

四、双向循环链表

五、代码示例

 1、单向不循环链表

2、双向循环链表

一、单链表

为了将所有的结点串起来，单链表的每个结点除了存储数据之外，还需要记录单链表上的下一个结点的位置。我们把这个记录下个结点位置的指针叫作后继指针 next。

从上面的单链表图中，可以明显看出，其中有两个结点是比较特殊的，它们分别是第一个结点和最后一个结点，即头结点和尾结点，其中，头结点用来记录链表的首地址，有了它，我们就可以遍历得到整条链表。而尾结点特殊的地方在于next指针指向的下一个结点位置为空地址 NULL，表示这是链表的结尾。

二、循环链表

循环链表很简单。它跟单链表唯一的区别就是循环链表的尾结点的指针不再指向空地址，而是指向链表的头结点。由此生成循环，如下图：

三、双向链表

单向链表和循环链表都只有一个方向，即只能通过结点的后继指针 next 获取后面的结点。而双向链表则不同，顾名思义，它支持两个方向，每个结点不仅仅有一个后继指针 next ，还有一个前驱指针 prev 指向其前面的结点。

相对于单向链表，虽然双向链表占用的内存更多(多存储了一个前驱指针)，但它的插入和删除操作的效率却有明显提升。

可能这里会有些疑问，本篇开头的位置明明写着链表的插入和删除的时间复杂度都是O(1)，双向链表的效率还咋提升呢？这里请注意，前面说的时间复杂度都是指的是赋值操作，忽略了其查询的过程，而双向链表的效率提升就体现在其查询过程，下面我们将查询过程也统计下来，重新计算一下复杂度，以删除操作为例：

（1）删除结点中“值等于某个给定值”的结点

对于这种情况，不管是单链表还是双向链表，时间复杂度是一样的，都是O(n)。为了查找到值等于给定值的结点，都需要从头结点开始一个一个依次遍历对比，直到找到值等于给定值的结点，然后再通过我前面讲的指针操作将其删除。尽管单纯的删除操作时间复杂度是 O(1)，但遍历查找的时间是主要的耗时点，对应的时间复杂度为 O(n)。根据时间复杂度分析中的加法法则，删除值等于给定值的结点对应的链表操作的总时间复杂度为 O(n)，即不管是单链表还是双向链表，在这种情况下，时间复杂度都是O(n)。

（2）删除给定指针指向的结点

对于这种情况，我们已经知道了要删除的结点，假设为q，删除q 需要知道其前驱结点p，将前驱结点的nex指针指向q的后驱结点，即可完成删除，但单链表并不支持直接获取前驱结点，所以为了找到前驱结点，我们还是要从头结点开始遍历链表，直到 p->next==q，此时单项链表的复杂度为O(n)。但是对于双向链表来说就很简单了，因为双向链表中的结点已经保存了指向前驱结点的指针pre，无需再去遍历。所以，此时双向链表的时间复杂度为 O(1)。

四、双向循环链表

双向循环链表仅仅是修改了双向链表最后一个结点的next指针使其指向链表头部，其他的和双向链表完全没有任何区别。

五、代码示例

 1、单向不循环链表

// 单链表.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <stdlib.h>
#include <iostream>

template <class T>
class Node
{
public:
    T data;
    Node(T& item);
    Node<T>* next;
};

template<class T>
class LinkList
{
public:
    LinkList();
    ~LinkList();
    int getSize(void);
    bool IsEmpty(void);
    int gotoNext(void);
    int getPostion(void);
    int InsertNode(T& data);
    int DeleteNode(void);
    void getCurrNodeData(T& data);
    void setCurrNodeData(T& data);
    void clear();
    void print();

private:
    Node<T>* head;
    Node<T>* currNode;
    int size;
    int position;
    void freeNode(Node<T>* p);
};

/* 链表节点构造函数 */
template <class T>
Node<T>::Node(T& item)
{
    data = item;
    next = NULL;
}

/* 链表构造函数 */
template <class T>
LinkList<T>::LinkList()
{
    head = NULL;
    currNode = NULL;
    size = 0;
    position = -1;
}

/* 链表析构函数 */
template <class T>
LinkList<T>::~LinkList()
{
    clear();
}

/* 获取链表长度 */
template <class T>
int LinkList<T>::getSize(void)
{
    return size;
}

/* 判断链表是否为空 */
template <class T>
bool LinkList<T>::IsEmpty(void)
{
    return size==0?true:false;
}

/* 移动到下个节点，返回下个节点的位置值 */
template <class T>
int LinkList<T>::gotoNext(void)
{
    if(NULL == head)
    {
        return -1;
    }

    if(NULL == currNode)
    {
        return -1;
    }
    else
    {
        currNode = currNode->next;
        position++
    }

    return position;
}

/* 获取当前节点的位置 */
template <class T>
int LinkList<T>::getPostion(void)
{
    return position;
}

/* 在当前节点前插入新节点 */
template <class T>
int LinkList<T>::InsertNode(T& data)
{
    Node<T>* p = new Node<T>(data);

    if(0 == size)
    {
        head = p;
        head->next = NULL;
        currNode = p;
        
    }
    else
    {
        p->next = currNode->next;
        currNode->next = p;
        currNode = p;
    }

    size++;
    position++;
    return size;
}


/* 删除当前节点 */
template <class T>
int LinkList<T>::DeleteNode(void)
{
    if(0 == size)
    {
        return -1;
    }
    
    Node<T>* p = head;
    Node<T>* tmp;
    for(int i = 0;i < size;i++)
    {
        if(NULL == p)
        {
            return -1;
        }

        if(p->next == currNode)
        {
            p->next = currNode->next;
            break;
        }

        p = p->next;
    }

    tmp = currNode;

    if(currNode == head)
    {
        head = currNode->next;
    }

    if(NULL == currNode->next)
    {
        position--;
        currNode = p;
    }
    else
    {
        currNode = currNode->next;
    }
    

    freeNode(p);
    size--;
    if(0 == size)
    {
       position = -1;
    }

    return 0;
}

/* 释放指定节点的内存 */
template <class T>
void LinkList<T>::freeNode(Node<T>* p)
{
    if(!p)
    {
        delete p;
    }

    return;
}

/* 获取当前节点的数据 */
template <class T>
void LinkList<T>::getCurrNodeData(T& data)
{
    if(currNode)
    {
        data = currNode->data;
    }

    return ;
}

/* 修改当前节点的数据 */
template <class T>
void LinkList<T>::setCurrNodeData(T& data)
{
    if(currNode)
    {
        currNode->data = data;
    }

    return ;
}

/* 清空链表 */
template <class T>
void LinkList<T>::clear()
{
    if(0 == size)
    {
        return;
    }

    Node<T>* p = head;
    Node<T>* tmp = head->next;
    while(p)
    {
        freeNode(p);
        p = tmp;
        if(tmp)
        {
            tmp = tmp->next;
        }
    }

    head = NULL;
    currNode = NULL;
    size = 0;
    position = -1;

    return;
}

template <class T>
void LinkList<T>::print()
{
    if(0 == size)
    {
        return;
    }

    Node<T>* p = head;
    Node<T>* tmp = head->next;
    while(p)
    {
        std::cout<<p->data<<std::endl;
        p = tmp;
        if(tmp)
        {
            tmp = tmp->next;
        }
    }

    return;
}

int main(int argc, _TCHAR* argv[])
{
    int a = 10,b=20,c=30,d=40,e=50;
    LinkList<int> list;
    list.InsertNode(a);
    list.InsertNode(b);
    list.InsertNode(c);
    list.DeleteNode();
    list.InsertNode(d);
    list.InsertNode(e);
    list.print();
    std::cin.get();
	return 0;
}

2、双向循环链表

#include <iostream>
#include <stdlib.h>

#include "stdafx.h"



template <class T>
class Node
{
public:
    T data;
    Node(T& item);
    Node<T>* next;
    Node<T>* pre;
};

template<class T>
class LinkList
{
public:
    LinkList();
    ~LinkList();
    int getSize(void);
    bool IsEmpty(void);
    int gotoNext(void);
    int setPostion(int pos);
    int getPostion(void);
    int InsertNodeBefore(T& data);
    int InsertNodeAfter(T& data);
    void DeleteNode(void);
    void getCurrNodeData(T& data);
    void setCurrNodeData(T& data);
    void clear();
    void print();

private:
    Node<T>* head;
    Node<T>* currNode;
    int size;
    int position;
    void freeNode(Node<T>* p);
};

/* 链表节点构造函数 */
template <class T>
Node<T>::Node(T& item)
{
    data = item;
    next = NULL;
    pre = NULL;
}

/* 链表构造函数 */
template <class T>
LinkList<T>::LinkList()
{
    head = NULL;
    currNode = NULL;
    size = 0;
    position = -1;
}

/* 链表析构函数 */
template <class T>
LinkList<T>::~LinkList()
{
    clear();
}

/* 获取链表长度 */
template <class T>
int LinkList<T>::getSize(void)
{
    return size;
}

/* 判断链表是否为空 */
template <class T>
bool LinkList<T>::IsEmpty(void)
{
    return size==0?true:false;
}

/* 移动到下个节点，返回下个节点的位置值 */
template <class T>
int LinkList<T>::gotoNext(void)
{
    if(NULL == head)
    {
        return -1;
    }

    if(NULL == currNode)
    {
        return -1;
    }
    else
    {
        currNode = currNode->next;
        position = (position+1+1)%(size);
    }

    return position;
}

/* 将当前节点移动到指定节点值 */
template <class T>
int LinkList<T>::setPostion(int pos)
{
    if(pos >= size||pos < 0)
    {
        return -1;
    }

    position = 0;
    currNode = head;

    for(int i = 0; i < pos;i++)
    {
        position++;
        currNode = currNode->next;
    }

    return position;
}

/* 获取当前节点的位置 */
template <class T>
int LinkList<T>::getPostion(void)
{
    return position;
}

/* 在当前节点前插入新节点 */
template <class T>
int LinkList<T>::InsertNodeBefore(T& data)
{
    Node<T>* p = new Node<T>(data);

    if(0 == size)
    {
        head = p;
        head->next = head;
        head->pre = head;
        currNode = head;
        position++;
    }
    else
    {
        currNode->pre->next = p;
        currNode->pre = p;
        p->next = currNode;
        p->pre = currNode->pre->next; 

        if(head == currNode)
        {
            head = p;
        }
        currNode = p;
    }

    size++;

    return size;
}

/* 在当前节点后插入新节点 */
template <class T>
int LinkList<T>::InsertNodeAfter(T& data)
{
    Node<T>* p = new Node<T>(data);

    if(0 == size)
    {
        head = p;
        head->next = head;
        head->pre = head;   
        currNode = p;
    }
    else
    {
        currNode->next->pre = p; 
        p->next = currNode->next ;
        currNode->next = p;
        p->pre = currNode; 
        currNode = p;
    }

    size++;
    position++;
    return size;
}

/* 删除当前节点 */
template <class T>
void LinkList<T>::DeleteNode(void)
{
    if(0 == size)
    {
        return;
    }

    Node<T>* p = currNode;

    currNode->pre->next = currNode->next;
    currNode->next->pre = currNode->pre;
    if(head == currNode)
    {
        head = currNode->next;
    }

    currNode = currNode->next;
    freeNode(p);
    size--;

    return ;
}

/* 释放指定节点的内存 */
template <class T>
void LinkList<T>::freeNode(Node<T>* p)
{
    if(!p)
    {
        delete p;
    }

    return;
}

/* 获取当前节点的数据 */
template <class T>
void LinkList<T>::getCurrNodeData(T& data)
{
    if(currNode)
    {
        data = currNode->data;
    }

    return ;
}

/* 修改当前节点的数据 */
template <class T>
void LinkList<T>::setCurrNodeData(T& data)
{
    if(currNode)
    {
        currNode->data = data;
    }

    return ;
}

/* 清空链表 */
template <class T>
void LinkList<T>::clear()
{
    Node<T>* p = currNode;

    for(int i = 0;i < size;i++)
    {
        p = p->next;
        freeNode(currNode);
        currNode = p;
    }

    head = NULL;
    currNode = NULL;
    size = 0;
    position = -1;

    return;
}

template <class T>
void LinkList<T>::print()
{
    Node<T>* p = head;

    for(int i = 0;i < size;i++)
    {
        std::cout<<"data = "<<p->data<<std::endl;
        p = p->next;
    }

    std::cout<<"====================================== "<<std::endl;
    return;
}

int main(int argc, _TCHAR* argv[])
{
    int a = 10,b=20,c=30,d=40,e=50;

    LinkList<int> linklist;
    
    linklist.InsertNodeAfter(a);
    linklist.InsertNodeAfter(b);
    linklist.InsertNodeAfter(c);
    linklist.InsertNodeAfter(d);
    linklist.InsertNodeAfter(e);
    linklist.print();

    std::cin.get();
	return 0;
}

运行结果为：

这里写图片描述

Chiang木
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
链表
m0_37145844的博客
10-12 427
定义 链表通常跟数组对比来讲，最大不同从底层的存储结构上：数组需要连续的内存空间，对内存的要求比较高。而链表恰恰相反，它并不需要一块连续的内存空间，它通过“指针”将一组零散的内存块串联起来。 链表种类 单链表 头节点 尾节点，尾节点的next指针指向null。 双向链表 每个节点相比单链表都多存储了一个前驱指针，比较耗费内存。但是比单链表更便捷的插入和删除操作（单项链表插入和删除需要...
数据结构与算法 c语言 线性表-静态链表
最新发布
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
单链表-LinkList
iteye_14363的博客
05-16 179
数据结构单链表-LinkList 参考书：《数据结构（C语言）》作者：严蔚敏 文中的LinkList无头结点。 如果发现错误，请帮忙指正，谢谢。 转载请注明@author vaneng LinkList.h [code="c"] /*单链表*/ typedef int ElemType; typedef struct LNode{ ElemType data...
删除单链表中指针q指向的结点
hhhlizhao的博客
12-28 3948
题目：有一个非空单链表list，每个结点中存放一个整型数据。 指针q指向链表中某一个结点，编写函数delLink，删除q指向的结点。 链表定义如下： typedef struct node { ElemType data; //数据域 struct node *next; //指针域 }LNode, *LinkList; 分析：
链表学习总结
guoquanqin的博客
03-13 644
1、链表的分类 单链表、双向链表和循环链表 单向链表只有一个方向，结点只有一个后继指针 next 指向后面的结点。而双向链表，顾名思义，它支持两个方向，每个结点不止有一个后继指针 next 指向后面的结点，还有一个前驱指针 prev 指向前面的结点。 循环链表是一种特殊的单链表，循环链表的优点是从链尾到链头比较方便。当要处理的数据具有环型结构特点时，就特别适合采用循环链表。 2、删除、插入操作 删除操作 在实际的软件开发中，从链表中删除一个数据无外乎这两种情况： 删除结点中“值等于
【数据结构】数组 VS 链表
weixin_72504310的博客
09-07 1002
数组 VS 链表
【数据结构与算法 - 链表】
04-18
【数据结构与算法 - 链表】 C语言实现 实现模块化
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
cailingling721#data-structures-and-algorithms#数据结构和算法-链表实战-环形链表I
07-25
链表实战题目4 - 链表入环的第一个节点给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。为了表示给定链表中的环，我们使用整数 pos
数据结构与算法之美.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
04 | 链表（上）：如何实现LRU缓存淘汰算法?
weixin_34406086的博客
10-03 210
今天我们来聊聊“链表（Linked list）”这个数据结构。学习链表有什么用呢？为了回答这个问题，我们先来讨论一个经典的链表应用场景，那就是+LRU+缓存淘汰算法。 缓存是一种提高数据读取性能的技术，在硬件设计、软件开发中都有着非常广泛的应用，比如常见的+CPU+缓存、数据库缓存、浏览器缓存等等。 缓存的大小有限，当缓存被用满时，哪些数据应该被清理出去，哪些数据应该被保留？这就需...
链表与内存块
AI与算法都要通俗易懂
03-29 1189
项目原因从来没有接触过链表，今天花了半天的时间研究了下链表，发现用的是二级指针，又研究了下二级指针，编写了几个链表小程序，将收获整理如下。 链表与内存块 链表实际上就是把一块块的内存通过指针连接起来。这些内存有可能是在物理地址上连续的，也有可能是不连续的，不过这不重要，因为在链表中有指针把这些地址连接起来。所以我们可以把链表看成是多个内存块的连接，就如同一根绳上栓了好多蚂蚱，虽然蚂蚱本身没...
链表到底比较占用空间还是节省空间
m0_48198797的博客
07-21 2631
链表到底比较占用空间还是节省空间 从两个角度来分析: 单从数据存储来说，顺序表(如数组)只需要存储 数据，而链表每个节点除了存储数据外还需要存储下一个节点地址(也就是指向)，所以说从这个角度来说链表是比较占用空间的； 单从空间分配来讲，顺序表必须一开始就分配好连续的空间，可能空间有剩余造成浪费，而链表则不会出现这种情况，链表是有几个节点就有几个值，用到了再分配，不会造成空间浪费，起到了节省空间的作用。 ...
使用链表管理内存
liuguangsh的博客
07-28 1829
使用链表管理内存的使用，这儿重新定义了 malloc,realloc,free函数，使用了mymalloc,myrealloc,myfree自己重定义了函数 mem.h #include #include void * mymalloc(size_t size); void *myrealloc(void *p, size_t size); void myfree(void *p)
链表中的节点占多大内存空间
张亮校的专栏
02-28 1883
为了让我记住这一点,因此写下来.是占用一个地址空间大小,32位机上是4个字节.
数据结构与算法约瑟夫环之循环链表
12-03
循环链表是一种特殊的链表，它的最后一个节点指向头节点，形成一个环。约瑟夫环问题是一个经典的问题，它的描述是：n个人围成一圈，从第k个人开始报数，报到m的人出圈，然后从出圈的下一个人开始重新报数，直到所有人出圈。这个问题可以使用循环链表来解决。 具体实现思路如下1. 创建一个单向循环链表，链表中每个节点存储一个人的密码和顺序。 2. 从第k个人开始，依次遍历链表，直到找到第m个人，将该节点从链表中删除。 3. 重复步骤2，直到链表中只剩下一个节点，返回该节点的顺序即可。 以下是Python代码实现： ```python class Node: def __init__(self, password, order): self.password = password self.order = order self.next = None def josephus(n, k, m): # 创建循环链表 head = Node(0, 0) cur = head for i in range(1, n+1): cur.next = Node(i, i) cur = cur.next cur.next = head.next # 从第k个人开始报数，直到找到第m个人并删除 cur = head.next while cur.next != cur: for i in range(k-1): cur = cur.next for i in range(m-1): cur = cur.next print("出列的人的顺序为：", cur.next.order) cur.next = cur.next.next # 返回最后一个节点的顺序 return cur.order # 测试 n = 7 k = 3 m = 4 print("最后一个出列的人的顺序为：", josephus(n, k, m)) ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Chiang木

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

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

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

打赏作者

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

抵扣说明：

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

余额充值