算法训练营 第四天

算法训练营 第四天

链表day02

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

这道题，首先为了保证循环不变量，设置虚拟节点，然后考虑清楚循环停止的条件是什么，这里考虑链表长度为偶数和奇数的情况，我是设head节点为当前节点，然后每次循环cur向后移动两个节点，则
1、链表长度为偶数时，它的循环停止条件为cur==NULL
2、链表长度为奇数时，它的循环停止条件为cur->next==NULL
因此循环停止条件为（cur != NULL&&cur->next != NULL），这里注意要把cur!=NULL 放在前面，否则会报错，因为当cur==NULL时，访问cur->next会发生内存访问异常，而A&&B运算符规则，如果A==0就不会再去判断B了，因此把cur!=NULL放前面不会报错。
源码：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dH = new ListNode(0, head);
        ListNode* cur = head;
        ListNode* pre = dH;
        while (cur != NULL&&cur->next != NULL ) {
            ListNode* tmp = cur->next->next;
            pre->next = cur->next;
            cur->next->next = cur;
            cur->next = tmp;
            pre = cur;
            cur = tmp;
        }
        return dH->next;
    }
};

19. 删除链表的倒数第N个结点

这里我的第一个思路是，首先遍历一遍链表，得到链表的长度，可以得到倒数第n个结点时正数第几个结点，然后再去删除这个节点,，时间复杂度为o(n*2)，但这样得遍历两次链表，感觉这个方法比较呆。

第二个思路是想到反转链表的方法，先反转链表，这样需要删除的节点就是正数第n个节点，删掉他，然后再反转回来，这样时间复杂度是o(n*3)，比第一个方法还复杂，指定也是不行。

然后想不到了，去看答案，答案的方法是用双指针，让fast指针和slow指针隔着n个节点的距离，然后两个节点同时移动，这样当fast移动到尾端时，slow指针也就指在了需要删除的节点位置，时间复杂度为o(n)！秀啊，又是被前人智慧震惊的一天。
方法三源码：

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* dH = new ListNode(-1, head);
        ListNode* slow = dH;
        ListNode* fast = head;
        while (n--) {
            fast = fast->next;
        }
        while (fast) {
            slow = slow->next;
            fast = fast->next;
        }
        ListNode* tmp = slow->next;
        slow->next = slow->next->next;
        delete tmp;
        return dH->next;
    }
};

代码随想录中参考答案：

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;
    }
};

参考答案中第一个while写的好一些，它考虑了输入的n不符合要求，比如超出了链表长度等情况。

面试题 02.07. 链表相交

这道题只想到了暴力解法，两层遍历，来找相交点，时间复杂度o(m*n)

看答案！

看了参考答案之后，觉得题目没有表述清楚，这道题相交的意思是，相交之后，两个链表就连在一起了，后面剩下的长度是相等的，也就是

如图所示，前两种情况本题都不考虑，只有第三种情况才是本题中的“相交”。

这样的话，就可以用双指针法，将A、B链表从后向前对齐，然后从较短链（例子中的B链）开始遍历，看是否有相交点。
源码：

class Solution {
public:
    ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
        ListNode* dHA = new ListNode(-1, headA);
        ListNode* dHB = new ListNode(-1, headB);
        ListNode* slowA = dHA;
        ListNode* slowB = dHB;//因为慢指针要只想相交点的前一个节点，所以刚开始就提前一个节点
        ListNode* fastA = headA;
        ListNode* fastB = headB;
        while (fastA != NULL && fastB != NULL) {
            fastA = fastA->next;
            fastB = fastB->next;
        }
        //将B设置为较短链
        if (fastA == NULL) {
            fastA = fastB;
            slowA = dHB;
            slowB = dHA;
        }
        //将A链的slowA也移到指定位置
        while (fastA) {
            slowA = slowA->next;
            fastA = fastA->next;
        }
        while (slowA->next != NULL) {
            if (slowA->next == slowB->next) {
                return slowA->next;
            }
            slowA = slowA->next;
            slowB = slowB->next;
        }
        return NULL;
    }
};

代码随想录参考答案：

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为其长度
        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;
    }
};

参考答案是先将A、B两链都遍历一遍得到长度，再移动指针，我的方法使用了双指针，一次遍历的时候将指针移动到了位置，我的方法代码复杂一些，但在运行时间上会快一些。

142. 环形链表

这道题没有什么思路，直接看答案
（看完回来）妙啊，这道题的整体解题思路就是：
1、先定义一个快指针，每次走两步，再定义一个慢指针，每次走一步，如果相遇，则说明有环，如果快指针走到结尾，说明没有环
2、有环时，定义一个指针A从相遇点出发，每次一步，再定义一个指针B从头出发，每次一步，相遇时，指针指向的点就是环的入口。

我的源码：

class Solution {
public:
    ListNode* detectCycle(ListNode* head) {
        if (head == NULL || head->next == NULL)
            return NULL;
        //设置快指针和慢指针
        ListNode* slow = head->next;
        ListNode* fast = head->next->next;
        bool isCircle = false;
        while (fast != NULL && fast->next != NULL) {
            if (fast == slow) {
                isCircle = true;
                break;
            }
            fast = fast->next->next;
            slow = slow->next;
        }
        if (!isCircle)
            return NULL;
        //这里慢指针指的是解题步骤第二步里的指针B（因为慢指针没用了，我就借用了一下，也可以重新定义一个指针）
        slow = head;
        while (slow != fast) {
            slow = slow->next;
            fast = fast->next;
        }
        return slow;

    }
};

代码随想录源码

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;
    }
};

参考答案比我的代码要更好看一些，思路更加清晰一些，不过解题方法都是一样的。

第四天结束啦~今天的题难度噌噌噌涨，累辽，休息休息