剑指offer第二天-链表（简单）

题目1： 剑指 Offer 06. 从尾到头打印链表

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

示例 1：

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

限制：

0 <= 链表长度 <= 10000

题解：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
private:
vector<int> vectorFirst;
ListNode *t;
int p1;
int p2;
int x;

public:
    vector<int> reversePrint(ListNode* head) {
        t = head;
        //先遍历链表，将链表中的元素顺序的添加到容器vectorFirst中
        while (t != NULL) {
            vectorFirst.emplace_back(t -> val);
            t = t -> next;
        }
        //双指针法，实现将容器vectorFirst中的元素的顺序反转
        p1 = 0;
        //size()方法的作用是获取对应容器中的元素总个数
        p2 = vectorFirst.size() - 1;
        while (p1 < p2) {
            x = vectorFirst[p1];
            vectorFirst[p1] = vectorFirst[p2];
            vectorFirst[p2] = x;
            ++p1;
            --p2;
        }
        //最后将反转之后的容器vectorFirst返回即可
        return vectorFirst;
    }
};

**思路：**创建一个空容器，然后先遍历一遍链表并同时将链表中的元素按顺序添加到容器中，然后利用双指针法反转容器中元素的顺序，最终将反转好的容器返回即可。

题目2： 剑指 Offer 24. 反转链表

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

示例:

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

限制：

0 <= 节点个数 <= 5000

题解：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
private:
ListNode *t, *p, *temp;

public:
    ListNode* reverseList(ListNode* head) {
        t = head;
        p = NULL;
        while (t != NULL) {
            temp = t -> next;
            t -> next = p;
            p = t;
            t = temp;
        }
        head = p;
        return head;
    }
};

思路： 首先定义几个链表节点的指针，其中t指向原链表的头节点，然后p初始化时指向NULL,temp指针用于在循环反转过程中保存t在原链表中所指的下一个节点的位置，然后在循环便利过程中，利用头插法每次将t所指的原链表的节点插到p所指节点的前面，然后让p指向t更新新链表头节点的位置，依次如此循环直到原链表中的节点全部反转完返回p节点或者更新head节点后返回head节点。

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fu-za-lian-biao-de-fu-zhi-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

示例 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。

提示：

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

题解：

/*
// 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) {
        Node *newHead = NULL;
        if (head == NULL) {
            return newHead;
        }
        Node *p = head;
        while (p) {
            Node *node = new Node(p -> val);
            node -> next = p -> next;
            p -> next = node;
            p = p -> next -> next;
        }

        p = head;
        while (p) {
            if (p -> random) {
                p -> next -> random = p -> random -> next;
            }
            p = p -> next -> next;
        }
        newHead = head -> next;
        p = head -> next;
        Node *temp = head;
        while (p -> next) {
            temp -> next = temp -> next -> next;
            p -> next = p -> next -> next;
            p = p -> next;
            temp = temp -> next;
        }
        temp -> next = NULL;
        return newHead;
    }
};

思路：
通过两次循环在原链表每个节点后面先创建一个与其相同的节点，第一次循环设置好next，第二次循环设置其random，然后第三次循环是将这一个链表拆分成两个相同的链表，就可以得到想要的结果。