浅谈【数据结构】链表之其他形态

最新推荐文章于 2024-08-24 23:54:19 发布
最新推荐文章于 2024-08-24 23:54:19 发布
阅读量580 收藏 10
点赞数 26
分类专栏： 基础数据结构 文章标签： 数据结构 链表 c语言 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67526434/article/details/141502239
版权

目录

1、带头结点的链表

2、创建步骤

3、循环链表

3.1创建循环链表

3.2循环链表的遍历

3.3链表中的闭环

4、静态链表

4.1静态链表初始化

谢谢帅气美丽且优秀的你看完我的文章还要点赞、收藏加关注

没错，说的就是你，不用再怀疑！！！

希望我的文章内容能对你有帮助，一起努力吧！！！

1、带头结点的链表

引入：链表的操作起来比较舒服，但是如果记录（获取）链表长度比较麻烦。需要遍历链表，一个一个 计数，比较费时间（占CPU资源）

所以可以不可以用一个比较特殊一点的结点来保存链表相关的信息？->头结点

  • 头结点

头节点其实就是一个特殊的结点，它的类型和其他的结点不一样的，它是专门用来存储链表的一些属性 信息。

struct head {

        int length; // 链表长度

        结点类型*first; // 首结点地址

        结点类型*final; // 尾结点地址

};

注意：

  • 头节点不参与链表的长度计数
  • 头节点也是不参与链表遍历
  • 头节点也不会作为链表的结点

带头结点链表，头节点是在链表中存储链表信息的作用。

注意：当对链表进行增删操作的时候需要对头节点进行及时的更新。

2、创建步骤

  • 从无到有
    • 创建一个头结点
  • 从少到多
    • 一个一个正常增加（注意：及时更新头节点的信息）

图示：

***增加节点***

***删除节点(4种情况)***

代码示例：

#include <iostream>

// 结点类型
struct node
{
    int data;
    struct node *next;
};

// 头节点类型
struct head
{
    int length;
    struct node *first;
    struct node *final;
};

/*
    @brief 创建链表
    @return 链表的头节点地址
*/
struct head *createNewList()
{
    // 申请一个空间
    struct head *newList = new struct head;

    // 初始化链表属性信息
    newList->length = 0;
    newList->first  = nullptr;
    newList->final  = nullptr;

    // 返回创建好的链表头节点地址
    return newList;
}

/*
    @brief 头插法增加结点进链表
    @param list 需要增加结点的链表的地址
    @param data 新结点数据
*/
void addNodeHead(struct head*list,int data)
{
    // 先判断链表是否存在
    if(!list)
        return;

    // 申请新结点空间
    struct node *newNode = new struct node;

    // 结点数据的初始化
    newNode->data = data;
    newNode->next = nullptr;

    // 开始头插法
    // 让新节点的next指针指向头节点里面的首结点
    newNode->next = list->first; // list->first 表示首结点地址

    // 更新头结点中首结点（first）和长度
    list->first = newNode; // 让newNode成为新的首结点
    list->length++;// 更新链表长度
}

/*
    @brief 尾插法增加结点进链表
    @param list 需要增加结点的链表的地址
    @param data 新结点数据
*/
void addNodeTail(struct head*list,int data)
{
    // 先判断链表是否存在
    if(!list)
        return;

    // 申请新结点空间
    struct node *newNode = new struct node;

    // 结点数据的初始化
    newNode->data = data;
    newNode->next = nullptr;

    // 进行尾插法增加
    list->final->next = newNode; // list->final 表示尾结点地址

    // 更新头结点中尾结点（final）和长度
    list->final = newNode;
    list->length++;
}


/*
    @brief 删除一个置顶的结点
    @param list 需要删除结点的链表地址
    @param data 需要删除的那个结点的数据
    @return true表示成功，false表示失败
*/
bool delListNode(struct head*list,int data)
{
    // 先判断链表是否存在
    if(!list)
        return;

    // 遍历查找元素
    struct node *node_ptr = list->first;
    // 一个结点的时候
    if(list->first->data == data&&list->length == 1)
    {
        // 直接释放空间
        delete list->first;

        // 更新首尾结点信息
        list->first = nullptr;
        list->final = nullptr;

        list->length--;
        return ;
    }

    // 判断是否为首结点且数量大于1
    if(list->first->data == data&&list->length > 1)
    {
        // 更新首结点
        list->first = node_ptr->next; 
        node_ptr->next = nullptr;
        delete node_ptr;
        list->length--;
        return true;
    }
    while(node_ptr->next)
    {
        // 找到了需要删除的元素
        if(node_ptr->next->data == data)
        {
            // 判断是不是尾结点且数量大于1
            if(node_ptr->next == list->final&&list->length > 1)
            {
                // 更新尾结点
                list->final = node_ptr; 

                // 释放需要删除的元素，再置空
                // 原因：node_ptr并非需要删除的元素，它是被删除元素的前一个元素。
                delete node_ptr->next;
                node_ptr->next = nullptr;
                list->length--;
                return true;
            }
            else if(list->length > 1)
            {
                // 临时存储被删除元素的地址
                struct node *delNode = node_ptr->next;

                // 更新被被删除元素的next指针：实际就是跳过被删除元素
                node_ptr->next = node_ptr->next->next;

                // 断开被删除元素的链接
                delNode->next = nullptr;

                // 释放元素空间
                delete delNode;
                list->length--;
                return ;
            }
        }
    }
}

3、循环链表

循环链表：第一个数据结点和最后一个数据结点相连链表

循环单链表：最后一个数据结点往后就到了第一个数据结点

循环双链表：最后一个数据结点往后就到了第一个数据结点，第一个数据结点往前走就到了最后数据结 点

3.1创建循环链表

3.2循环链表的遍历

用两个指针，一个指针跑，另一个指针不动，当两个指针重叠的时候就跑完了。

代码示例：

#include <iostream>


typedef struct node 
{
    int data;
    struct node *next;
}NodeType;


/*
    @brief 为循环链表增加结点
    @param list 需要增加结点的循环链表
    @param data 新结点数据
*/
NodeType *addNewNode(NodeType *list,int data)
{
    // 如果为空作为第一个结点插入
    if(!list)
    {
        list = new NodeType;
        list->data = data;

        // 自己指向自己，这个就是形成循环的关键了
        list->next = list;
        return list; 
    }
    // 不是第一结点
    NodeType *newNode = new NodeType;
    newNode->data = data;
    newNode->next = nullptr;

    // 如果list指向的是最后加入链表结点(头插/尾插)
    newNode->next = list->next;
    list->next = newNode;

    return newNode;
}


/*
    @brief 创建循环链表
    @return 返回新循环链表的地址
*/
NodeType *createLoopList()
{
    NodeType *loopList = nullptr;

    int data = -1;
    do
    {
        std::cin >> data;
        if(data == -1)
            break;

        // 增加结点
        loopList = addNewNode(loopList,data);
    }while(1);
    return loopList;
}

/*
    @brief 打印循环链表
*/
void PrintLoopList(NodeType *looplist)
{
    if(!looplist)
    {
        std::cout << "空的" << std::endl;
        return;
    }
    
    NodeType *node_ptr = looplist;
    do
    {
        std::cout << node_ptr->data << std::endl;
        node_ptr = node_ptr->next;
    }while(node_ptr != looplist);
}

int main()
{
    NodeType*looplist = createLoopList();

    PrintLoopList(looplist);

    return 0;
}

3.3链表中的闭环

链表的尾结点指向了链表中的任意一个随机的结点

求闭环的算法

  • 使用两个指针
    • 一个移动步数快
    • 一个移动步数慢
  • 如果两者发生重叠 就形成闭环
  • 如果其中一个指针出现空指针的情况 ，就是没有环的

代码示例：

***形成闭环示例***

#include <iostream>


typedef struct node 
{
    int data;
    struct node *next;
}NodeType;


/*
    @brief 为循环链表增加结点
    @param list 需要增加结点的循环链表
    @param data 新结点数据
*/
NodeType *addNewNode(NodeType *list,int data)
{
    // 如果为空作为第一个结点插入
    if(!list)
    {
        list = new NodeType;
        list->data = data;

        // 自己指向自己，这个就是形成循环的关键了
        list->next = list;
        return list; 
    }
    // 不是第一结点
    NodeType *newNode = new NodeType;
    newNode->data = data;
    newNode->next = nullptr;

    // 如果list指向的是最后加入链表结点(头插/尾插)
    newNode->next = list->next;
    list->next = newNode;

    return newNode;
}


/*
    @brief 创建循环链表
    @return 返回新循环链表的地址
*/
NodeType *createLoopList()
{
    NodeType *loopList = nullptr;

    int data = -1;
    do
    {
        std::cin >> data;
        if(data == -1)
            break;

        // 增加结点
        loopList = addNewNode(loopList,data);
    }while(1);
    return loopList;
}

/*
    @brief 打印循环链表
*/
void PrintLoopList(NodeType *looplist)
{
    if(!looplist)
    {
        std::cout << "空的" << std::endl;
        return;
    }
    
    NodeType *node_ptr = looplist;
    do
    {
        std::cout << node_ptr->data << std::endl;
        node_ptr = node_ptr->next;
    }while(node_ptr != looplist);
}

/*
    求闭环的算法
*/
bool IsHaveCircle(NodeType *looplist)
{
    if(!looplist)
        return true;

    
    // 是否有圈
    NodeType *fast = looplist;    // 慢
    NodeType *slow = looplist;    // 快

    // 循环操作
    do
    {
        // 移动指针
        if(fast->next)
            fast = fast->next->next;   // 移动两步
        else  // 如果不能移动表示其中一个next是为空
            return false;
        
        slow = slow->next; // 移动一步

        // 判断有没有为空的指针
        if(!fast||!slow) // 只要任意一个指针为空那么就没有环
            return false;
    }while(fast != slow);

    // 相等退出，就是有环
    return true;
}

int main()
{

    NodeType *looplist = createLoopList();

    if(IsHaveCircle(looplist))
        std::cout << "有环" << std::endl;
    else
        std::cout << "没环" << std::endl;


    // destoryList();
    return 0;
}

***无闭环示例***

/*
    无头结点的单链表
*/



#include <iostream>

/*
    结点类型
*/
typedef struct nodeData
{
    // 用来存储数据的空间（成员）称为：数据域
    int data;       

    // 用来保存其他结点的地址（关系）称为：指针域
    struct nodeData *next;
}NodeType;


/*
    @brief:创建一个新链表
    @return:返回新链表的首结点的地址
*/
struct nodeData *createNewList()
{
    // 新链表的首结点指针
    struct nodeData *newList = nullptr;

    // 循环通过数据不断的去增加新结点到链表中
    while(1)
    {
        int data = -1;
        // 通过键盘获取数据
        std::cin >> data;

        // 判断退出条件
        if(data == -1)
            break;

        // 申请了一个新结点的空间
        struct nodeData *newNode = new struct nodeData;
        newNode->data = data; // 将通过键盘获取到的数据存入结构体的数据域中
        newNode->next = nullptr; // 因为它是一个新结点，暂时是没有后继结点

        // 增加到链表里面:向后增加（尾插法）
        // 做第一次判断：链表中有没有结点
        if(newList == nullptr)
        {
            // 如果newList是nullptr说明该链表里面为空，当前的新节点就是首届点
            newList = newNode;
            continue; // 继续增加新结点
        }

        // 搞一个临时指针，来指向首结点
        struct nodeData *node_ptr = newList;

        // 找尾结点
        while(node_ptr->next)node_ptr = node_ptr->next;
        
        // 到这个位置 node_ptr 此时指向的结点是尾结点
        // 就可以把newNode作为尾结点的后继结点添加到链表里面去了
        node_ptr->next = newNode;
    }
    return newList;
}

// 打印链表（遍历方法）
void printList(struct nodeData *list)
{
    // 判断是不是空链表
    if(list == nullptr)
    {
        std::cout << "链表为空" << std::endl;
        return;
    }

    std::cout << "List( ";
    // 如果不为空打印链表元素
    while(list) // 只要list不为空就一直循环
    {
        // list本来就可以表示首结点
        std::cout << list->data << " ";

        // 让list移动到下一个结点
        list = list->next;
    }
    std::cout << ")" << std::endl;
}


bool IsHaveCircle(NodeType *looplist)
{
    if(!looplist)
        return true;

    
    // 是否有圈
    NodeType *fast = looplist;    // 慢
    NodeType *slow = looplist;    // 快

    // 循环操作
    do
    {
        // 移动指针
        if(fast->next)
            fast = fast->next->next;   // 移动两步
        else  // 如果不能移动表示其中一个next是为空
            return false;
        
        slow = slow->next; // 移动一步

        // 判断有没有为空的指针
        if(!fast||!slow) // 只要任意一个指针为空那么就没有环
            return false;
    }while(fast != slow);

    // 相等退出，就是有环
    return true;
}


int main()
{
    // 不在栈空间里面申请结点空间
    // 创建一个链表
    struct nodeData *newList = createNewList();

    // 打印链表元素
    printList(newList); // 传入的值是newList存储的地址，并非newList自己的地址
    
    if(IsHaveCircle(newList))
        std::cout << "有环" << std::endl;
    else
        std::cout << "没环" << std::endl;

    return 0;
}

4、静态链表

静态链表是一种使用数组来实现链表概念的数据结构。它通过在每个元素中存储下一个元素的索引来实 现链式存储，从而在有限的空间内实现对大量元素的有效管理。

普通链表

struct node {

        int data;

        struct node *next;

}; // 结点

静态链表

struct node {

        int data;

        int next; // 不是指针，而是下标

};

struct node static_list[100]={0};

4.1静态链表初始化

for(int i = 0;i < 100;i ++)

{

        static_list[i].data = i+1;

        if(i!=99)

                static_list[i].next = i+1;

        else

                 static_list[i].next = -1; // 下标不会出现-1

}

插入元素

// 尾插法

int i = 0;

for(i < 100;i++)

if(static_list[i].next == -1)

        break;

// 找空位

for(int l = 0; l < 100;l++)

{

         if(static_list[l] == NULL)

         {

                static_list[l] = newNode;

                static_list[i].next = l;

        }

}

注意事项：

  • 静态链表是一种在内存空间有限时使用的数据结构。
  • 使用数组和指针来实现链表的功能。
  • 初始化静态链表时，需要正确设置每个节点的 data 和 next 指针。
  • 在向静态链表添加元素时，需要检查是否已满。
  • 访问静态链表元素时，要确保索引有效。
  • 静态链表的大小是固定的，因此在设计时需要合理估计最大元素数量。

代码实例：

#include <iostream>

struct node
{
    int data;   // 数据
    int next_index; // 下标
};

#define MAXLEN 20


void addNode(struct node *staticlist[],int data)
{
    // 插入元素
    if(staticlist[0] == nullptr)
    {
        staticlist[0] = new struct node;
        staticlist[0]->data = 1;
        staticlist[0]->next_index = -1;
        return;
    }

    std::cout << __LINE__ << std::endl;

    // 找尾元素插入
    int pos = 0; // 第一个
    while(1)
    {
        if(staticlist[pos]->next_index == -1)
            break;
        pos = staticlist[pos]->next_index;
    }
    
    // 找到尾元素了
    int newPos = 0;
    while(staticlist[newPos] != nullptr)newPos++;

    // 将新结点加入
    staticlist[newPos] = new struct node;
    staticlist[newPos]->data = data;
    staticlist[newPos]->next_index = -1;

    staticlist[pos]->next_index = newPos;
}

int main()
{
    // 新建一个静态链表
    struct node *staticlist[MAXLEN] = {0};

    for(int i = 0;i < 10;i++)
        addNode(staticlist,i+2);

    // 正常打印
    for(int i = 0;i < MAXLEN;i++)
        std::cout << staticlist[i] << " ";
    std::cout << std::endl;

    int pos = 0;
    // 链表遍历形式打印
    do
    {
        std::cout << staticlist[pos]->data << " ";
        pos =staticlist[pos]->next_index;
    } while (pos != -1);
    std::cout << std::endl;

}

超级飞侠12138
关注
  • 26
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈iOS 数据结构之链表
08-29
链表作为基础的数据结构之一，对于提升程序效率有显著作用。本文将深入探讨链表的概念，特别是单链表和双链表，并提供Objective-C实现的示例。 链表是一种数据结构，它由一系列节点组成，每个节点包含数据以及指向...
浅谈PHP链表数据结构(单链表)
12-18
链表是一种重要的数据结构，它不同于数组，数组中的元素在内存中是连续存储的，而链表中的元素在内存中可以分散存储。链表的主要优势在于它的灵活性，它允许高效地插入和删除元素，因为这些操作只需要改变节点的引用...
浅谈数据结构
zhou_yue999的博客
08-30 158
数据结构 栈 栈（stack），它是一种运算受限的线性表,后进先出（LIFO）； LIFO表示就是后进入的元素， 第一个弹出栈空 间. 类似于自动餐托盘, 最后放上的托盘, 往往先把拿出去使用. 其限制是仅允许在表的一端进行插入和删除运算。这一端被称 为栈顶，相对地，把另一端称为栈底。 向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素 放到栈顶元素的上面，使之成为新的栈顶元素； 从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除 掉，使其相邻的元素成为新的栈顶元素。 栈实现 //类-栈封装 fun
浅谈数据结构-树
chuanao8829的博客
06-22 166
树是一种数据结构，其中一个元素可以有两个或者多个数据元素，具有一对多的特点，用树结构来存储文件。 树的概念 结点的度：子结点的个数。例如结点1中有3个子结点，结点1的度是3. 树的度：树的度等于所有结点度中度最高的值。结点最高的度为3，树的度为3. 叶子结点：度为0...
浅谈HashMap
qq_43649799的博客
10-06 569
这不是最近大四要开始找工作了嘛，我就仔细看了看HashMap的一些原理，今天就写在CSDN上跟大家分享一下，也算给自己加深一下印象 1、HashMap的概述 HashMap基于Map接口实现，元素以键值对的方式存储，并且允许使用null 建和null值，因为key不允许重复，因此只能有一个键为null,另外HashMap不能保证放入元素的顺序，它是无序的，和放入的顺序并不能相同。 2、HashMap的底层数据结构 1、在jdk 1.8之前 HashMap是数组+链表的数据结构，链表就是用来解决哈希冲突的，所
数据结构中的树
jiangjunyuan168的博客
12-04 959
介绍 相比于数组、链表、哈希表，不能说树结构比它们的结构要好，因为每一种数据结构都有自己特定的应用场景。但是树结构确实也综合了这些的数据结构的优点（当然优点不足以盖过其他数据结构，比如效率一般情况下没有哈希表高），并且弥补了这些数据结构的缺点。 为了模仿某些场景，我们使用树结构会更加的方便。比如：文件的目录结构。因为树结构是非线性的，可以表示一对多的关系。 术语 为了更好的了解树结构，我们还需要对树结构的术语进行了解： 节点的度（Degree）：节点的子数个数。 树的度：树的所有节点中最大的度数。 叶节点
Python数据结构之链表实现
02-27
1.使用Python语言实现链表数据结构 2.基于类封装思想 3.实现链表增删改查功能 4.有测试数据
数据结构之并查集
我要学编程的博客
08-21 1181
并查集相关概念、模拟实现并查集、并查集的应用：省份的数量、等式方程的可满足行
【Java & 数据结构】初识二叉树
qq_42150700的博客
08-20 682
树是一种非线性的数据结构, 也就是说它和我们前面学习的顺序表链表之类的不太一样. 那些数据结构要求中间的元素都只有一个前驱和后继, 而树型结构的中间元素则允许有多个后继.例如下面这个就是一个树形结构为什么叫这种结构为树形结构呢?这是因为它的结构长的就像一颗倒过来的树, 最上面是树根, 最下面则是叶子.下面我们看几个例子, 来认识一下树形结构的注意点下面的这个结构, 就不是一个树形结构, 原因是其中间在同一层的节点, 是不可以相连的, 中间的节点只允许和上层节点和下层节点进行连接.
数据结构（邓俊辉）学习笔记】优先级队列 06——完全二叉堆：批量建堆
weixin_44399845的博客
08-18 898
完全二叉堆：批量建堆
Leetcode每日刷题之1658.将x减到0的最小操作数(C++)
2301_80689220的博客
08-21 230
【代码】Leetcode每日刷题之1658.将x减到0的最小操作数(C++)
二叉树(源码+lw+部署文档+讲解等)
lpw1012的博客
08-21 725
🌞博主介绍：✌全网粉丝15W+,CSDN特邀作者、211毕业、高级全栈开发程序员、大厂多年工作经验、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注于Java、小程序技术领域和毕业项目实战，以及程序定制化开发、全栈讲解、就业辅导✌🌞👇🏻精彩专栏 推荐订阅👇🏻2023-2024年最值得选的微信小程序毕业设计选题大全：100个热门选题推荐✅2023-2024年最值得选的Java毕业设计选题大全：500个热门选题推荐✅Java精品实战案例《500套》
【冒泡排序算法】输入n个数进行排序
最新发布
qq_64108165的博客
08-24 371
输入n个数进行排序，使用冒泡排序算法
数据结构-栈与队列-数组和链表的推广运用-第六天
qq_33867768的博客
08-24 410
总结： 1. 栈是一种先入后出的数据结构，类似于“铁饼堆叠游戏”。2. 队列是一种先入先出的数据结构，类似于“数据进入不能回头的管道”。
数据结构-堆(二叉树的特殊)-第四天
qq_33867768的博客
08-21 212
堆是一棵完全二叉树，根据成立条件可分为大顶堆和小顶堆。大（小）顶堆的堆顶元素是最大（小）的。堆（Heap）是一种特殊的完全二叉树数据结构，通常用于实现优先队列。它是一种完全二叉树，除了最后一层外，每一层都是完全填充的。最后一层的所有节点都尽可能地靠左排列。堆中的每个节点的值与其子节点的值之间有一定的关系，这取决于堆的类型。堆是一种高效的数据结构，通常用于实现优先队列和排序算法。
【数据结构-前缀异或和】1442. 形成两个异或相等数组的三元组数目
sjsjs11的博客
08-20 449
首先第一个哈希表cnt是用来在遍历k，计算k+1的前缀异或和的时候，是否有对应的 i 的前缀异或和一样。那么在遍历 k 的时候，就可以根据当前的前缀异或和来查找之前相同前缀异或和的个数cnt[s ^ val]。解释：满足题意的三元组分别是 (0,1,2), (0,2,2), (2,3,4) 以及 (2,4,4)输入：arr = [7,11,12,9,5,2,7,17,22]输入：arr = [2,3,1,6,7]输入：arr = [1,1,1,1,1]输入：arr = [1,3,5,7,9]
数据结构-树(二叉树)-第三天
qq_33867768的博客
08-21 329
二叉树（binary tree）是一种非线性数据结构，代表“祖先”与“后代”之间的派生关系，体现了“一分为二”的分治逻辑。与链表类似，二叉树的基本单元是节点，每个节点包含值、左子节点引用和右子节点引用。/* 二叉树节点结构体 */int val;// 节点值// 左子节点指针// 右子节点指针每个节点都有两个引用（指针），分别指向左子节点（left-child node）和右子节点（right-child node），该节点被称为这两个子节点的父节点（parent node）。
数据结构（Java）：揭开二叉搜索树删除机制的奥秘
2401_83595513的博客
08-19 2423
二叉搜索树的模拟实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值