代码随想录算法训练营day04

Leetcode24.两两交换链表中的节点 

Leetcode24题目链接

1.思路

重点：

1. 画图将3个步骤的顺序搞清楚

2. 注意循环条件：只剩1个节点或者0个节点就不交换了---->while(cur->next!=NULL&&cur->next->next!=NULL)

3. 注意每次交换中有两个临时变量需要保存，否则链表会断：temp1,temp2

4. 每次是处理两个节点，所以：cur=cur->next->next

2.代码

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyhead=new ListNode(0);
        dummyhead->next=head;
        ListNode* cur=dummyhead;
        ListNode* temp1;
        ListNode* temp2;
        while(cur->next!=NULL&&cur->next->next!=NULL){
            temp1=cur->next;
            temp2=cur->next->next->next;
            cur->next=cur->next->next;//步骤一
            cur->next->next=temp1;//步骤二
            temp1->next=temp2;//步骤三

            cur=cur->next->next;//交换下一组两个节点
        }
        ListNode* result=dummyhead->next;
        delete dummyhead;
        return result;
    }
};

3.复杂度分析

时间复杂度：O(n)

空间复杂度：O(1)

4.Reference:代码随想录

Leetcode19.删除链表倒数第N个节点

Leetcode19题目链接

1.思路

使用快慢指针可以一次遍历就完成操作

重点：

1. 画图确定fast指针要先移动多少，并且fast和slow一起移动时的终止条件

2. 注意在进行dummyhead的创建过程中，不要忘记dummyhead->next=head(初始化)

2.代码

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!=NULL){
            fast=fast->next;//fast先走n步
        }
        while(fast->next!=NULL){//使得fast走到最后一个节点
            fast=fast->next;
            slow=slow->next;
        }
        //此时slow已经位于要删除节点的前一个位置了
        slow->next=slow->next->next;
        ListNode* result;
        result=dummyhead->next;
        delete dummyhead;
        return result;
    }
};

3.复杂度分析

时间复杂度：O(n)

空间复杂度：O(1)

4.Reference:代码随想录

Leetcode160.链表相交

Leetcode160题目链接

1.思路

两个链表的公共部分是在链表末尾，所以先分别遍历两个链表，得到各自的长度，算出distance。再讲长的链表提前移动distance。再同步移动，如果节点相同则返回节点；如果遍历完还不相同则说明没有公共节点，直接返回NULL。

注意：

1.进行遍历得到长度后，要将cur1和cur2重置。

2.代码

class Solution {
public:
    ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
        ListNode* cur1 = headA;
        ListNode* cur2 = headB;
        int lenA = 0;
        int lenB = 0;
        int distance;
        // 分别计算A和B的长度
        while (cur1 != NULL) {
            lenA++;
            cur1 = cur1->next;
        }
        while (cur2 != NULL) {
            lenB++;
            cur2 = cur2->next;
        }
        cur1 = headA;//重置cur1和cur2
        cur2 = headB;
        distance = lenA > lenB ? (lenA - lenB) : (lenB - lenA);
        if (lenA > lenB) {
            while (distance--) {
                cur1 = cur1->next;
            }
        } else {
            while (distance--) {
                cur2 = cur2->next;
            }
        }
        // 此时链表A和链表B一样长
        while (cur1 != NULL) {
            if (cur1 == cur2)
                return cur1;
            else {
                cur1 = cur1->next;
                cur2 = cur2->next;
            }
        }
        return NULL;
    }
};

3.Reference:代码随想录

Leetcode142.环形链表||

Leetcode142题目链接

1.思路

判断是否有环：

用一个fast指针每次移动两步，slow指针每次移动1步，相遇则说明有环

如何确定环的入口：

详解分析见：代码随想录

2.代码

class Solution {
public:
    ListNode* detectCycle(ListNode* head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (fast != NULL && fast->next != NULL) {
            fast = fast->next->next;
            slow = slow->next;
            if (slow == fast) {
                ListNode* index1 = head;
                ListNode* index2 = fast;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return NULL;
    }
};

3.复杂度分析

时间复杂度：O(n)

空间复杂度：O(1)

4.Reference:代码随想录