链表
24 两两交换链表中的结点
题目描述
给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
1234变2143
代码
迭代法。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
ListNode* dummyHead = new ListNode(0);
dummyHead->next = head;
ListNode* pre = dummyHead;
ListNode* cur = dummyHead->next;
while(cur != NULL && cur->next != NULL)
{
ListNode* tmp = cur->next;
pre->next = tmp;
cur->next = tmp->next;
tmp->next = cur;
pre = cur;
cur = cur->next;
}
return dummyHead->next;
}
};
复杂度
时间复杂度:O(n),其中 n 是链表的节点数量。需要对每个节点进行更新指针的操作。
空间复杂度:O(1)。
19 删除链表的倒数第N个结点
题目描述
给你一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点。
代码
双指针法,保证fast指向NULL时,slow指向要删除的前一个结点,要删除的结点用tmp表示。slow和fast中间隔着n个结点,故fast一开始走了n+1步,n步在while loop中走,1步单独走。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode* dummyHead = new ListNode(0);
dummyHead->next = head;
ListNode* fast = dummyHead;
ListNode* slow = dummyHead;
while(n--)
{
fast = fast->next;
}
fast = fast->next;
while(fast != NULL)
{
slow = slow->next;
fast = fast->next;
}
ListNode* tmp = slow->next;
slow->next = tmp->next;
delete tmp;
return dummyHead->next;
//以下为自己写的代码,也可以通过。
// int step = 0;
// while(fast->next != NULL)
// {
// step++;
// fast = fast->next;
// }
// step -= n;
// while(step--)
// {
// slow = slow->next;
// }
// ListNode* tmp = slow->next;
// slow->next = tmp->next;
// delete tmp;
// return dummyHead->next;
}
};
复杂度
时间复杂度:O(L),其中 L 是链表的长度。
空间复杂度:O(1)。
面试题 02.07. 链表相交
题目描述
给你两个单链表的头节点 headA 和 headB ,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null 。
题目数据 保证 整个链式结构中不存在环。
注意,函数返回结果后,链表必须保持其原始结构 。
代码
双指针法,p1遍历完A后遍历B,p2遍历B后遍历A,若两者存在相交,则相交点在 p1 == p2处。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
ListNode* p1 = headA;
ListNode* p2 = headB;
while(p1 != p2)
{
if(p1 == NULL)
{
p1 = headB;
}
else
{
p1 = p1->next;
}
if(p2 == NULL)
{
p2 = headA;
}
else
{
p2 = p2->next;
}
}
return p1;
}
};
复杂度
时间复杂度:O(m+n),其中 m 和 n 是分别是链表 headA 和 headB 的长度。两个指针同时遍历两个链表,每个指针遍历两个链表各一次。
空间复杂度:O(1)。
142 环形链表II
题目描述
给定一个链表的头节点 head ,返回链表开始入环的第一个节点。 如果链表无环,则返回 null。
如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。如果 pos 是 -1,则在该链表中没有环。注意:pos 不作为参数进行传递,仅仅是为了标识链表的实际情况。
不允许修改链表。
代码
双指针法,slow走一步,fast走两步。两者相遇的地方到环入口的距离与从head到环入口的距离相同,这是找到环入口的关键。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode* slow = head;
ListNode* fast = head;
while(fast != NULL && fast->next != NULL)
{
slow = slow->next;
fast = fast->next->next;
if(slow == fast)
{
break;
}
}
if(fast == NULL || fast->next == NULL)
{
return NULL;
}
slow = head;
while(slow != fast)
{
slow = slow->next;
fast = fast->next;
}
return slow;
}
};
复杂度
时间复杂度:O(N),其中 N 为链表中节点的数目。在最初判断快慢指针是否相遇时,slow指针走过的距离不会超过链表的总长度;随后寻找入环点时,走过的距离也不会超过链表的总长度。因此,总的执行时间为 O(N)+O(N)=O(N)。
空间复杂度:O(1)。