代码随想录第四天|LeetCode27 & LeetCode19 & 面试题02.07 & LeetCode142

1.两两交换链表中的结点

LeetCode27题目链接

拿到题目第一想法：

两两交换？1结点和2结点换，3结点和4结点换？还是1和2换，然后1再和3换？不对不对，应该是前面那种换法，后者只是将1结点换为了尾结点。到此，题意理解完全。那就是奇数结点与偶数结点交换，若偶数结点存在则换，为空则不换。

解题思路：

​

遍历cur指针必须指向前一个结点才可以操作接下来两个结点，所以cur指针得指向结点值为1；

链表while循环遍历条件为：while(curnext!=NULL && curnext->next!=NULL)注意两个不为空条件不能掉个即while(curnext->next!=NULL & curnext!=NULL)，这会导致空指针异常，先判断curnext->next为空时，curnext可能已经为空指针（例如链表为空链表时）。

代码随想录视频讲解 

LeetCode27代码实现

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyhead = new ListNode();//构建虚拟头结点
        dummyhead->next = head;//虚拟头结点链接链表
        ListNode* cur = dummyhead;//cur遍历指针
        ListNode* curnext = cur->next;
        while(cur->next!=nullptr && curnext->next!=nullptr){//遍历结束条件
            cur->next = curnext->next;
            curnext->next = cur->next->next;
            cur->next->next = curnext;
            //向后移动
            cur = cur->next->next;
            curnext = cur->next;
        }    
    return dummyhead->next;
    }
};

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

LeetCode19题目链接

拿到题目第一想法：

两趟扫描——第一趟获得链表长度，第二趟找到倒数第N＋1个结点，移除倒数第N个结点
一趟扫描——使用双指针，利用前后出发的两个指针的间隔为N-1，当先出发的指针指向末尾结点时，后出发的指针指向倒数第N个结点。

解题思路：

双指针法：
快指针比慢指针先走n步，当快指针fast的next指向NULL时，慢指针slow指向移除结点的前一个结点。

 代码随想录视频讲解

LeetCode19代码实现

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyhead = new ListNode(0);
        dummyhead->next = head;
        ListNode* fast = dummyhead;
        ListNode* low = dummyhead;
        while(n--){//先后两指针的间隔为n，即后指针向后移动n次与前指针重合
            fast = fast->next;
        }
        while(fast->next!=nullptr){
            fast = fast->next;
            low = low->next;
        }//找到倒数第n+1个结点
        //删除倒数第n个结点
        ListNode* temp = low->next;
        low->next = temp->next;
        delete temp;
        return dummyhead->next;
    }
};

3.面试题 02.07. 链表相交

LeetCode题目链接

拿到题目第一想法：

理解链表相交，不是要求从某一结点开始结点值相等，而是从某一个结点开始两个链表的遍历指针指向同一个结点，同一块内存空间。例如，

链表相交的起点是结点值为8，而不是结点值为1。
解题没有思路，参考了代码随想录讲解。 

代码实现

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
//不用增删改，所以可以不用增设虚拟头结点
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lengthA,lengthB;
        lengthA = lengthB = 0;
        while(curA!=nullptr){
            lengthA++;
            curA = curA->next;
        }
        while(curB!=nullptr){
            lengthB++;
            curB = curB->next;
        }
        //遍历指针重新指回头结点
        curA = headA;
        curB = headB;
        if (lengthB > lengthA) {
            swap (lengthA, lengthB);
            swap (curA, curB);
        }
        // 求长度差,curA指向最长的链表
        int gap = lengthA - lengthB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap--) {
            curA = curA->next;
        }
        //此时curA与curB距各自链表末端的距离相等
        while(curA!=nullptr){
            if(curA==curB){return curA;}
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;    
    }
};

4. 环形链表

LeetCode142题目链接

拿到题目第一想法：

1. 第一想法是没有想法，尴尬！有一点小想法：创建一个新链表，给第一次遍历过的原链表结点的基础上添加标记tag=；再遍历一次新链表，访问过的链表结点tag值修改为1，每次访问下一结点时检标记是否为1，当第一次检查到访问结点标记为1时，说明该链表存在环，并且此结点即为环的入口。这种解法的空间复杂度为O(N)。

解题思路：

先学习了代码随想录讲解视频，然后翻看了代码随想录网站，觉得卡尔哥讲解的十分精彩，将每一个细节都考虑到了，为什么是这样和为什么不会是那样，让我做到了彻底搞懂了环形链表的代码思路。这道题是我学习编程以来第一次遇到的类型，这道的解法让我体会到了数学推理对编程的重要性，是一种全新的体会与体验。编程思维是对问题的模拟求解，在暴力求解之后，我们要追求的是数学思维的加持，从而实现代码的简洁，和程序的轻短快。有时求解问题的代码不见得有多复杂，但是背后的数学推理是精准的是经的准推敲的，而不是“想当然”和“应该是这样吧”。

从代码随想录摘录求解思路如下：本题求解两个关键点：

1. 怎么确定链表有环
2. 怎么确定环的入口

确定链表有环：

通过使用快慢指针，原理是：快指针fast每次向前移动2个结点，慢指针slow每次向前移动1个结点，可以等价于快慢指针的移动速度不同，若链表有环，则快慢指针一定在环内相遇，且为快指针追赶慢指针，快指针移动速度快，先行进入环中，接着慢指针进入环中。快指针每次移动2个结点，慢指针每次移动1个结点，则快指针相对慢指针的相对移动速度为每次移动一个结点靠近慢指针，所以快慢指针一定会相遇，所以快指针移动两个结点，慢指针移动一个结点是本题利用快慢指针的关键。

确定环的入口：

根据推导可得（推导见代码随想录网站），从头结点出发一个指针index1，从相遇节点也出发一个指针index2，这两个指针每次只走一个节点，那么当这两个指针相遇的时候，就是环形入口的节点。

LeetCode142代码实现

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast!=NULL && fast->next!=NULL){
//&&逻辑，fast指针快，遍历链表，当fast为空指针(链表结点数为偶数)或fast->next为空指针(链表结点数为奇数)时，链表无环，结束while循环
            fast = fast->next->next;//fast指针移动 2结点/次
            slow = slow->next;//slow指针移动 1结点/次
            if(fast == slow) break;//存在环，跳出while循环
        }
        if(fast == NULL || fast->next == NULL) return NULL;
//||逻辑，若while循环是因为不存在环而退出，返回空指针，否则继续执行下列代码
        ListNode* index1 = head;//index1从头结点出发
        ListNode* index2 = fast;//index2从fast和slow相遇的结点出发
        while(index1!=index2){//每次都移动一个结点，相遇时退出while循环
            index1 = index1->next;
            index2 = index2->next;
        }
        return index1;//返回环入口指针
    }
};

总结

2023年4月9日00:02:13
内容没有完成，明天继续
2023年4月12日12:05:02
完成了前两道题的代码实现，都是自己独立完成的，有进步。
落下了几天的任务，需要多花一些时间补一补，不能越落越多了。

问题解决了！！！！

——为什么下面的代码会报错呢？

LeetCode面试02.07链表相交

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
//不用增删改，所以可以不用增设虚拟头结点
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lengthA,lengthB;
        lengthA = lengthB = 0;
        while(curA!=nullptr){
            lengthA++;
            curA = curA->next;
        }
        while(curB!=nullptr){
            lengthB++;
            curB = curB->next;
        }
        int n = lengthA - lengthB;
        //遍历指针重新指回头结点
        curA = headA;
        curB = headB;
        if(n>0){
            while(n--){curA = curA->next;}
        }else{
            while(n--){curB = curB->next;}
        }
        //此时curA与curB距各自链表末端的距离相等
        while(curA!=nullptr){
            if(curA==curB){return curA;}
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;    
    }
};

 代码出错！？！

原因：

当n<0时进入while(n--)是一个死循环，所以导致报错。上面n>0，while循环写(n--)正确，但是当n<0时，进入while循环再写n--，因为跳出while循环情况为n为0时，所以n--导致while变成了死循环。解决办法：当n<0时，while(n++)；

 收获：

1.程序报的错误不一定就是解决自己程序出错的关键原因，它只能起到提示的作用
2.以后写程序要注意防止陷入死循环
3.顿悟解决问题程序的豁然开朗，很开心！不亚于写对一个程序，哈哈哈哈哈！

2023年4月13日12:01:49
完成任务学习打卡！
感觉像是补作业，一直在补之前没完成的任务，什么时候可以做到跟上节奏啊？
任务规划的重要性，最好不要盲目完成任务，不要想到什么做什么，也不要只做想做的事，这样容易失去对时间安排的控制，导致每件事都在补之前的，缺乏掌控。