C语言【数据结构】链表【OJ题(C++)练习】

目录

1.203. 移除链表元素

2.206. 反转链表

3.876. 链表的中间结点

4.链表中倒数第k个结点_牛客题霸_牛客网

5.21. 合并两个有序链表

6.链表分割_牛客题霸_牛客网

7.链表的回文结构_牛客题霸_牛客网

8.160. 相交链表

9.141. 环形链表

10.142. 环形链表 II

11.138. 复制带随机指针的链表


前言:单链表->C语言【数据结构】单链表实现_糖果雨滴a的博客-CSDN博客_c语言单链表的实现

带头双向循环链表->C语言【数据结构】链表(带头双向循环)实现_糖果雨滴a的博客-CSDN博客

1.203. 移除链表元素

(1)描述

给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。
C语言【数据结构】链表【OJ题(C++)练习】_第1张图片

示例 1:

输入:head = [1,2,6,3,4,5,6], val = 6
输出:[1,2,3,4,5]


示例 2:

输入:head = [], val = 1
输出:[]


示例 3:

输入:head = [7,7,7,7], val = 7
输出:[]

(2)思路

方法1:类似于单链表中的删除接口。

        创建一个用来循环的节点cur,以及一个保存cur前一个结点的prev,通过while循环,循环到nullptr时停止,如果cur节点值不是val,先让prev = cur,然后再让链表往后走,这样prev就始终是cur的前一个值。

        如果cur节点的值为val,这时候要注意一种特殊情况,当头节点的值为val,那么要先保存头节点的下一个节点,然后delete掉头节点,再让下一个节点变成头节点。正常情况就通过让prev->next = cur -> next,直接连接起来,从而实现删除操作,之后再delete掉cur,同时让cur变成原本cur的下一个节点(现在是prev的下一个节点)

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* cur = head;
        ListNode* prev = nullptr;
        while(cur != nullptr)
        {
            // 不是val,链表往后走
            if(cur->val != val)
            {
                prev = cur;
                cur = cur->next;
            }
            // 是val
            else
            {
                // 头是val,delete掉当前头节点,让下一个节点作为新的头
                if(head->val == val)
                {
                    ListNode* next = head->next;
                    delete head;
                    head = next;
                    cur = next;
                }
                // 正常情况,让前一个节点连接上后一个节点,删掉值为val的节点
                else if(cur->val == val)
                {
                    prev->next = cur->next;
                    delete cur;
                    cur = prev->next;
                }
            }
        }

        return head;
    }
};

方法2:递归方法,链表一般都可以用递归的方式来做。

        我们可以把链表看做一个头节点head后面连接一个更短的链表,然后进行拆解,不断拆解,直到不能再拆解。head == nullptr的时候就说明不能再拆了。

        然后如果递归中head中的值等于val,那么就直接返回当前链表连接的情况(这样就可以让当前这个节点不参与到链表中,相当于删除了这个节点)。如果不等于,就让head->next = res,即让当前节点连接到链表之中,之后返回到res中。

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if (head == nullptr) 
            return nullptr;  

        ListNode* res = removeElements(head->next, val);

        if (head->val == val) 
        {
            return res;
        } 
        else 
        {
            head->next = res;
            return head;
        }
    }
};

方法2写法优化:

        这个在写法上进行了优化,直接把结果存放到head->next中,这时候在判断head的值是否等于val时,我们要注意,如果是val,要返回head->next,这样才能跳过当前节点;然后不是val的时候,返回当前节点,才能连接上。

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if(head == nullptr)
            return nullptr;

        head->next = removeElements(head->next, val);
        return head->val == val ? head->next : head;
    }
};

2.206. 反转链表

(1)描述

给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。

示例 1:

C语言【数据结构】链表【OJ题(C++)练习】_第2张图片

输入:head = [1,2,3,4,5]
输出:[5,4,3,2,1]


示例 2:

C语言【数据结构】链表【OJ题(C++)练习】_第3张图片

输入:head = [1,2]
输出:[2,1]


示例 3:

输入:head = []
输出:[]

(2)思路

方法1:头插法,我们把后面的节点依次头插在第一个节点前面

我们创建一个newHead变量,这个就是最后新的头节点,以及一个cur变量。while循环,先保存当前节点的下一个节点,然后让当前节点连上新的头节点newHead,连上之后,这个节点就变成了新的头节点,cur = next,cur往下走,继续循环,直到结束。最后返回newHead即可

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* newHead = nullptr;
        ListNode* cur = head;

        while(cur != nullptr)
        {
            ListNode* next = cur->next;
            cur->next = newHead;
            newHead = cur;
            cur = next;
        }

        return newHead;
    }
};

方法2:调转方向法。创建3个指针,n1,n2,n3,然后通过这3个指针,依次改变链表中的方向。

        n2为从头到尾的指针,每次改变n2的下一个节点,让n2的下一个节点指向它的前一个结点n1,然后3个指针分别往后走,如果n3不是空指针,就让n3再往下走,因为最后n3一定会是空指针,所以要加上这一层判断,否则会报错。

        最后我们还要注意,因为n3在初始化时是头节点的下一个,所以当链表为空链表时,要提前结束,否则n3会因为非法访问报错。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // 下面n3是n2的下一个,如果head是空,就要提前判断,否则下面n3会非法访问
        if(head == nullptr)
        {
            return head;
        }

        ListNode* n1 = nullptr;
        ListNode* n2 = head;
        ListNode* n3 = n2->next;

        while(n2)
        {
            n2->next = n1;
            n1 = n2;
            n2 = n3;
            if(n3)
            {
                n3 = n3->next;
            }
        }

    return n1;

    }
};

方法3:递归法

        通过递归调用到链表的最后面,然后从后往前,改变链表方向

        首先两个判断,如果head为空,即链表为空时,直接返回头节点,如果head->next为空,说明走到链表尾,这时候返回头节点。

        我们创建一个新头,通过递归,递归到了最后一个节点时,返回,这时head,比如链表是1->2->3->4->5,这是我们的位置是处于4,newHead这时候是5(因为刚才递归到最后一个节点后就返回了)。这时候让head->next->next = head,即5的next指向4(head),这样就实现了5->4,但是这时候指向是1->2->3->4<->5,所以我们要让head->next = nullptr,这样就是1->2->3->4<-5了,这样依次从后往前进行,就可以完成反转。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr || head->next == nullptr)
        {
            return head;
        }

        ListNode* newHead = reverseList(head->next);

        head->next->next = head;
        head->next = nullptr;

        return newHead;
    }
};

3.876. 链表的中间结点

(1)描述

给定一个头结点为 head 的非空单链表,返回链表的中间结点。

如果有两个中间结点,则返回第二个中间结点。

示例 1:

输入:[1,2,3,4,5]
输出:此列表中的结点 3 (序列化形式:[3,4,5])


返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意,我们返回了一个 ListNode 类型的对象 ans,这样:
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.


示例 2:

输入:[1,2,3,4,5,6]
输出:此列表中的结点 4 (序列化形式:[4,5,6])


由于该列表有两个中间结点,值分别为 3 和 4,我们返回第二个结点。

(2)思路

方法1:数组法

        这个比较容易想,因为链表无法通过下标去找到对应的元素,那么我们可以创建一个数组,放入数组中,然后 数组元素个数 / 2 就是中间节点了。

方法2:单指针法

        这个是对方法1的优化,节省了空间。只需要遍历两遍链表,第一遍记录链表元素个数,第二遍遍历到 个数 / 2 返回即可。

方法3:快慢指针法

        这个是最好的方法,只需要遍历一遍链表。通过定义两个指针变量,一个快指针,一个慢指针,然后同时往后遍历,快指针一下走两步,慢指针一下走一步,这样等快指针走到链表尾的时候,慢指针正好走到中间节点。

方法3代码:

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode* fast = head, *slow = head;
        while(fast != nullptr && fast->next != nullptr)
        {
            fast = fast->next->next;
            slow = slow->next;
        }

        return slow;
    }
};

4.链表中倒数第k个结点_牛客题霸_牛客网

(1)描述

输入一个链表,输出该链表中倒数第k个结点。

示例1

输入:

1,{1,2,3,4,5}

复制返回值:

{5}

(2)思路

方法1:要求得倒数第k个节点,那么我们可以转换成正数的。

        两次遍历,第一次遍历求出链表元素个数,然后把倒数转换成正数的,第二遍再遍历到正数的链表元素,并返回。

方法2:快慢指针法

        定义两个指针变量,一个快指针,一个慢指针,想要得到倒数第k个元素,那么可以先让快指针fast先走k步,然后再让两个指针一起走,这时候因为fast先走了k步,所以fast会比slow快k步,这时候slow正好是倒数第k个元素。

方法2代码:

class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        ListNode* fast = pListHead, *slow = pListHead;
        while(k--)
        {
            // k > 链表中的元素个数时
            if(fast == nullptr)
            {
                return nullptr;
            }
            // 正常往下走
            fast = fast->next;
        }
        
        while(fast)
        {
            fast = fast->next;
            slow = slow->next;
        }
        
        return slow;
    }
};

5.21. 合并两个有序链表

(1)描述

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

示例 1:

输入:l1 = [1,2,4], l2 = [1,3,4]
输出:[1,1,2,3,4,4]


示例 2:

输入:l1 = [], l2 = []
输出:[]


示例 3:

输入:l1 = [], l2 = [0]
输出:[0]

(2)思路

方法1:迭代法

        创建两个变量,作为新的链表的头和尾。用归并的思想,list1的小,就链接上list1的节点,list2的小,就链接上list2的节点,这里要注意,第一个进来的节点,要变成这个新链表的头。链接交给尾指针,每次链接新节点,都更改尾指针。最后判断list1和list2是否有剩余的节点,若有,则链接上。

        这里要注意list1和list2存在空链表的情况,list1为空,就返回list2;list2为空,就返回list1。

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        // list1为空链表
        if(list1 == nullptr)
            return list2;

        // list2为空链表
        if(list2 == nullptr)
            return list1;

        ListNode* head = nullptr, *tail = nullptr;

        while(list1 && list2)
        {
            // list1小于list2
            if(list1->val < list2->val)
            {
                // 第一个进入循环的节点,作为头节点
                if(tail == nullptr)
                {
                    head = list1;
                    tail = list1;
                }
                // 尾插,尾连接下一个节点,并让下一个节点变成新的尾
                else
                {
                    tail->next = list1;
                    tail = list1;
                }

                list1 = list1->next;
            }
            else
            {
                // 第一个进入循环的节点,作为头节点
                if(tail == nullptr)
                {
                    head = list2;
                    tail = list2;
                }
                else
                {
                    tail->next = list2;
                    tail = list2;
                }

                list2 = list2->next;
            }
        }

        // list1有剩余的节点
        if(list1)
        {
            tail->next = list1;
        }

        // list2有剩余的节点
        if(list2)
        {
            tail->next = list2;
        }

        return head;
    }
};

方法2:递归法

        使用递归分解了很多子问题,每个子问题都是一个在当前的链表中找到最小的一个节点,被连接在前一个最小的节点后面。连接之后,返回去才是真正链接上了。

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        // list1为空链表
        if(list1 == nullptr)
            return list2;

        // list2为空链表
        if(list2 == nullptr)
            return list1;

        if(list1->val < list2->val)
        {
            list1->next = mergeTwoLists(list1->next, list2);
            return list1;
        }
        else
        {
            list2->next = mergeTwoLists(list1, list2->next);
            return list2;
        }
    }
};

6.链表分割_牛客题霸_牛客网

(1)描述

现有一链表的头指针 ListNode* pHead,给一定值x,编写一段代码将所有小于x的结点排在其余结点之前,且不能改变原来的数据顺序,返回重新排列后的链表的头指针。

(2)思路

         创建两个新的链表,并且都带一个哨兵位的头节点,两个链表分别定义一个头和一个尾,哨兵位的头用来后面链接与返回,尾用来链接每一个节点。

        小于x的节点插在lessTail的后面,大于x的节点插在greaterTail的后面。最后再把greaterTail的下一个节点置空,让lessTail链接上greaterTail。

class Partition {
public:
    ListNode* partition(ListNode* pHead, int x) {
        // write code here
        ListNode* lessHead, *lessTail, *greaterHead, *greaterTail;
        lessHead = lessTail = new ListNode(0);
        greaterHead = greaterTail = new ListNode(0);
        
        lessTail->next = nullptr;
        greaterTail->next = nullptr;
        
        ListNode* cur = pHead;
        while(cur)
        {
            // 小于x的节点插在lessTail的后面
            if(cur->val < x)
            {
                lessTail->next = cur;
                lessTail = cur;
            }
            // 大于x的节点插在greaterTail的后面
            else
            {
                greaterTail->next = cur;
                greaterTail = cur;
            }
            
            // cur往后走
            cur = cur->next;
        }
        
        // 大的那个链表后面为空
        greaterTail->next = nullptr;
        // 小的那个链表后面链接大的链表
        lessTail->next = greaterHead->next;
        
        // 下面要销毁,提前保存一下
        ListNode* list = lessHead->next;
        
        delete lessHead;
        delete greaterHead;
        
        return list;
    }
};

7.链表的回文结构_牛客题霸_牛客网

(1)描述

对于一个链表,请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法,判断其是否为回文结构。

给定一个链表的头指针A,请返回一个bool值,代表其是否为回文结构。保证链表长度小于等于900。

示例:

1->2->2->1
返回:true

(2)思路

        想要判断是否是回文结构,那么我们可以先得到中间的节点,再把中间节点后面的所有节点都进行反转处理,这时如果是回文结构,那么对应的节点的值应该都相等。因此可以通过这个进行比较,全相等说明是回文结构。

        首先是求得中间节点,这里我们可以通过快慢指针来完成,但是要注意节点个数为奇数还是偶数时,同时也要注意是否为空链表。因此这里判断条件是fast && fast->next,最后返回慢指针。

        然后是让中间节点后面的节点反转,这个与上面的第2题相同->2. 206. 反转链表

         最后两段依次进行比较,有一个不相同就说明不是回文结构。

class PalindromeList {
public:
    ListNode* middleNode(ListNode* head)
    {
        ListNode* fast = head, *slow = head;
        while(fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        
        return slow;
    }
    
    ListNode* reverseList(ListNode* head)
    {
        ListNode* newHead = nullptr;
        ListNode* cur = head;
        while(cur)
        {
            ListNode* next = cur->next;
            cur->next = newHead;
            newHead = cur;
            cur = next;
        }
        
        return newHead;
    }
    
    bool chkPalindrome(ListNode* A) {
        // write code here
        
        // 得到中间节点
        ListNode* mid = middleNode(A);
        // 得到从中间到最后一个节点的倒序链表
        ListNode* rHead = reverseList(mid);
        
        // 前半段与后半段的倒序版比较,全部相等说明是回文结构
        while(A && rHead)
        {
            if(A->val == rHead->val)
            {
                A = A->next;
                rHead = rHead->next;
            }
            else
            {
                return false;
            }
        }
        
        return true;
    }
};

8.160. 相交链表

(1)描述

给你两个单链表的头节点 headA 和 headB ,请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点,返回 null 。

图示两个链表在节点 c1 开始相交:

C语言【数据结构】链表【OJ题(C++)练习】_第4张图片

题目数据 保证 整个链式结构中不存在环。

注意,函数返回结果后,链表必须 保持其原始结构 。

自定义评测:

评测系统 的输入如下(你设计的程序 不适用 此输入):

intersectVal - 相交的起始节点的值。如果不存在相交节点,这一值为 0
listA - 第一个链表
listB - 第二个链表
skipA - 在 listA 中(从头节点开始)跳到交叉节点的节点数
skipB - 在 listB 中(从头节点开始)跳到交叉节点的节点数
评测系统将根据这些输入创建链式数据结构,并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点,那么你的解决方案将被 视作正确答案 。

示例 1:

C语言【数据结构】链表【OJ题(C++)练习】_第5张图片

输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出:Intersected at '8'


解释:相交节点的值为 8 (注意,如果两个链表相交则不能为 0)。
从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,6,1,8,4,5]。
在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。


示例 2:

C语言【数据结构】链表【OJ题(C++)练习】_第6张图片

输入:intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出:Intersected at '2'


解释:相交节点的值为 2 (注意,如果两个链表相交则不能为 0)。
从各自的表头开始算起,链表 A 为 [1,9,1,2,4],链表 B 为 [3,2,4]。
在 A 中,相交节点前有 3 个节点;在 B 中,相交节点前有 1 个节点。


示例 3:

C语言【数据结构】链表【OJ题(C++)练习】_第7张图片

输入:intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出:null


解释:从各自的表头开始算起,链表 A 为 [2,6,4],链表 B 为 [1,5]。
由于这两个链表不相交,所以 intersectVal 必须为 0,而 skipA 和 skipB 可以是任意值。
这两个链表不相交,因此返回 null 。

(2)思路

        双指针法

        首先求出两个链表的长度,然后随便令一个链表为长链表,另一个链表就为短链表,这时候再用之前求出的长度判断一下是否符合。然后再让长的那个链表走差距步(两个长度的差值),这时候走完差距步时,两个链表处于相对应的位置上。

        之后再让两个链表一起往后走,这时候因为是在相对应的位置上,所以如果后面有一个相同的节点,就可以说明两个链表相交,如果链表走完,没有一个相同的节点,就说明两个链表不相交。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* tailA = headA, *tailB = headB;
        int lenA = 0, lenB = 0;

        // 求出链表A的节点个数
        while(tailA)
        {
            ++lenA;
            tailA = tailA->next;
        }

        // 求出节点B的节点个数
        while(tailB)
        {
            ++lenB;
            tailB = tailB->next;
        }

        // 默认A是长链表,B是短链表
        ListNode* longList = headA, *shortList = headB;
        // 如果B节点多,那么更改B为长链表,A为短链表
        if(lenB > lenA)
        {
            longList = headB;
            shortList = headA;
        }

        // 算出长度差
        int gap = abs(lenA - lenB);

        // 长链表走差距步
        while(gap--)
        {
            longList = longList->next;
        }

        // 长和短链表同时走,这时位置相对应
        // 如果后面有相同的节点,说明链表相交
        // 如果走到最后,也没有相同的节点,说明链表不相交
        while(longList && shortList)
        {
            if(longList == shortList)
            {
                return longList;
            }

            longList = longList->next;
            shortList = shortList->next;
        }

        return nullptr;
    }
};

9.141. 环形链表

(1)描述

给你一个链表的头节点 head ,判断链表中是否有环。

如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。注意:pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ,则返回 true 。 否则,返回 false 。

示例 1:

C语言【数据结构】链表【OJ题(C++)练习】_第8张图片

输入:head = [3,2,0,-4], pos = 1
输出:true


解释:链表中有一个环,其尾部连接到第二个节点。


示例 2:

C语言【数据结构】链表【OJ题(C++)练习】_第9张图片

输入:head = [1,2], pos = 0
输出:true


解释:链表中有一个环,其尾部连接到第一个节点。


示例 3:

输入:head = [1], pos = -1
输出:false


解释:链表中没有环。

(2)思路

        快慢指针法

        快指针一次走两步,慢指针一次走一步,那么如果有环,快指针会先进入环,这时候等到慢指针进入环,快指针可能已经转了好几圈了,但是无论如何,因为快指针和慢指针只差一步,所以一定会在环内相遇。

        如果没有相遇,就说明没有环。

注意:这个快慢指针中间必须只能差一步,比如:快指针一次走3步,慢指针一次走1步,那么如果距离入口点是奇数就永远也追不上了

class Solution {
public:
    bool hasCycle(ListNode *head) { 
        ListNode* fast = head, *slow = head;
        while(fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;

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

        return false;
    }
};

10.142. 环形链表 II

(1)描述

给定一个链表的头节点  head ,返回链表开始入环的第一个节点。 如果链表无环,则返回 null。

如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。如果 pos 是 -1,则在该链表中没有环。注意:pos 不作为参数进行传递,仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1:

C语言【数据结构】链表【OJ题(C++)练习】_第10张图片

输入:head = [3,2,0,-4], pos = 1
输出:返回索引为 1 的链表节点


解释:链表中有一个环,其尾部连接到第二个节点。


示例 2:

C语言【数据结构】链表【OJ题(C++)练习】_第11张图片

输入:head = [1,2], pos = 0
输出:返回索引为 0 的链表节点


解释:链表中有一个环,其尾部连接到第一个节点。


示例 3:

C语言【数据结构】链表【OJ题(C++)练习】_第12张图片

输入:head = [1], pos = -1
输出:返回 null


解释:链表中没有环。

(2)思路

        先判断是否有环,如果有环,我们就可以用结论:两个指针,一个指针从快慢指针相遇的地方走,一个指针从链表头走,最终它们会在入口点(环口)相遇。

链表头~入口点距离:L

链表头~相遇点距离:X

环的长度:C

fast一次走两步,slow一次走一步,那么fast走的距离是slow的两倍

slow走的距离:L+X

fast走的距离:L + N * C + X

2 * (L + X) = L + N * C  +X

L + X = N * C

L = N * C - X

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        // 先判断是否有环(快慢指针法)
        ListNode* fast = head, *slow = head;
        while(fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;

            // 快慢指针相遇
            if(slow == fast)
            {
                // meet是快慢指针相遇的位置
                // 结论:一个指针从meet走,一个指针从head走,最终它们会在入口点(环口)相遇
                // L = N*C-X <=> L = (N-1)*C+(C-X)
                ListNode* meet = fast;
                while (head != meet)
                {
                    head = head->next;
                    meet = meet->next;
                }

                return meet;
            }
        }

        return nullptr;
    }
};

11.138. 复制带随机指针的链表

(1)描述

给你一个长度为 n 的链表,每个节点包含一个额外增加的随机指针 random ,该指针可以指向链表中的任何节点或空节点。

构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成,其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点,并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。

例如,如果原链表中有 X 和 Y 两个节点,其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ,同样有 x.random --> y 。

返回复制链表的头节点。

用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示:

val:一个表示 Node.val 的整数。
random_index:随机指针指向的节点索引(范围从 0 到 n-1);如果不指向任何节点,则为  null 。
你的代码 只 接受原链表的头节点 head 作为传入参数。

示例 1:

C语言【数据结构】链表【OJ题(C++)练习】_第13张图片

输入:head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出:[[7,null],[13,0],[11,4],[10,2],[1,0]]


示例 2:

C语言【数据结构】链表【OJ题(C++)练习】_第14张图片

输入:head = [[1,1],[2,1]]
输出:[[1,1],[2,1]]


示例 3:

C语言【数据结构】链表【OJ题(C++)练习】_第15张图片

输入:head = [[3,null],[3,0],[3,null]]
输出:[[3,null],[3,0],[3,null]]

(2)思路

        这道题我们可以用三步去复制这个带随机指针的链表。

        第一步:先拷贝节点在原节点的后面

        第二步:再链接上拷贝节点的random指针

        第三步:最后解下拷贝的节点,并把拷贝的节点链接起来

class Solution {
public:
    Node* copyRandomList(Node* head) {
        // 1.拷贝节点在原节点后面
        Node* cur = head;
        while(cur)
        {
            Node* copy = new Node(cur->val);
            copy->next = cur->next;
            cur->next = copy;
            cur = cur->next->next;
        }

        // 2.链接拷贝节点的random
        cur = head;
        while(cur)
        {
            Node* copy = cur->next;

            if(cur->random == nullptr)
            {
                copy->random == nullptr;
            }
            else
            {
                // 链接的是拷贝的节点,所以copy->random要等于cur->random->next
                copy->random = cur->random->next;
            }
            cur = cur->next->next;
        }

        // 3.解下拷贝的节点,并把拷贝的节点链接起来
        cur = head;
        Node* copyHead = nullptr, *copyTail = nullptr;
        while(cur)
        {
            Node* copy = cur->next;
            Node* next = copy->next;
            cur->next = next;

            if(copyHead == nullptr)
            {
                copyHead = copy;
                copyTail = copy;
            }
            else
            {
                copyTail->next = copy;
                copyTail = copy;
            }

            cur = next;
        }

        return copyHead;
    }
};

你可能感兴趣的:(C语言数据结构学习-练习题,数据结构,链表,c语言,c++,算法)