题目一 从尾到头打印链表
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/
1.描述
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
2.示例
- 示例 1：
输入：head = [1,3,2]
输出：[2,3,1]
解法一 迭代+辅助栈
解题思路
看到题不难想到最简单的办法就是借助一个辅助栈，顺序遍历将节点值入栈，然后再依次出栈，就能实现倒序打印。
代码
1 1 /**
2 2 * Definition for singly-linked list.
3 3 * struct ListNode {
4 4 * int val;
5 5 * ListNode *next;
6 6 * ListNode(int x) : val(x), next(NULL) {}
7 7 * };
8 8 */
9 9 class Solution {
10 10 public:
11 11 vector<int> reversePrint(ListNode* head) {
12 12 vector<int> ans;//存储答案
13 13 if(head == nullptr) return ans;//如果节点为空，输出空数组
14 14 stack<int> tempAns;//辅助栈
15 15 ListNode* temp = head;
16 16 //顺序遍历，将节点值压栈
17 17 while(temp != nullptr){
18 18 tempAns.push(temp->val);
19 19 temp = temp->next;
20 20 }
21 21 while(!tempAns.empty()){//出栈直至栈为空
22 22 ans.push_back(tempAns.top());
23 23 tempAns.pop();
24 24 }
25 25 return ans;//返回答案
26 26 }
27 27 };
复杂度分析
时间复杂度： O(m)。m为链表长度，遍历链表和出栈各需要O(m)时间。
空间复杂度： O(m)。辅助栈的空间消耗。
解法二 递归
解题思路
也可以借助递归一直递推至链表尾部再层层回溯以实现反向输出。这样的方法代码简洁，但是调用函数时间消耗较大。
代码
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 vector<int> reversePrint(ListNode* head) {
12 if(head==nullptr) return ans;//如果头结点为空，返回空数组
13 reversePrint(head->next);//递推
14 ans.push_back(head->val);//回溯，持续存值
15 return ans;//返回答案
16 }
17
18 vector<int> ans;
19 };
复杂度分析
时间复杂度： O(m)。递归的时间消耗
空间复杂度： O(m)。递归的空间消耗。
题目二 反转链表
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof/
1.描述
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
2.示例
- 示例 1：
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
解法一 迭代+辅助栈
解题思路
参考题目一，我们可以写出迭代+辅助栈的版本。首先遍历链表将节点存入辅助栈，然后再倒序遍历辅助栈并将每个节点的next指针指向前一个节点。
代码
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode* reverseList(ListNode* head) {
12 if(head==nullptr || head->next==nullptr) return head;//如果头结点为空或者只有一个节点，返回其本身
13 vector<ListNode*> aid;//辅助栈
14 while(head!=nullptr){//顺序遍历链表并压栈
15 aid.push_back(head);
16 head = head -> next;
17 }
18 ListNode* ans = new ListNode(0);//假头节点
19 ListNode* temp = ans;
20 for(int i = aid.size()-1; i >= 0; --i){//倒序遍历节点并修改next指针
21 temp -> next = aid[i];
22 temp = temp -> next;
23 }
24 temp -> next = nullptr;
25 return ans->next;//返回翻转后的链表头节点
26 }
27 };
复杂度分析
时间复杂度： O(m)。m为链表长度，遍历链表和倒序遍历修改next指针各需要O(m)时间。
空间复杂度： O(m)。辅助栈的空间消耗。
解法二 迭代+三指针
解题思路
解法一的辅助栈耗费了大量空间，实际上只需要使用三指针即可。我们使用指针prePtr，curPtr，nextPtr分别指向上一节点，当前节点，下一节点。初始时，prePtr，curPtr，nextPtr分别为nullptr，head以及head->next，然后顺序遍历链表，将curPtr指向节点的next指针修改，使其指向prePtr指向的节点，之后更新三个指针，使其分别后移以为。遍历完成后，返回当前curPtr即为答案。
代码
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode* reverseList(ListNode* head) {
12 if(head==nullptr || head->next==nullptr) return head;//若头结点为空或只有一个节点，直接返回其本身
13 ListNode* prePtr = nullptr;//上一节点
14 ListNode* curPtr = head;//当前节点
15 ListNode* nextPtr = head->next;//下一节点
16 while(nextPtr != nullptr){//依次遍历翻转
17 curPtr -> next = prePtr;
18 prePtr = curPtr;
19 curPtr = nextPtr;
20 nextPtr = nextPtr -> next;
21 }
22 curPtr -> next = prePtr;
23 return curPtr;//返回答案
24 }
25 };
复杂度分析
时间复杂度： O(m)。遍历链表的时间消耗。
空间复杂度： O(1)。只需常数个额外变量即可。
解法三 递归
解题思路
除此之外，我们还可以使用递归方法解决本题。一般来说递归的代码比较简洁，就是有的地方不容易想。这里再提供递归版本代码，供大家加深对递归的理解。
代码
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode* reverseList(ListNode* head) {
12 if(head==nullptr) return head;
13 ListNode* temp = head -> next;
14 head -> next = ans;
15 ans = head;
16 reverseList(temp);
17 return ans;
18 }
19 ListNode* ans = nullptr;
20 };
复杂度分析
时间复杂度： O(m)。递归的时间消耗
空间复杂度： O(m)。递归的空间消耗。
题目三 复杂链表的深拷贝
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fu-za-lian-biao-de-fu-zhi-lcof/
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作为传入参数。
2.示例
- 示例 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。
解法一 暴力遍历
解题思路
可以立马想到的暴力方法就是遍历链表，使用双指针对旧链表和新链表进行同步，先创建random指针指向全为空的新链表；然后对新链表的每个节点，使用上一步的双指针同步方法再次遍历旧链表找到正确的random指向。
代码
1 /*
2 // Definition for a Node.
3 class Node {
4 public:
5 int val;
6 Node* next;
7 Node* random;
8
9 Node(int _val) {
10 val = _val;
11 next = NULL;
12 random = NULL;
13 }
14 };
15 */
16 class Solution {
17 public:
18 Node* copyRandomList(Node* head) {
19 if(head == NULL || head->next == NULL)//若头结点为空或只有头结点
20 {
21 if(head == NULL)//如果头结点为空
22 {
23 return NULL;//则直接返回头结点
24 }
25 else//如果只有头结点
26 {
27 Node* NewHead = new Node(0);//新链表的头结点
28 NewHead->val = head -> val;//将头结点进行复制
29 NewHead -> next = NULL;//因为只有一个节点，next指向NULL
30 if(head -> random == head)
31 {
32 NewHead -> random = NewHead;
33 }
34 else
35 {
36 NewHead -> random = NULL;
37 }
38 return NewHead;
39 }
40 }
41 else//如果不只头结点
42 {
43 vector<int> randomPosition;//新建一个数组，用于记忆各个节点random指针的指向节点，俩数字一组
44 //例如1 31就代表第一个节点的random指向31节点，25 67就代表节点25
45 //的random指向67节点
46 Node* NewHead = new Node(0);//新链表的头结点
47 Node* Index = head;//采用双指针技术，这个旧链表哨兵指向原链表的当前节点
48 Node* newIndex = NewHead;//这个指针指向新链表的当前节点
49 NewHead->val = head -> val;//将头结点进行复制
50 NewHead -> next = NULL;//因为只有一个节点，next指向NULL
51 NewHead -> random = NULL;//random节点之后统一修改，因为现在新链表还未成型
52 Index = Index -> next;//头结点复制完毕，旧链表哨兵向后位移指向下一个节点
53 Node* positionOfRandom = NULL;//用来遍历旧链表确定random指向的游标
54 if(head -> random == NULL)//如果旧链表头结点的random指向NULL
55 {
56 // NewHead -> random = NULL;//则新链表头结点random也指向NULL
57 randomPosition.push_back(1);//1入数组，表示这是第一个节点
58 randomPosition.push_back(0);//0入数组，表示该节点的random指针指向null
59 }
60 else//如果头节点random指向不为空，寻找头结点random指向位置
61 {
62 randomPosition.push_back(1);//1入数组，表示这是第一个节点
63 int flag = 1;//用来记录random指向节点位置
64 positionOfRandom = head;//游标指向头节点
65 while(positionOfRandom != head -> random)//游标持续移动直到找到random指向位置
66 {
67 flag++;
68 positionOfRandom = positionOfRandom -> next;
69 }
70 randomPosition.push_back(flag);//记录位置的整数入数组
71 }
72 int count = 1;//记录做到第几个节点了
73 while(Index != NULL)//每复制完一个节点旧链表哨兵向后位移一个节点，直到全部复制完毕
74 {
75 /***************进行节点复制工作************************************************/
76 count++;//处理的节点数+1
77 Node* temp = new Node(0);//新建一个节点
78 temp -> next = NULL;//先将next指向空
79 temp -> random = NULL;//先将random指向空
80 temp->val = Index->val;//将旧节点的值复制过来
81 newIndex->next = temp; //将新建节点链到新链表尾部
82
83 /**************确定该节点random指向****************************************/
84 randomPosition.push_back(count);//count入数组，表示这是第count个节点
85 if(Index -> random == NULL)//如果旧链表该结点的random指向NULL
86 {
87 randomPosition.push_back(0);//则用0记录新链表该节点random也指向NULL
88 }
89 else//如果旧链表该节点random指向不为空，寻找该结点random指向位置
90 {
91 int flag = 1;//用来记录random指向节点位置
92 positionOfRandom = head;//游标指向头节点
93 // Node* nonius = head -> random;
94 while(positionOfRandom != Index -> random)//游标持续移动直到找到random指向位置
95 {
96 flag++;
97 positionOfRandom = positionOfRandom -> next;
98 }
99 randomPosition.push_back(flag);//记录位置的整数入数组
100 }
101
102 Index = Index -> next;//处理完一个节点后俩游标向后位移一个位置
103 newIndex = newIndex -> next;
104 }
105
106 /***********根据之前建立的辅助数组完成random指向工作*************************************/
107 //该步骤同样采用双哨兵技术
108 newIndex = NewHead;
109 for(int i = 0, j = 2; i < count; i++, j = j + 2)
110 {
111 if(randomPosition[j-1] == 0)
112 {
113 newIndex -> random = NULL;
114 }
115 else
116 {
117 positionOfRandom = NewHead;
118 for(int k = 0; k < randomPosition[j-1]-1; k++)
119 {
120 positionOfRandom = positionOfRandom -> next;
121 }
122 newIndex -> random = positionOfRandom;
123 }
124 newIndex = newIndex -> next;
125 }
126 return NewHead;
127 }
128 }
129 };
复杂度分析
时间复杂度： O(m²)。m为链表长度，建新链表和修改random指针的时间消耗分别为O(m)和O(m²)。
空间复杂度： O(1)。只需要常数个额外变量。
解法二 递归+哈希表
解题思路
对于普通链表的深拷贝，我们只需要顺次遍历然后新建对应节点就可以了。但本题的难点在于，我们新建一个节点并给random指针确定指向时，它应该指向的那个节点可能还不存在。于是我们可以在新建一个节点时，递归的新建他的后继节点和random指针指向的节点。为了防止重复新建节点，我们使用哈希表标记该节点是否已有，如果有直接取用该节点，如果没有，则新建它。
递归代码通常比较简洁，但是有的递归较难以理解，需要多加练习，多读代码，以加深理解。
代码
1 /*
2 // Definition for a Node.
3 class Node {
4 public:
5 int val;
6 Node* next;
7 Node* random;
8
9 Node(int _val) {
10 val = _val;
11 next = NULL;
12 random = NULL;
13 }
14 };
15 */
16 class Solution {
17 private:
18 unordered_map<Node*, Node*> created;//已建节点
19 public:
20 Node* copyRandomList(Node* head) {
21 if(head==nullptr) return head;//如果该节点为空，返回其本身
22 if(!created.count(head)){//如果该节点未建立
23 Node* temp = new Node(head->val);//新建该节点
24 created[head] = temp;//标记该节点已建立
25 temp -> next = copyRandomList(head->next);//递归建立其后继节点
26 temp -> random = copyRandomList(head->random);//递归建立其random指针指向的节点
27 }
28 return created[head];//返回新链表
29 }
30 };
复杂度分析
时间复杂度： O(m)。递归建立新链表的时间消耗。
空间复杂度： O(m)。哈希表的空间消耗。
解法三 迭代 + 哈希表
解题思路
除了递归+哈希外，本题还可以使用迭代+哈希的方式解决，该方法相较于上一方法更好理解。
与上一方法不同的是，我们只关注当前节点random指针应指向的节点是否存在，并不关注当前节点的random指针应该指向的节点的random指针应指向的节点存不存在，也即不会直接递归创建一条链路上的全部节点（上一方法中，只要random指针指向的节点不存在，就会递归创建。），如果不存在，创建之，并标记旧链表中对应节点的新节点已创建。
具体的，我们使用pre指针指向上一个节点，cur指针指向当前工作节点，初始时pre指向一个新建的假头节点，cur指向旧链表头节点。我们从头节点开始依次遍历各个节点，首先查表判断该节点是否已存在，如果已存在，直接取用之，将pre指针指向的节点的next指针指向已新建本节点，否则创建之。之后判断其random指向是否为空或者已存在，已存在则调用之，不存在则创建之，并将本节点random指针指向它。最后更新cur指针指向本节点的下一节点继续遍历。
代码
1 ```cpp
2 class Solution {
3 private:
4 unordered_map<Node*, Node*> created;
5 public:
6 Node* copyRandomList(Node* head) {
7 if(head==nullptr) return head;//如果头结点为空，返回其本身
8 Node* pre = new Node(0);//假头节点，用于避免边界判断带来的麻烦
9 Node* cur = head;//当前指针指向头节点
10 while(cur!=nullptr){//依次遍历链表各节点，同时构造新链表
11 if(!created.count(cur)){//如果当前指针指向的旧链表节点未被创建（其有可能在之前的节点完善random指针时被创建）
12 created[cur] = new Node(cur->val);//则创建之
13 }//如果已被创建则直接使用之
14 pre -> next = created[cur];//将前一节点的next指针指向本节点
15 pre = pre -> next;//更新pre指针指向本节点
16 if(cur->random == nullptr) created[cur] -> random = nullptr;//若该节点的random指针指向空，则新链表中的也指向空
17 else{//否则完善其random指针指向
18 if(!created.count(cur->random)){//如果其random应指向的节点还未创建
19 created[cur->random] = new Node(cur->random->val);//则创建之
20 }//并将random指针指向他
21 created[cur]->random = created[cur->random];
22 }
23 cur = cur -> next;//更新当前工作指针指向本节点的下一节点
24 }
25 return created[head];//返回答案
26 }
27 };
复杂度分析
时间复杂度： O(m)。遍历一次链表的时间消耗
空间复杂度： O(m)。哈希表的空间消耗。
解法四 迭代
解题思路
在上述方法中，因为使用了哈希表，所以空间复杂度比较高。这里有另外的一种方法，可以实现O(1)空间复杂度。
具体的，我们首先遍历一遍旧链表，并新建复制节点，注意，这次我们将新建的节点直接链接在原节点的后边，同时保持链表的完整性。
例如对于链表A→B→C，我们可以将其拆分为A → A′→ B → B′→ C → C′。对于任意一个原节点S，其拷贝节点S'即为其后继节点。
通过这样的方式，我们很容易就能找到新节点的random节点所指向的正确节点，因为他们就是旧链表中原节点中random指针指向节点的后继结点或者空节点，通过一次遍历我们就能完善所有节点的random指针。最后，再通过一次遍历将两个链表断开，即可完成深拷贝操作。注意，原链表也必须还原，不然无法通过。
代码
1 class Solution {
2 public:
3 Node* copyRandomList(Node* head) {
4 if(!head) return head;//如果头结点为空，返回其本身
5
6 //第一次遍历，将拷贝节点链接到原节点之后，使其成为原节点的后继结点
7 Node* temp = head;
8 while(temp!=nullptr){
9 Node* newNode = new Node(temp->val);
10 newNode -> next = temp -> next;
11 newNode -> random = temp -> random;
12 temp -> next = newNode;
13 temp = newNode -> next;
14 }
15
16 //第二次遍历，完善各拷贝节点的random指向
17 temp = head;
18 Node* ans = head -> next;
19 while(temp!=nullptr){
20 if(temp->next->random != nullptr){
21 temp->next->random = temp->next->random->next;
22 }
23 temp = temp -> next -> next;
24 }
25
26 //第三次遍历，将新旧链表断链并恢复原链表
27 temp = head;
28 while(temp!=nullptr){
29 Node* copy = temp -> next -> next;
30 if(!copy) break;
31 temp -> next -> next = copy -> next;
32 temp -> next = copy;
33 temp = copy;
34 }
35 temp -> next = nullptr;
36 return ans;
37 }
38 };
复杂度分析
时间复杂度： O(m)。遍历一次链表的时间消耗
空间复杂度： O(1)。只需常数个额外变量。
Tips：
在上面的分析中可以看到，对于涉及链表的，包含增删等操作时，使用假头/尾节点可以避免很多边界判断带来的麻烦。这一点可以在解题过程中多加应用。
更多知识内容分享：
力扣个人主页https://leetcode-cn.com/profile/articles/
CSDN个人主页https://blog.csdn.net/qq_39255924
牛客个人主页https://blog.nowcoder.net/newcoderthewarrior