目录
1.(leetcode 24)两两交换链表中的节点
一定要画图,不画图,操作多个指针很容易乱,而且要操作的先后顺序
初始时,cur指向虚拟头结点,然后进行如下三步:
操作后:
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
ListNode* dummyhead=new ListNode(0);
dummyhead->next=head;
ListNode* cur=dummyhead;
while(cur->next!=NULL &&cur->next->next!=NULL)
{
/*ListNode* temp=cur->next;
cur->next=cur->next->next;
cur->next->next=temp;
cur->next->next->next=temp->next->next;*/
ListNode* tmp = cur->next; // 记录临时节点
ListNode* tmp1 = cur->next->next->next; // 记录临时节点
cur->next = cur->next->next; // 步骤一
cur->next->next = tmp; // 步骤二
cur->next->next->next = tmp1; // 步骤三
cur=cur->next->next;
}
return dummyhead->next;
}
};
- 时间复杂度:O(n)
- 空间复杂度:O(1)
注意事项:一定要画图,不然就会出现cur->next->next->next=temp->next->next中,temp->next->next跟最一开始的cur->next是一样的了,也会造成问题(比如超出时间限制等)
2.(leetcode 19)删除链表的倒数第N个节点
思路:如果要删除倒数第n个节点,让fast移动n步,然后让fast和slow同时移动,直到fast指向链表末尾。删掉slow所指向的节点就可以了(个人想法:fast走了n步,距离末尾l-n步,slow走l-n,则距离末尾n步,符合要求)
- 使用虚拟头结点,这样方便处理删除实际头结点的逻辑
- fast首先走n + 1步 ,为什么是n+1呢,因为只有这样同时移动的时候slow才能指向删除节点的上一个节点(方便做删除操作)(如图)
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode* dummyHead = new ListNode(0);
dummyHead->next = head;
ListNode* slow = dummyHead;
ListNode* fast = dummyHead;
while(n-- && fast != NULL) {
fast = fast->next;
}
fast = fast->next; // fast再提前走一步,因为需要让slow指向删除节点的上一个节点
while (fast != NULL) {
fast = fast->next;
slow = slow->next;
}
slow->next = slow->next->next;
// ListNode *tmp = slow->next; C++释放内存的逻辑
// slow->next = tmp->next;
// delete nth;
return dummyHead->next;
}
};
- 时间复杂度: O(n)
- 空间复杂度: O(1)
3.(leetcode 160)链表相交
思路:求两个链表交点节点的指针。 要注意,交点不是数值相等,而是指针相等
求出两个链表的长度,并求出两个链表长度的差值,然后让curA移动到,和curB 末尾对齐的位置,如图:
此时可以比较curA和curB是否相同,如果不相同,同时向后移动curA和curB,如果遇到curA == curB,则找到交点。否则循环退出返回空指针。
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
ListNode* curA = headA;
ListNode* curB = headB;
int lenA = 0, lenB = 0;
while (curA != NULL) { // 求链表A的长度
lenA++;
curA = curA->next;
}
while (curB != NULL) { // 求链表B的长度
lenB++;
curB = curB->next;
}
curA = headA;
curB = headB;
// 让curA为最长链表的头,lenA为其长度
//void swap(int x, int y) {int temp = y;y = x;x = temp;}在按值传递的情况下,实参的内容没有被改变
if (lenB > lenA) {
swap (lenA, lenB);
swap (curA, curB);
}
// 求长度差
int gap = lenA - lenB;
// 让curA和curB在同一起点上(末尾位置对齐)
while (gap--) {
curA = curA->next;
}
// 遍历curA 和 curB,遇到相同则直接返回
while(curA!=NULL)
{
if(curA==curB)
{
return curA;
}
curA=curA->next;
curB=curB->next;
}
return NULL;
}
};
- 时间复杂度:O(n + m)
- 空间复杂度:O(1)
补充:swap(x,y)
void swap(int x, int y) {
int temp = y;
y = x;
x = temp;
}
x,y并未实现交换:
【原因解析】:
整形x和y在函数swap内为按值传递,按值传递时,函数不会访问当前调用的实参。函数处理的值是它本地的拷贝,这些拷贝被存储在运行栈中,因此改变这些值不会影响实参的值。一旦函数结束了,函数的活动记录将从栈中弹出,这些局部值也就消失了。
4.(leetcode 142)环形链表II
思路:
1)如何判断有环?
分别定义 fast 和 slow 指针,从头结点出发,fast指针每次移动两个节点,slow指针每次移动一个节点,如果 fast 和 slow指针在途中相遇 ,说明这个链表有环。
a.fast指针一定先进入环中,如果fast指针和slow指针相遇的话,一定是在环中相遇
b.为什么fast指针和slow指针一定会相遇呢?
相对于slow来说,fast是一个节点一个节点的靠近slow的,所以fast一定可以和slow重合
2)如果有环,如何找到这个环的入口
slow指针走过的节点数为: x + y
, fast指针走过的节点数:x + y + n (y + z)
2(x+y)=x+y+n(y+z) 则x=n(y+z)-y=(n-1)(y+z)+z (
要求的是x,因为x表示 头结点到 环形入口节点的的距离,将x单独放在左面)
n≥1
1)n=1时,公式就化解为 x = z
,
从头结点出发一个指针,从相遇节点 也出发一个指针,这两个指针每次只走一个节点, 那么当这两个指针相遇的时候就是 环形入口的节点。
也就是在相遇节点处,定义一个指针index1,在头结点处定一个指针index2。
让index1和index2同时移动,每次移动一个节点, 那么他们相遇的地方就是 环形入口的节点。
2)n>1时
和n为1的时候 效果是一样的,一样可以通过这个方法找到 环形的入口节点,只不过,index1 指针在环里 多转了(n-1)圈,然后再遇到index2,相遇点依然是环形的入口节点
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode* fast = head;
ListNode* slow = head;
while(fast != NULL && fast->next != NULL) {
slow = slow->next;
fast = fast->next->next;
// 快慢指针相遇,此时从head 和 相遇点,同时查找直至相遇
if (slow == fast) {
ListNode* index1 = fast;
ListNode* index2 = head;
while (index1 != index2) {
index1 = index1->next;
index2 = index2->next;
}
return index2; // 返回环的入口
}
}
return NULL;
}
};
- 时间复杂度: O(n),快慢指针相遇前,指针走的次数小于链表长度,快慢指针相遇后,两个index指针走的次数也小于链表长度,总体为走的次数小于 2n
- 空间复杂度: O(1)
补充:
为什么第一次在环中相遇,slow的 步数 是 x+y 而不是 x + 若干环的长度 + y 呢?
首先slow进环的时候,fast一定是先进环来了。
1)如果slow进环入口,fast也在环入口,那么把这个环展开成直线,就是如下图的样子
如果slow 和 fast同时在环入口开始走,一定会在环入口3相遇,slow走了一圈,fast走了两圈。
2)slow进环的时候,fast一定是在环的任意一个位置,如图:
fast指针走到环入口3的时候,已经走了k + n 个节点,slow相应的应该走了(k + n) / 2 个节点。
因为k是小于n的(图中可以看出),所以(k + n) / 2 一定小于n。也就是说slow一定没有走到环入口3,而fast已经到环入口3了。在slow开始走的那一环已经和fast相遇了。
同时,fast相对于slow是一次移动一个节点,所以不可能跳过去。疑问结束!