代码随想录打卡—day4—【链表】—链表操作综合题

1 链表题目（1）

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

思路和翻转链表那个像，也是搞几个指针，按着链表的顺序走一遍就行，就是【1】写核心逻辑需不需要tmp防止覆盖，【2】哪个指针指着哪个容易晕。

AC代码：

/**
 * 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) 
    {
        if(head == nullptr || head->next == nullptr)return head;  // 只有0或者1个元素就返回
        ListNode* dummynode = new ListNode(0,head);
        ListNode* last = dummynode;
        ListNode* now = dummynode->next;
        while(now != nullptr && now->next != nullptr)
        {
            cout << last->val << endl;
            cout << now->val << endl;
            // 交换
            last->next = now->next;
            ListNode* tmp = now->next;
            now->next = now->next->next;
            tmp->next = now;
            //前进
            last = now;
            now = now->next;
        }
        return dummynode->next;
    }
};

---

2 链表题目（2）

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

我一开始AC的做法，先遍历整个链表计算一共几个元素，然后计算要删除的是正着数第几个节点，再遍历走到要删除的节点的前一个节点，删除。【遍历两遍】

/**
 * 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,head);  // 加一个虚拟头节点
        int sum = 0;  // 一共k个节点
        ListNode* cur = dummyhead;
        while(cur->next != nullptr)
        {
            sum++;
            cur = cur->next;
        }
        int k = sum - n ;  //到要删除节点的前一个
        cur = dummyhead;
        while(k--)
        {
            cur = cur->next;
        }
        cur->next = cur->next->next;
        return dummyhead->next;
    }
};

2.1 链表题目（2）优化

看了讲解发现用《同向快慢双指针》可以优化到一遍扫描+上面这个又忘记delete要删除的元素，优化之后的AC代码：

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) 
    {
        ListNode* dummyhead = new ListNode(0,head);  // 加一个虚拟头节点
        ListNode* fast = dummyhead;
        ListNode* slow = dummyhead;
        n++;
        while(n--)fast = fast->next;  //快指针先走n+1步
        while(fast != nullptr)
        {
            fast = fast->next;
            slow = slow->next;
        }
        ListNode* tmp = slow->next;
        slow->next = slow->next->next;
        delete tmp;

        return dummyhead->next;
    }
};

---

3 链表题目（3）

面试题 02.07. 链表相交

 一开始没有想法，只想到了O（m*n）的暴力解法。后来看了提示，才想到可以从两个链表后面长度相同的部分开始往后移。

/**
 * 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* cura = headA;
        ListNode* curb = headB;
        // 计算两个链表的长度
        int numa = 0;
        int numb = 0;
        while(cura != nullptr)
        {
            cura = cura->next;
            numa++;
        }
        while(curb != nullptr)
        {
            curb = curb->next;
            numb++;
        }
        cura = headA;
        curb = headB;
        // 把两个链表当前指针同步到后面的长度一致
        if(numa < numb)  //  b比较长
        {
            int k = numb - numa;
            while(k--){curb = curb->next;}
        }
        else if(numa > numb)  //a比较长
        {
            int k = numa - numb;
            while(k--){cura = cura->next;}
        }
        while(cura != nullptr)  // 后移 找交点
        {
            if(cura == curb)return cura;
            cura = cura->next;
            curb = curb->next;
        }
        return nullptr;
    }
};

---

4 链表题目（4）

142. 环形链表 II

 我的AC写法超暴力写法，又占时间，又占空间的。

/**
 * 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) 
    {
        //  我的暴力想法 来一个vector 存着过去扫过的节点地址
        vector<ListNode *> a;
        ListNode * cur = head;
        while(cur != nullptr)
        {
            auto it = find(a.begin(),a.end(),cur);
            if(it == a.end())  // 在a中没有
                a.push_back(cur);
            else return cur;
            cur = cur->next;
        }
        return nullptr;
    }
};

---

4.1 链表题目（4）优化

学习一下我想不到的优化写法。学完感慨，妙啊！！！下面讲一下注意点：

Q1：判断有无环。==》 快慢指针，快的每次走2步，慢的每次走1步，如果存在环的话，快慢指针一定会在环里面相遇！证明：【1】首先，快的比慢的走的快，所以不可能在直线上相遇，要是相遇只可能在环里面。【2】其次，想到在一个操场跑步，当慢的进入环，早就在环里的快的 就相当于要追慢的，而快的速度比慢的快，所以一定可以追上！

Q1.1 为什么快的要2步，不能3步，4步？==》 因为快的2步时，就是相对慢的每次增加一步的节奏逼近，如果快的走3步时，则快的相对慢的以每次2步的增速逼近，由于走的是离散的，也就是存在慢的就在自己前面一步，但是快的相对慢的迈了两步，相遇超过了但错过了没发现。

Q2：现在如果判断有环了，怎么找环入口？==》

那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，其中：n为fast指针在环内走了n圈才遇到slow指针。因为fast指针是一步走两个节点，slow指针一步走一个节点， 易得：

(x + y) * 2 = x + y + n (y + z)

化简得 : x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。所以要求x ，将x单独放在左面：

x = n (y + z) - y 

 消掉 -y 得：

x = (n - 1) (y + z) + z 

注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

这个公式说明：先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。

假设 n为1的时候，公式就化解为

 x = z

这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

 Q2.1： 为什么那么相遇时： slow指针走过的节点数为: x + y？ 不是x + y + k (y + z).==》因为当慢的进入环的时候，最差的情况，快的就在自己前面一格，所以慢的转小于一圈的时间内，快的一定可以追到自己。

Q2.2：n的解释：n是一个不知道多少的定值，可能是1，可能是其他正整数，但不论是哪个定值，按下面的t1 != t2 为条件循环都满足x = (n - 1) (y + z) + z  ，也不在乎n是多少了。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) 
    {
        //
        ListNode * fast = head;
        ListNode * slow = head;
        while(fast != nullptr && fast->next != nullptr)
        {
            fast = fast->next->next;  //快指针走两格
            slow = slow->next;  //慢指针走一格
            if(fast == slow)  //相遇了说明有环
            {
                ListNode * t1 = head;
                ListNode * t2 = fast;
                while(t1 != t2)  // 找到环就找环入口
                {
                    t1 = t1->next;
                    t2 = t2->next;
                }
                return t1;
            }
        }
        return nullptr;  //没有环
    }
};

 果然！时间空间都小了，时间快了12倍！

---

总结：

1. 这次学到了快慢指针的更多应用

2. 感受了一个环形链表比较难的题，正解很难想，但很有意思

3. day6才在补day4 的wuwu ， 累计用时3个半小时吧