【C/C++ 数据结构】-链表（OJ题）（4）

已于 2023-03-03 02:10:44 修改
阅读量671 收藏 6
点赞数 10
分类专栏： 【C/C++ 数据结构与算法理解及刷题】 文章标签： 链表 数据结构 leetcode
于 2022-09-16 12:41:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63979882/article/details/126848243
版权
本文详细介绍了四种链表操作：反转链表、找到链表中间节点、合并两个有序链表，以及环形链表的检测与定位入环点。对于环形链表，通过快慢指针法证明了不同步速指针在环内一定能相遇，并分析了不同步速下的相遇条件。此外，还探讨了环形链表II的解决方案，证明了相遇点和入环点的关系。
摘要由CSDN通过智能技术生成

文章目录

题一：反转链表

链接：
LeetCode206.反转链表

法1：指针反向

说明：将指针的方向反向，在原链表的头前加上NULL

//法一：指针反向
struct ListNode* reverseList(struct ListNode* head)
{
    //1、原链表为：[]
    if(head == NULL)
    {
        return NULL;
    }
    //2、原链表只有一个节点
    else if(head->next == NULL)
    {
        return head;
    }//注意点1：这前两步可以合并，直接return head;
    //3、有两个及以上节点
    else
    {
        struct ListNode* prev = head;
        struct ListNode* next = head->next;
        struct ListNode* flag = next->next;
        //注意点2：原链表的头变成新链表的尾，尾->next = NULL
        prev->next = NULL;

        //注意点3：退出while时：flag=NULL, next是原链表最后一个节点，但还没连接在新链表上
        while(flag! = NULL || next->next! = NULL)
        {
            next->next = prev;
            prev = next;
            next = flag;

            //注意点4：用标记指针找下一位
            flag = flag->next;
        }
        //注意点5：连接原链表尾节点到新链表
        next->next = prev;

        //注意点6：退出循环后flag=NULL，next指向最后一个节点
        return next;
    }
}

法2：指针翻转

说明：以每个节点为中心将指针全部翻转，在原链表的头前面加上NULL

//法二：指针翻转
struct ListNode* reverseList(struct ListNode* head)
{
    //1、原链表为：[]
    if(head == NULL)
    {
        return NULL;
    }
    //2、原链表有一个及以上节点
    //注意点1：next和flag前面也加*，否则这两个就变成结构体，而不是结构体指针
    struct ListNode* prev = NULL, *next = head, *flag = next->next;
    
    //注意点2：退出循环时，next=NULL，flag=NULL
    //且法二比法一多执行一次循环，最后一个节点已经接入新链表
    while(next!=NULL)
    {
        //注意点3：第一次执行时prev=NULL，所以已经将原链表的头改为新链表的尾
        next->next = prev;
        prev = next;
        next = flag;

        //注意点4：记录原链表下一位，
        if(flag!=NULL)
        {
            flag=flag->next;
        }
    }
    
    //注意点5：退出循环后，next=NULL,prev指向最后一个节点
    return prev;
}

法3：头插法

说明：用newhead去拼接，把原链表节点一个一个拿出来插在newhead前面

//法二：头插法
struct ListNode* reverseList(struct ListNode* head)
{
    //注意点1：这里的newHead相当于法二中的prev, cur相当于next, next相当于flag
    struct ListNode* newHead = NULL;
    struct ListNode* cur = head;

    //注意点2：退出循环后cur=NULL, 和指针翻转相似
    while(cur!=NULL)
    {
        //注意点3：next和while里的条件对应
        struct ListNode* next = cur->next;

        cur->next = newHead;
        newHead = cur;
        cur = next;
    }
    
    //注意点4：退出循环后，cur=NULL,newHead是原链表最后一个节点,且已经连接到新链表
    return newHead;
}

说明：

  • 这三个方法共性：
    1、都有三个指针
    2、第一第二个指针操作链表的指向
    3、第三个指针记录原链表向后找

题二：链表的中间节点

链接：
LeetCode876.链表的中间节点

法1：统计节点减半法

//法一：统计节点减半法
struct ListNode* middleNode(struct ListNode* head)
{
    struct ListNode* cur = head;

    //1、统计节点个数
    int count = 1;
    while(cur->next!=NULL)
    {
        cur=cur->next;
        count++;
    }

    //2、查找中间节点
    count /= 2;
    cur = head;
    while(count>0)
    {
        cur=cur->next;

        count--;
    }

    //3、返回中间节点
    return cur;
}

法2：快慢指针法

说明：用快慢指针遍历一遍，slow指针即为中间节点。
规则：fast=slow=head，fast每次走两个节点，slow每次走一个节点，当走到末尾时，slow刚好走到一半

//法二：快慢指针法(只遍历一遍链表)
//fast每次走两个节点，slow每次走一个
//1、当fast走到尾节点表示奇数个节点 2、当fast走到NULL表示偶数个节点
struct ListNode* middleNode(struct ListNode* head)
{
    struct ListNode* fast = head, *slow = head;
    
    //注意1：while里面的两个条件不能交换，否则出错。
    //因为要先判断fast位置是否等于NULL
    while(fast!=NULL && fast->next!=NULL)
    {
        fast=fast->next->next;
        slow=slow->next;
    }
    
    //注意2：退出循环fast=NULL表示偶数个，fast->next=NULL表示奇数个
    return slow;
}

题三：合并两个有序链表

链接：
LeetCode21.合并两个有序链表

法1：tail拼接法

说明： 用head和tail重新去拼接
规则：list1和list2找小尾插到tail后面，最后返回记录的head。
两种写法的方法一样，但相对来说第二种写法更容易理解

第一种写法：

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
    //1、list2 != NULL || 二者都为NULL
    if(list1 == NULL)
    {
        return list2;
    }

    //2、list1 !=NULL || 二者都为NULL
    if(list2 ==NULL)
    {
        return list1;
    }

    //3、二者都不为NULL
    struct ListNode* head = NULL;
    struct ListNode* tail = NULL;
    while(list1!=NULL && list2!=NULL)
    {
        //注意点1：比较list1和list2的值，小的拿来尾插
        if(list1->val <= list2->val)
        {
            //注意点2：处理第一个节点，放入head和tail，记录好头节点
            if(head==NULL)
            {
                head = tail = list1;
            }
            else
            {
                tail->next = list1;
                tail=tail->next;
            }

            //注意3：从list1转移一个节点在head链表上后，
            //因为这个节点还没有断掉与list1的联系，所以往后找节点
            list1 = list1->next;
        }
        else
        {
            if(head==NULL)
            {
                head = tail = list2;
            }
            else
            {
                tail->next=list2;
                tail=tail->next;
            }
            list2=list2->next;
        }
    }

    //注意点5：走完循环,list1还有节点
    if(list1!=NULL)
    {
        tail->next = list1;
    }
    if(list2!=NULL)
    {
        tail->next = list2;
    }

    //注意点6：返回记录的头节点
    return head;
}

第二种写法：

//简化版
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
    //1、list2 != NULL || 二者都为NULL
    if(list1 == NULL)
    {
        return list2;
    }
    //2、list1 !=NULL || 二者都为NULL
    if(list2 ==NULL)
    {
        return list1;
    }

    struct ListNode* head = NULL;
    struct ListNode* tail = NULL;

    //注意1：提前把head和tail的第一个节点准备好,保证tail!=NULL
    if(list1->val < list2->val)
    {
        head=tail=list1;
        list1=list1->next;
    }
    else
    {
        head=tail=list2;
        list2=list2->next;
    }

    //3、遍历找小尾插
    while(list1!=NULL && list2!=NULL)
    {
        //注意点2：第一次循环是，tail已经有一个头节点
        if(list1->val < list2->val)
        {
            tail->next = list1;
            list1=list1->next;
        }
        else
        {
            tail->next=list2;
            list2=list2->next;
        }
        //注意点3：tail连接新节点后，要指向这个新节点，便于下次尾插
        tail=tail->next;
    }

    //注意点4：走完循环,list1还有节点
    if(list1!=NULL)
    {
        tail->next = list1;
    }
    if(list2!=NULL)
    {
        tail->next = list2;
    }

    //4、返回记录的头节点
    return head;
}

法2：哨兵位法

说明：创建一个哨兵（头节点），然后用这个节点把list1和list2两个链表有序连接
优点：
1、可以不用再考虑法一中，tail连接头节点单独讨论的过程，也便于理解
2、可以解决二级指针传参的问题，如在带头双向循环链表里

//法二：哨兵法
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
    //1、list2 != NULL || 二者都为NULL
    if(list1 == NULL)
    {
        return list2;
    }
    //2、list1 !=NULL || 二者都为NULL
    if(list2 ==NULL)
    {
        return list1;
    }

    //注意1：提前把哨兵head准备好
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode* tail = head;

    //3、遍历找小尾插
    while(list1!=NULL && list2!=NULL)
    {
        //注意点2：第一次循环是，tail已经有一个头节点
        if(list1->val < list2->val)
        {
            tail->next = list1;
            list1=list1->next;
        }
        else
        {
            tail->next=list2;
            list2=list2->next;
        }
        //注意点3：tail连接新节点后，要指向这个新节点，便于下次尾插
        tail=tail->next;
    }

    //注意点4：走完循环,list1还有节点
    if(list1!=NULL)
    {
        tail->next = list1;
    }
    if(list2!=NULL)
    {
        tail->next = list2;
    }

    //4、返回存储数据的第一个节点
    struct ListNode* first = head->next;
    free(head);
    head=NULL;

    return first;
}

题四：环形链表

链接：
LeetCode141.环形链表

错误示范：

根本原因：不知道入环位置
解释：找是不是第一个节点入环，需要从第二个开始找当前节点是否与第一个节点相同
不同就继续找下一个。那就出了一个问题，如果非第一个节点是入环，就陷入了死循环。

bool hasCycle(struct ListNode *head) 
{
    struct ListNode* cur = head, *mark = head;
    while(mark!=NULL)
    {
        //cur!=NULL这个循环会陷入死循环
        while(cur!=NULL)
        {
            if(cur->next==mark)
            {
                return true;
            }
        }
        mark=mark->next;
        cur=mark;
    }
    return false;
}

方法：快慢指针法

说明：快指针fast一次走两个节点，慢指针slow一次走一个节点。fast先进入环，slow后进入环，然后fast在环中追逐slow，直到fast=slow时return true。

//快慢指针
bool hasCycle(struct ListNode *head) 
{
    //1、有环：快指针先进入环，然后慢指针进入环，最后fast追逐slow直到相等时停止
    struct ListNode *fast = head, *slow = head;
    while(fast!=NULL && fast->next!=NULL)
    {
        fast=fast->next->next;
        slow=slow->next;

        if(fast==slow)
        {
            return true;
        }
    }

    //2、fast=NULL或者fast->next=NULL。表示链表不带环就退出循环，fast=NULL表示偶数个节点，fast->next=NULL表示奇数个节点
    return false;
}

拓展面试题：

题目：

  1. slow一次走1步，fast一次走2步。请证明slow和fast一定在环内相遇，即fast一定追到slow？有没有追不上的可能？
  2. slow一次走1步，fast一次走3步行吗？
    slow一次走1步，fast一次走4步呢？
    slow一次走1步，fast一次走n步呢？

1小题：slow一次走1步，fast一次走2步

结论：slow一次走1步，fast一次走2步。在环内fast一定能追到slow，因为步数相差1。

如下图所示：
1、分析题目：
分析题目

2、画图理解：
画图理解

2小题：

2.1：slow一次走1步，fast一次走3步

结论：

  1. N是2（3-1）的倍数，一定能相遇，
  2. N不是2的倍数，但fast超过slow时相隔1，所以如果C-1为2的倍数就可以相遇
  3. N不是2的倍数，且C-1不是2的倍数永不相遇

如下图所示：
1、分析题目：
题目分析

2、画图理解

N为2的倍数（偶数）：

fast和slow能相遇，因为3-1=2，fast和slow步数相差2，所以2的倍数就能相遇
N为偶数

N不是2的倍数（奇数）：

设链表节点为C个，C-1为2（3-1）的倍数，则fast和slow能相遇

C-1为2的倍数：

注意：

  1. 在这里fast走了两圈即6个N，slow走了2个N，即fast第一圈跳过了slow，因为C-1为偶数，第二圈追了回来。

入环和反超
相遇

C-1不是2的倍数：

当N=1时，C=6时：fast第一次反超slow，这时C-1=5不是2的倍数，最终陷入死循环
第一次反超：
fast第一次反超
后续循环：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.2：slow一次走1步，fast一次走4步

结论：

  1. N为3（4-1）的倍数，一定能相遇。
  2. N不是3的倍数，但fast第一次反超slow相隔1时，C-1为3的倍数，就能相遇
  3. N不是3的倍数，但fast第一次反超slow相隔2时，C-2为3的倍数，就能相遇
  4. N不是3的倍数，fast第一次反超slow时C-1或者C-2不是3的倍数，就一定不能相遇，由此可以推广到slow走一步，fast走n步。

总结

  • slow一次走1步，fast一次走2步：fast一定能追上slow

  • slow一次走1步，fast一次走3步：fast不一定能追上slow
    1、slow入环时二者相距离N为步数差（2）的倍数，则可以追上
    2、第一次反超时，相间隔距离为1，环的长度C-1为步数差（2）的倍数，就可以追上。
    3、以上两者都不是，则永久循环。

  • slow一次走1步，fast一次走n步：
    与fast走3步相类似。

题五：环形链表II

链接：
LeetCode142.环形链表II

结论

说明：slow一次走1步，fast一次走2步。从fast和slow相遇节点meet开始，和从开头head位置开始，二者到入环的长度相等，即它们会在入环处相遇

//推导出的结论：一个指针从相遇节点往后走，一个指针从head往后走，它们会在入环处相遇
struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode *fast = head, *slow = head;

    while(fast!=NULL && fast->next!=NULL)
    {
        fast=fast->next->next;
        slow=slow->next;

        //注意点2：fast追上slow, 环中相遇节点meet往后走
        //start从head位置往后找，meet和start在入环节点处相遇
        if(fast==slow)
        {
            struct ListNode *meet = fast;
            struct ListNode *start = head;
            while(start!=meet)
            {
                start=start->next;
                meet=meet->next;
            }
            return start;
        }
    }

    //注意点2：fast能出循环，表示链表没有环形部分
    return NULL;
}

证明

分析：

规定：设L为head到入环位置的长度，X为slow走的长度(也为fast追slow最后不到一圈的长度)，C为环的长度，N为fast追slow走过完整的圈数，从顺时针看。
meet为slow和fast相遇时的节点。

在这里插入图片描述

情况1：环大头短

说明：环大头短的情况下，fast走的路程是大于等于1圈，小于2圈的 且fast路程C <= N*C+X < 2C。这里N=1。

1、fast走一圈及以下（错误示范）：

在这里插入图片描述
在这里插入图片描述

注意：环大头短，且fast走一圈以下不能实现，最低都得是满一圈。因为fast在环入口对面到环的范围时，fast已经走了右半环，最后fast走的路程：L+C+X

2、fast走大于等于一圈不到两圈：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

情况2：环小头长

说明：环小头长的情况下，fast走的路程大于等于两圈，且fast路程N*C+X >= 2C，这里N>=2

在这里插入图片描述
在这里插入图片描述

展示证明：

1、总结：L+N * C+X >= C，N>=1

在这里插入图片描述

2、C <= L+N * C+X < 2C，N=1

即环大头短，fast路程大于等于一圈小于两圈：
在这里插入图片描述

3、L+N * C+X >= 2C，N >= 2

即环小头大，fast路程大于等于两圈：
在这里插入图片描述

感受

在写这一篇博客之前，没接触过环形链表，也没有多大感受，我也没想过这篇博客我会写的这么曲折，花这么长时间。前面几道OJ题画图之后还是容易解决，环形链表知道原理后代码也比较简单。但环形链表原理的证明也太复杂了吧！写了后感觉全身酸麻，主要是证明时，我还走了弯路，写到后面才绕回来，属实裂开。但万幸最终还是通过拼时间完成，花了两天，累的同时也有一种成就感。让这种让人酸痛的题再多来几道吧，让我多感受感受痛苦的滋味！

链表的OJ题---（C++）
weixin_45599288的博客
02-17 970
链表的题目206 反转链表876链表的中间结点22链表中倒数第K个结点21合并2个有序链表牛客CM11 链表分割 206 反转链表 题目链接：https://leetcode-cn.com/problems/reverse-linked-list/ 思路一：双指针解决 定义1个prev的前驱指针，cur来工作指针，next来保存cur的下一个，如果不保存cur的下一个，cur指向prev后则找不到cur的next了。当cur走到空时循环结束。注意返回头结点，结束时头结点是prev。 如下图： 代
C++解OJ题--回文链表（图文并茂系列）
老胡的博客
11-19 950
  一杯茶，一包烟，一道链表盯一天。 文章目录一.反转前半部分二.反转后半部分 原题如下：   给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。   你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？ 审题：   题目的描述挺简洁，但是所需要考虑的点还是挺多。那什么是回文链表？在这里就不多描述，我给出几个例子后再总结一下，如下：   只有一个结点的链表属于回文链表。   奇数个结点的链表可能属于回文链表。   偶
数据结构链表例题
c_living的博客
07-09 964
给定一个链表L，链表中的整数数据是唯一的。给定一个数组G，G中的数据全是链表L中的数，但是顺序可能是打乱的。现在要判断G中的数据在对应链表中的数据位置是否是连接上的，并求出链接上的组数。例如：L：0-&gt;7-&gt;2-&gt;9-&gt;4G:{0,9,7,4}结果返回：2，因为{0，7}在L中式连续的，{9，4}在L中是连续的，3个连续或者更多同样算一个。当最后只有一个的情况下是视为一个连...
C语言【数据结构】链表【OJ题（C++）练习】
冰果滴的博客
06-02 1615
前言：单链表->C语言【数据结构】单链表实现_糖果雨滴a的博客-CSDN博客_c语言单链表的实现 带头双向循环链表->C语言【数据结构】链表（带头双向循环）实现_糖果雨滴a的博客-CSDN博客 1.203. 移除链表元素 （1）描述 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3.
链表相关ＯJ题目
qq_52145272的博客
11-06 266
文章目录10-30移除链表元素问题描述思路分析代码实现反转链表问题描述思路分析代码实现链表的中间结点问题描述思路分析代码实现链表中倒数第K个结点问题描述思路分析代码实现合并两个有序链表问题描述思路分析代码实现链表分割问题描述思路分析代码实现10-31链表的回文结构问题描述思路分析代码实现相交链表问题描述思路分析代码实现11-2环形链表问题描述思路分析代码实现环形链表进阶问题描述思路分析代码实现 10-30 移除链表元素 问题描述 https://leetcode-cn.com/problems/remove
【学堂在线】清华数据结构 OJ小记录
这里是张聪明，正在学习中，请稍后
02-05 4026
MOOC数据结构 OJ题记录PA1-1 范围查询 （对应课程：绪论+向量）PA1-2 祖玛问题 （对应课程：列表） PA1-1 范围查询 （对应课程：绪论+向量） 描述 数轴上有n个点，对于任一闭区间 [a, b]，试计算落在其内的点数。 输入 第一行包括两个整数：点的总数n，查询的次数m。 第二行包含n个数，为各个点的坐标。 以下m行，各包含两个整数：查询区间的左、右边界a和b。 输出 对每次...
C++解OJ题--链表中倒数第K个结点（已在路上）
老胡的博客
11-21 771
  世界这么大，人生这么长，总会有这么一个人，让你想要温柔对待。 原题如下：   输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。   例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。 审题：   题目也还是很好理解，就是输出一个单链表的倒数第K个结点。 可能给我们的单链表的情况：  1.空的单链表;  2.有多个结点，但是K的值不合理（即K的值大于链表
C++解OJ题----反转链表（这次没有递归只有迭代）
老胡的博客
11-18 627
  2021年的最后个把月，收拾心情，整装待发，请让我越来越忙碌吧！   解了一道OJ题，一起来看看。 原题如下：   给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 审题：   题目描述还是挺简单的，就是给你一个单链表让它的头变尾，尾变头后，返回新的头。 可能给我们的单链表情况：  1.空单链表；  2.只有一个结点的单链表；  3.有多个结点的单链表。   对于前两种情况，我们都还是很好进行处理的，只需要返回原来的头即可。现在一起来看看如何处理第三种情况。 一.点不变箭头变
C++解OJ题--环形链表
老胡的博客
11-10 1079
  害怕犯错而不去犯错才是最大的错误！   哈哈，登场的时候先抒情一下！今天又解了一道算法题，一起来看看吧
关于链表的经典OJ题
拼命阿紫冲冲冲！
03-16 1828
表锅，我出来了哦！！！ 表锅，表集，表die，表美 们，看我金天又给大噶带来了什么咧？？？ ------------额，金天给大家伙带来了，关于链表的三大经典OJ题哦！（哈哈哈哈哈哈）
链表的相关OJ题解析
m0_72532428的博客
05-19 823
链表的相关OJ题
单链表OJ题（1）
qq_45229484的博客
12-09 592
目录 移除链表元素 思路： 实现代码 反转链表 思路1：头插法 实现代码 思路2：从头开始改变链表的指向 实现代码 移除链表元素 力扣 思路： 1.当第一个元素是需要删除的元素（要移动头的位置） 2.当第一个元素不是需要删除的元素（不需要改变头的位置） 如果第二个元素是需要删除的元素 如果第二个元素不是需要删除的元素（移动cur 和 next 的位置） 实现代码 struct ListNode* removeE...
一网打尽链表的经典OJ题！链表必考笔试题第一弹
qq_63992711的博客
01-10 775
单链表作为只能单向搜寻，具有天生缺陷的数据结构，衍生出了许许多多的OJ题，这些都是笔试当中的经典题，本编博客旨在带大家手把手分析这些单链表的OJ题。
力扣---链表OJ题
myi__的博客
11-16 1074
一：给你一个链表的头节点head和一个整数val，请你删除链表中所有满足Node.val == val的节点，并返回新的头节点。 示例1： 示例2： 输入：head=[ ]，val = 1 输出：[ ] 示例3： 输入：head=[7,7,7,7]，val=7 输出：[ ] 二：给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。 统计链表中总结点的个数size 取size的一半 让一个引用从链表的起始位置往后遍历，..
C++习题 继承与组合
u013629228的专栏
06-03 4739
Problem C: C++习题 继承与组合 [Submit][Status][Web Board] Description 已知类如下： （1） BirthDate（生日类） 含有：year,month,day 等数据成员 （2） Teacher（教师类）含有：num,name,sex 等数据成员 （3） Professor（教授类）含有：教师类和生日类的数据成员 要求
C++ ---- 链表题 ---- 持续更新中。
huanfei8895的博客
08-17 875
链表题：一个链表的结点结构 复制代码 struct Node { int data ; Node *next ; }; typedef struct Node Node ; (1)已知链表的头结点head,写一个函数把这个链表逆序 ( Intel) Node * ReverseList(Node *head) //链表逆序 { if ( head == NULL || head->next == NULL ) return head; Node *p1 = head ; Node *p2 = p1-&
C++链表基本用法及LeetCode经典链表题目汇总
whocare的博客
05-02 3692
链表基本用法： 目录 链表基本用法： C++链表及基本操作 LeetCode链表经典题目汇总： 2. 两数相加 19. 删除链表的倒数第 N 个结点 21. 合并两个有序链表 23. 合并K个升序链表 24. 两两交换链表中的节点 25. K 个一组翻转链表 61. 旋转链表 92. 反转链表 II 141. 环形链表 142. 环形链表 II 160. 相交链表 328. 奇偶链表 C++链表及基本操作 1 2 ...
数据结构-二叉树及其遍历
宁zz的博客
11-15 536
本篇文章咱们聊聊数据结构中的树，准确的说因该是只说一说二叉树以及相关的三种递归遍历、三种非递归遍历以及层次遍历。🍃二叉树 (BinaryTree) 是 n (n>0) 个结点所构成的集合，它或为空树(n-0)或为非空树，对于非空树(1) 有且仅有一个称之为根的结点:(2) 除根结点以外的其余结点分为两个互不相交的子集 TI 和 T2，分别称为 T 的左子树和右子树，且 T1 和 T2 本身又都是二叉树。🍃二叉树与树一样具有递归性质，二叉树与树的区别。
数据结构-线性表-具有独立头节点的双向循环链表
最新发布
2301_76819732的博客
11-15 529
双向循环链表是一种在链表基础上拓展而来的数据结构。与普通链表不同的是，它的每个节点都有两个指针，一个指向前驱节点（prior），一个指向后继节点（next而且，它是循环的，即链表的尾节点的后继指针指向头节点，头节点的前驱指针指向尾节点，形成一个闭合的环。我们这里讨论的双向循环链表还有一个独立的头节点。这个独立头节点不存储数据，主要用于方便对链表的操作和维护。这种链表为空的条件是头节点的next和prior指针都指向NULL。在代码中，首先定义了链表节点的数据类型。} Node;这里，
评论 18
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

学Java的冬瓜

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

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

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

打赏作者

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

抵扣说明：

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

余额充值