链表类(Linked List)
基础知识
链表如何实现,如何遍历链表。链表可以保证头部尾部插入删除操作都是O(1),查找任意元素位置O(N)
基础题目
题目:Leetcode 206. Reverse Linked List
题解
方法1:迭代
假设链表为1→2→3→∅
,我们想要把它改成 ∅←1←2←3
。
在遍历链表时,将当前节点的next
指针改为指向前一个节点。由于节点没有引用其前一个节点,因此必须事先存储其前一个节点。在更改引用之前,还需要存储后一个节点。最后返回新的头引用。
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* pre = nullptr;
ListNode* cur = head;
while (cur != nullptr) {
ListNode* next = cur->next;
cur->next = pre;
pre = cur;
cur = next;
}
return pre;
}
};
方法2:递归
链表:1→2→3→4→5→6→∅
其中1→[2→3→4→5→6→∅]
括号部分看作已经反转好了,1
看作head
,[]
整体看作next
:
步骤1:head->next->next = head;
实现了1⬅[2→3→4→5→6→∅]
步骤2:head->next = nullptr;
实现了∅⬅1⬅[2→3→4→5→6→∅]
步骤3:return p;
实现了返回新的头节点[2→3→4→5→6→∅]
class Solution {
public:
ListNode* reverseList(ListNode* head) {
// 链表为空 或 链表只有一个节点(递归终止)
if (head == nullptr || head->next == nullptr) {
return head;
}
ListNode* p = reverseList(head->next);
head->next->next = head;
head->next = nullptr;
return p;
}
};
题目:Leetcode 876. Middle of the Linked List
给定一个头结点为 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,我们返回第二个结点。
题解
class Solution {
public:
ListNode* middleNode(ListNode* head) {
ListNode* p1 = head;
ListNode* p2 = head;
while (p1->next != nullptr && p2->next != nullptr) {
p1 = p1->next;
p2 = p2->next;
if (p2->next != nullptr) {
p2 = p2->next;
}
}
return p1;
}
};
注意:快慢指针和链表反转几乎是所有链表类问题的基础,尤其是反转链表,代码很短,建议直接背熟。
进阶题目
题目:Leetcode 160. Intersection of Two Linked Lists
给你两个单链表的头节点headA
和headB
,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回null
。
图示两个链表在节点c1
开始相交:
题目数据保证整个链式结构中不存在环。
注意,函数返回结果后,链表必须保持其原始结构。
示例 1:
输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出:Intersected at '8'
解释:相交节点的值为 8 (注意,如果两个链表相交则不能为 0)。
从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,0,1,8,4,5]。
示例 2:
输入: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 。
题解
步骤1:链表1
从头节点开始,走到最后一个节点(不是结束),统计链表1
的长度记为len1
,同时记录链表1
的最后一个节点记为end1
。
步骤2:链表2
从头节点开始,走到最后一个节点(不是结束),统计链表2
的长度记为len2
,同时记录链表2
的最后一个节点记为end2
。
步骤3:如果end1!=end2
,说明两个链表不相交,返回null
即可;如果end1==end2
,说明两个链表相交,进入步骤4来找寻第一个相交节点。
步骤4:如果链表1
比较长,链表1
就先走len1-len2
步;如果链表2
比较长,链表2
就先走len2-len1
步。然后两个链表一起走,一起走的过程中,两个链表第一次走到一起的那个节点就是第一个相交的节点。
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
if (headA == nullptr || headB == nullptr) {
return nullptr;
}
// 第一步:统计链表1的的长度len1,同时记录链表1的尾节点end1
int len1 = 0;
ListNode* end1 = nullptr;
ListNode* cur1 = headA;
while (cur1->next != nullptr) {
cur1 = cur1->next;
len1++;
}
end1 = cur1;
// 第二步:统计链表2的的长度len2,同时记录链表2的尾节点end2
int len2 = 0;
ListNode* end2 = nullptr;
ListNode* cur2 = headB;
while (cur2->next != nullptr) {
cur2 = cur2->next;
len2++;
}
end2 = cur2;
// 第三步:判断链表1和链表2的尾节点是否重合
if (end1 != end2) {
return nullptr;
}
// 第四步:链表1和链表2的尾节点重合,快指针先走|len1-len2|步
// 然后快慢指针一起走,第一次相遇即是第一个相交节点
ListNode* fast = nullptr;
ListNode* slow = nullptr;
int n = 0;
if (len1 > len2) {
n = len1 - len2;
fast = headA;
slow = headB;
while (n > 0) {
fast = fast->next;
n--;
}
} else {
n = len2 - len1;
fast = headB;
slow = headA;
while (n > 0) {
fast = fast->next;
n--;
}
}
while (fast != slow) {
fast = fast->next;
slow = slow->next;
}
return fast;
}
};
题目:Leetcode 141. Linked List Cycle (Linked List Cycle II)
给定一个链表,判断链表中是否有环。
如果链表中有某个节点,可以通过连续跟踪next
指针再次到达,则链表中存在环。 为了表示给定链表中的环,我们使用整数pos
来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果pos
是 -1,则在该链表中没有环。注意:pos
不作为参数进行传递,仅仅是为了标识链表的实际情况。
如果链表中存在环,则返回true
。 否则,返回false
。
进阶:
你能用 O(1)(即,常量)内存解决此问题吗?
示例 1:
输入:head = [3,2,0,-4], pos = 1
输出:true
解释:链表中有一个环,其尾部连接到第二个节点。
示例 2:
输入:head = [1,2], pos = 0
输出:true
解释:链表中有一个环,其尾部连接到第一个节点。
示例 3:
输入:head = [1], pos = -1
输出:false
解释:链表中没有环。
题解
步骤1:设置一个慢指针slow
和一个快指针fast
。在开始时,slow
和fast
都指向链表的头节点head
。然后slow
每次移动一步,fast
每次移动两步,在链表中遍历起来。
步骤2:如果链表无环,那么fast
指针在移动过程中一定先遇到终点,一旦fast
到达终点,说明链表是没有环的,直接返回null
,表示该链表无环,当然也没有第一个入环的节点。
步骤3:如果链表有环,fast
指针和slow
指针一定会在环中的某个位置相遇,当fast
和slow
相遇时,fast
指针重新回到head
的位置,slow
指针不动。接下来,fast
指针从每次移动两步改为每次移动一步,slow
指针依然每次移动一步,然后继续遍历。
步骤4:快指针fast
和慢指针slow
一定会再次相遇,并且在第一个入环的节点处相遇。证明略。
class Solution {
public:
bool hasCycle(ListNode *head) {
if (head == nullptr || head->next == nullptr || head->next->next == nullptr) {
return false;
}
ListNode* fast = head;
ListNode* slow = head;
while (fast->next != nullptr && slow->next != nullptr) {
slow = slow->next;
fast = fast->next;
if (fast->next != nullptr) {
fast = fast->next;
}
if (fast == slow) {
return true;
}
}
return false;
}
};
题目:Leetcode 92. Reverse Linked List II
给你单链表的头指针head
和两个整数left
和right
,其中left <= right
。请你反转从位置left
到位置right
的链表节点,返回反转后的链表 。
示例 1:
输入:head = [1,2,3,4,5], left = 2, right = 4
输出:[1,4,3,2,5]
示例 2:
输入:head = [5], left = 1, right = 1
输出:[5]
题解
分两种情况:
情况1:从原链表的首位开始反转,则反转后的链表头为反转部分的右节点rightNode
,且只需处理反转部分的头部,如下:
leftNode->next = rightNodeNext;
情况2:从原链表的非首位开始反转,则反转后的链表头仍未原链表的头节点head
,且反转部分的两端都需要处理,如下:
leftNodePre->next = pre;
leftNode->next = rightNodeNext;
ListNode* reverseBetween(ListNode* head, int left, int right) {
if (head == nullptr || left == right) {
return head;
}
// 从1位置开始反转
if (left == 1) {
ListNode* curNode = head;
// 找到需要反转部分的右节点
ListNode* rightNodeNext = nullptr; // 记录反转部分右点的下一个节点
ListNode* rightNode = nullptr;
while (right > 0) {
rightNode = curNode;
right--;
curNode = curNode->next;
rightNodeNext = curNode;
}
ListNode* leftNode = head; // 反转部分的左节点
ListNode* pre = nullptr;
ListNode* cur = leftNode;
while (cur != rightNodeNext) {
ListNode* next = cur->next;
cur->next = pre;
pre = cur;
cur = next;
}
leftNode->next = rightNodeNext;
return rightNode;
} else { // 不从1位置开始反转
// 找需要反转部分的左节点的前一个节点
int count = left - 1;
ListNode* curNode = head;
ListNode* leftNodePre = nullptr; // 记录反转部分左节点的前一个节点
while (count > 0) {
leftNodePre = curNode;
curNode = curNode->next;
count--;
}
// 找到需要反转部分的左节点
ListNode* leftNode = nullptr;
curNode = head;
int n = left;
while (left > 0) {
leftNode = curNode;
left--;
curNode = curNode->next;
}
curNode = head;
// 找到需要反转部分的右节点
ListNode* rightNodeNext = nullptr; // 记录反转部分右点的下一个节点
ListNode* rightNode = nullptr;
while (right > 0) {
rightNode = curNode;
right--;
curNode = curNode->next;
rightNodeNext = curNode;
}
// 反转
ListNode* pre = nullptr;
curNode = leftNode;
while (curNode != rightNodeNext) {
ListNode* next = curNode->next;
curNode->next = pre;
pre = curNode;
curNode = next;
}
leftNodePre->next = pre;
leftNode->next = rightNodeNext;
return head;
}
}
题目:Leetcode 328. Odd Even Linked List
给定一个单链表,把所有的奇数节点和偶数节点分别排在一起。请注意,这里的奇数节点和偶数节点指的是节点编号的奇偶性,而不是节点的值的奇偶性。
请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1),时间复杂度应为 O(nodes),nodes 为节点总数。
示例 1:
输入: 1->2->3->4->5->NULL
输出: 1->3->5->2->4->NULL
示例 2:
输入: 2->1->3->5->6->4->7->NULL
输出: 2->3->6->7->1->5->4->NULL
说明:
- 应当保持奇数节点和偶数节点的相对顺序。
- 链表的第一个节点视为奇数节点,第二个节点视为偶数节点,以此类推
题解
class Solution {
public:
ListNode* oddEvenList(ListNode* head) {
if (head == nullptr || head->next == nullptr) {
return head;
}
ListNode* odd = head; // 奇数首个节点
ListNode* even = head->next; // 偶数首个节点
ListNode* dummyEnvenHead = new ListNode(-1); // 偶数链表的虚拟头节点
dummyEnvenHead->next = even;
while (odd->next != nullptr && even->next != nullptr) {
// 找到下一个目标节点
odd->next = odd->next->next;
even->next = even->next->next;
// 尾接下一个目标节点
even = even->next;
odd = odd->next;
}
odd->next = dummyEnvenHead->next; // 奇数尾节点->偶数头节点
return head;
}
};