剑指offic--链表

PS:以下代码使用C++完成

1.从尾到头打印链表力扣

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：

输入：head = [1,3,2]
输出：[2,3,1]

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof

这道题方法有四种，我只写三种，剩下的一种交给读者自己去完成

//递归写法
class Solution {
public:
    vector arr;
    vector reversePrint(ListNode* head) 
    {
        
        if(head==nullptr)
            return arr;
       reversePrint(head->next);
       arr.push_back(head->val);
       
        return arr;
    }
};
//反转链表
class Solution {
public:
    vector arr;
    vector reversePrint(ListNode* head) 
    {
        ListNode* prev=nullptr;
        ListNode* cur=head;
        while(cur)
        {
            ListNode* next=cur->next;
            //prev=cur;
            cur->next=prev;
            prev=cur;
            cur=next;
        }
        while(prev)
        {
            arr.push_back(prev->val);
            prev=prev->next;
        }
        return arr;
    }
};

//尾插如vector,然后反转vector
class Solution {
public:
    vector reversePrint(ListNode* head) 
    {
        vector arr;
        while(head)
        {
            arr.push_back(head->val);
            head=head->next;
        }
        reverse(arr.begin(),arr.end());
        return arr;
    }
};

2.反转链表

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

限制：

0 <= 节点个数 <= 5000

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/fan-zhuan-lian-biao-lcof

这道题和上一道题差不多，如果上一道题成功解决，这道题可以不看。

这道题使用迭代完成

class Solution {
public:
    ListNode* reverseList(ListNode* head) 
    {
        //使用反转链表完成
        ListNode* prev=nullptr;
        ListNode* cur=head;
        while(cur)
        {
            ListNode* next=cur->next;
            cur->next=prev;
            prev=cur;
            cur=next;
        }
        return prev;
    }
};

3.复查链表的复制

请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。

示例 1：

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

示例 2：

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

示例 3：

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

示例 4：

输入：head = []
输出：[]
解释：给定的链表为空（空指针），因此返回 null。

提示：

    -10000 <= Node.val <= 10000
    Node.random 为空（null）或指向链表中的节点。
    节点数目不超过 1000 。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/fu-za-lian-biao-de-fu-zhi-lcof

这道题比较麻烦，我采用迭代的方法完成。

完成这道题分为三部：

1. 首先将原链表复制一边，然后将复制链表插入原链表
2. 复制random指针
3. 将复制好的链表从原链表中拆下

class Solution {
public:
    Node* copyRandomList(Node* head) 
    {
        Node* cur=head;
        //复制链表
        while(cur)
        {
            //开空间
            Node* copy=new Node(cur->val);
            copy->val=cur->val;
            copy->next=cur->next;
            cur->next=copy;
            cur=copy->next;
        }
        cur=head;
        //加入random的指针
        while(cur)
        {
            Node* copy=cur->next;
            if(cur->random==nullptr)
            {
                copy->random=nullptr;
            }
            else
            {
                copy->random=cur->random->next;
            }
            cur=copy->next;
        }
        //将复制好的链表从原链表中拆下
        cur=head;
        Node* copyhead=nullptr;
        Node* copytail=nullptr;

        while(cur)
        {
            Node* copy=cur->next;
            Node* Next=copy->next;
            if(copyhead==nullptr)
            {
                copytail=copyhead=copy;
            }
            else
            {
                copytail->next=copy;
                copytail=copytail->next;
            }
            cur->next=Next;
            cur=Next;
        }
        return copyhead;

    }
};