针对链表的插入、删除操作,需要对插入第一个结点和删除最后一个结点的情况进行特殊处理。这样代码实现起来就会很繁琐,不简洁,而且也容易因为考虑不全而出错。如何来解决这个问题呢?
技巧三中提到的哨兵就要登场了。哨兵,解决的是国家之间的边界问题。同理,这里说的哨兵也是解决“边界问题”的,不直接参与业务逻辑。如果我们引入哨兵结点,在任何时候,不管链表是不是空,head 指针都会一直指向这个哨兵结点。我们也把这种有哨兵结点的链表叫带头链表。相反,没有哨兵结点的链表就叫作不带头链表。哨兵结点是不存储数据的。因为哨兵结点一直存在,所以插入第一个结点和插入其他结点,删除最后一个结点和删除其他结点,都可以统一为相同的代码实现逻辑了。
我经常用来检查链表代码是否正确的边界条件有这样几个:
如果链表为空时,代码是否能正常工作?
如果链表只包含一个结点时,代码是否能正常工作?
如果链表只包含两个结点时,代码是否能正常工作?
代码逻辑在处理头结点和尾结点的时候,是否能正常工作?
删除链表倒数第n个结点
方法一:一次遍历算法
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
if(head==nullptr || n<1)
return nullptr;
ListNode *res_head = head;
ListNode *back = head;
ListNode *front = head;
int count = n;
while(front->next!=NULL && count>0){
front = front->next;
--count;
}
if(count>1){
//输入的n大于链表的长度,n无效
return nullptr;
}
if(count==1){
//count==1 则链表的长度等于n
if(n==1){
//链表长度为1,移除头结点,返回空指针
return nullptr;
}else{
//链表长度大于1,移除头结点,返回头结点->next
res_head = res_head->next;
delete head;
return res_head;
}
}
if(count==0){
while(front->next != NULL){
front = front->next;
back = back->next;
}
ListNode *deletenode = back->next;
back->next = back->next->next;
delete deletenode;
return res_head;
}
}
};
Complexity Analysis
Time complexity : O(L)
The algorithm makes one traversal of the list of L nodes. Therefore time complexity is O(L).
Space complexity : O(1).
We only used constant extra space.
方法二:两次遍历算法
思路
我们注意到这个问题可以容易地简化成另一个问题:删除从列表开头数起的第 (L - n + 1)个结点,其中 L 是列表的长度。只要我们找到列表的长度 LL,这个问题就很容易解决。
算法
首先我们将添加一个哑结点作为辅助,该结点位于列表头部。哑结点用来简化某些极端情况,例如列表中只含有一个结点,或需要删除列表的头部。在第一次遍历中,我们找出列表的长度 LL。然后设置一个指向哑结点的指针,并移动它遍历列表,直至它到达第 (L - n) 个结点那里。我们把第 (L - n) 个结点的 next
指针重新链接至第 (L - n + 2) 个结点,完成这个算法。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode *dummy = new ListNode(0);
dummy->next = head;
int length = 0;
ListNode first = head;
while (first != null) {
length++;
first = first->next;
}
length -= n;
first = dummy;
while (length > 0) {
length--;
first = first->next;
}
first->next = first->next->next;
return dummy->next;
}
};
方法三:一次遍历算法
算法
上述算法可以优化为只使用一次遍历。我们可以使用两个指针而不是一个指针。第一个指针从列表的开头向前移动 n+1 步,而第二个指针将从列表的开头出发。现在,这两个指针被 n 个结点分开。我们通过同时移动两个指针向前来保持这个恒定的间隔,直到第一个指针到达最后一个结点。此时第二个指针将指向从最后一个结点数起的第 n个结点。我们重新链接第二个指针所引用的结点的 next
指针指向该结点的下下个结点。
两个有序链表的合并
Example:
Input: 1->2->4, 1->3->4
Output: 1->1->2->3->4->4
方法一:迭代法
class Solution {
public:
ListNode * mergeTwoLists(ListNode* l1, ListNode* l2) {
if (l1 == nullptr && l2 == nullptr) return nullptr;
if (l1 == nullptr) return l2;
if (l2 == nullptr) return l1;
ListNode *head = nullptr,*now = nullptr;
ListNode *L1 = l1, *L2 = l2;
while (L1 != nullptr || L2 != nullptr) {
//当L1为nullptr时,L2一定不为nullptr
if (L1 == nullptr) {
now->next = L2;
break;
}
//当L2为nullptr时,L1一定不为nullptr
if (L2 == nullptr) {
now->next = L1;
break;
}
//当L1和L2均不为空时
if (head == nullptr) {
if (L1->val < L2->val) {
head = L1;
now = head;
L1 = L1->next;
}
else {
head = L2;
now = head;
L2 = L2->next;
}
}
else {
if (L1->val < L2->val) {
now->next = L1;
now = now->next;
L1 = L1->next;
}
else {
now->next = L2;
now = now->next;
L2 = L2->next;
}
}
}
return head;
}
};
方法二:递归法
第一次进入if(l1->val < l2->val) 判断的时候的return即为最终返回的头结点。这个函数的目的是返回当前两个参数中val值较小的那个节点指针,并令这个指针指向下一个val值最小的节点。当两个参数中有一个为nul时,直接将另一个参数剩余的所有链表直接连接在要返回的链表后面。
class Solution {
public:
ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
if(l1 == NULL) return l2;
if(l2 == NULL) return l1;
if(l1->val < l2->val) {
l1->next = mergeTwoLists(l1->next, l2);
return l1;
} else {
l2->next = mergeTwoLists(l2->next, l1);
return l2;
}
}
};
This solution is not a tail-recursive, the stack will overflow while the list is too long :)
链表中环的检测
方法一:双指针法
思路
想象一下,两名运动员以不同的速度在环形赛道上跑步会发生什么?
算法
通过使用具有 不同速度 的快、慢两个指针遍历链表,空间复杂度可以被降低至 O(1)O(1)。慢指针每次移动一步,而快指针每次移动两步。
如果列表中不存在环,最终快指针将会最先到达尾部,此时我们可以返回 false
。
现在考虑一个环形链表,把慢指针和快指针想象成两个在环形赛道上跑步的运动员(分别称之为慢跑者与快跑者)。而快跑者最终一定会追上慢跑者。这是为什么呢?考虑下面这种情况(记作情况 A) - 假如快跑者只落后慢跑者一步,在下一次迭代中,它们就会分别跑了一步或两步并相遇。
其他情况又会怎样呢?例如,我们没有考虑快跑者在慢跑者之后两步或三步的情况。但其实不难想到,因为在下一次或者下下次迭代后,又会变成上面提到的情况 A。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
bool hasCycle(ListNode *head) {
if(head == nullptr || head->next==nullptr){
return false;
}
ListNode *fast = head->next;
ListNode *slow = head;
while(fast!=nullptr && fast->next!=nullptr){
slow = slow->next;
fast = fast->next->next;
if(slow==fast){
return true;
}
}
return false;
}
};
方法二:
用 set 存储 判断每次存入 next 结点后 set 的 size()有没有发生变化,没有发生变化说明这个结点已经被存储过了,就说明是个环。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
bool hasCycle(ListNode *head) {
if(head == nullptr || head->next==nullptr){
return false;
}
std::unordered_set<ListNode *> s;
int cnt = 0;
while(head!=nullptr){
s.insert(head);
if(cnt==s.size()){
return true;
}
cnt = s.size();
head = head->next;
}
return false;
}
};
反转单链表
方法一:递归法
【数据结构与算法】为什么你学不会递归?告别递归,谈谈我的一些经验
1、定义递归函数功能
假设函数 reverseList(head) 的功能是反转但链表,其中 head 表示链表的头节点。
2. 寻找结束条件
当链表只有一个节点,或者如果是空表的话,你应该知道结果吧?直接啥也不用干,直接把 head 返回呗。代码如下:
3. 寻找等价关系
这个的等价关系不像 n 是个数值那样,比较容易寻找。但是我告诉你,它的等价条件中,一定是范围不断在缩小,对于链表来说,就是链表的节点个数不断在变小,所以,如果你实在找不出,你就先对 reverseList(head.next) 递归走一遍,看看结果是咋样的。例如链表节点如下
我们就缩小范围,先对 2->3->4递归下试试
我们在第一步的时候,就已经定义了 reverseLis t函数的功能可以把一个单链表反转,所以,我们对 2->3->4反转之后的结果应该是这样:
我们把 2->3->4 递归成 4->3->2。不过,1 这个节点我们并没有去碰它,所以 1 的 next 节点仍然是连接这 2。
接下来呢?该怎么办?
其实,接下来就简单了,我们接下来只需要把节点 2 的 next 指向 1,然后把 1 的 next 指向 null,不就行了?,即通过改变 newList 链表之后的结果如下:
也就是说,reverseList(head) 等价于 ** reverseList(head.next)** + 改变一下1,2两个节点的指向。好了,等价关系找出来了,代码如下(有详细的解释):
/**
* 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 *new_end = head->next;
ListNode* res = reverseList(head->next);
new_end->next = head;
head->next = nullptr;
return res;
}
};
方法二:迭代法
/**
* 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 *cursor = head;
ListNode *next = head->next;
head->next = nullptr;
while(next!=nullptr){
ListNode *temp = next->next;
next->next = cursor;
cursor = next;
next = temp;
}
return cursor;
}
};
给定一个带有头结点 head
的非空单链表,返回链表的中间结点。
如果有两个中间结点,则返回第二个中间结点。
方法一:输出到数组
思路和算法
按顺序将每个结点放入数组 A
中。然后中间结点就是 A[A.Length/2]
,因为我们可以通过索引检索每个结点。
class Solution {
public:
ListNode* middleNode(ListNode* head) {
if(head==nullptr || head->next==nullptr){
return head;
}
vector<ListNode*> A = {head};
while (A.back()->next != NULL)
A.push_back(A.back()->next);
return A[A.size() / 2];
}
};
方法二:快慢指针法
思路和算法
当用慢指针 slow
遍历列表时,让另一个指针 fast
的速度是它的两倍。当 fast
到达列表的末尾时,slow
必然位于中间。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* middleNode(ListNode* head) {
if(head==nullptr || head->next==nullptr){
return head;
}
ListNode *slow = head, *fast = head;
while(fast->next!=nullptr){
slow = slow->next;
fast=fast->next->next;
if(fast==nullptr)
break;
}
return slow;
}
};