剑指Offer02

06.从尾到头打印链表

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

示例 1：
输入：head = [1,3,2]
输出：[2,3,1]
思路：先遍历的后输出，是种栈的思想，可以构造辅助栈来实现，也可以用递归来实现，每访问一个节点，先递归输出它后面的节点，在输出该节点自身

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        if(head == nullptr)
            return {};
        vector<int> res = reversePrint(head->next);
        res.push_back(head->val);
        return res;
    }
};

24.反转链表

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

示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
思路：要调整一个节点的next指针时，除了要知道节点本身，还需要知道前一个节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr || head->next == nullptr)
            return head;
        ListNode *res =  reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;
        return res;
    }
};

35.复杂链表的复制

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

思路：

1. 根据原始链表的每个节点N创建对应的N1，把N1链接到N的后边
2. 设置复制出来的N1节点的random
3. 把长链表拆分成两个链表N，N1，N是原始链表，N1是复制的链表

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
public:
    Node* copyRandomList(Node* head) {
        CloneNode(head);
        ConnectRandom(head);
        return ReconnectNode(head);
    }
    void CloneNode(Node* head)
    {
        Node* pnode = head;
        while(pnode != nullptr)
        {
            Node* newNode = new Node(pnode->val);
            newNode->next = pnode->next;
            pnode->next = newNode;
            pnode = newNode->next;
        }
    }
    void ConnectRandom(Node* head)
    {
        Node* node = head;
        while(node != nullptr)
        {
            Node* cnode = node->next;
            if(node->random != nullptr)
            {
                cnode->random = node->random->next;
            }
            node = cnode->next;
        }
    }
    Node* ReconnectNode(Node* head)
    {
        Node* node = head;
        Node* res = nullptr;
        Node* rnode = nullptr;
        if(node != nullptr)
        {
            res = rnode = node->next;
            node->next = rnode->next;
            node = node->next;
        }
        while(node != nullptr)
        {
            rnode->next = node->next;
            rnode = rnode->next; 
            node->next = rnode->next;
            node = node->next;
        }
        return res;
    }
};