记录算法Day4

代码随想录算法训练营第四天|Leetcode 24 两两交换链表中的节点，19 删除链表的倒数第N个节点， 面试题 02.07. 链表相交，142 环形链表II

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

题目链接 24. 两两交换链表中的节点
文章链接 https://programmercarl.com/0024.%E4%B8%A4%E4%B8%A4%E4%BA%A4%E6%8D%A2%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B9.html
视频链接 https://www.bilibili.com/video/BV1YT411g7br

思路

这道题和昨天的反转链表有点像，只要把每个步骤弄清楚就可以了。第一步先记录当前指针的下下个节点(我用的next指针存储)，第二步让上个节点（pre指向）指向当前节点的下一个节点（cur->next）,第三步让当前节点的下个节点指向当前节点（cur->next->next=cur），第四步让cur指向下下个节点，然后更新一下pre和cur指针即可。受昨天的递归思路启发，又写了一份递归的解法

代码

• 迭代(时间复杂度O(n),空间复杂度O(1))

ListNode* swapPairs(ListNode* head) {

        ListNode* dummyHead = new ListNode();

        if(head==nullptr||head->next==nullptr) return head;

        dummyHead->next = head;

        ListNode* cur = dummyHead->next;

        ListNode* next = nullptr;

        ListNode* pre = dummyHead;

        while(cur->next||cur){

            next = cur->next->next;//记录当前指针cur的下下个节点next

            pre->next = cur->next;//上个节点pre指向cur的下一个节点

            cur->next->next = cur;//cur的下个节点指向当前节点

            cur->next = next;//cur指向下下个节点next节点

            pre = cur;

            cur = next;

        }

        head = dummyHead->next;

        delete dummyHead;

        return head;

    }

• 递归（时间复杂度O(n),空间复杂度O(n)）

ListNode* dummyHead = new ListNode();

    ListNode* reverse(ListNode* pre,ListNode* cur){

        ListNode* next = nullptr;

        if(!pre&&cur){

            dummyHead->next = cur;

            pre = dummyHead;

        }

        if(!cur||!cur->next) return dummyHead->next;//递归结束条件
		//四个步骤
        next = cur->next->next;
        pre->next = cur->next;
        cur->next->next = cur;
        cur->next = next;

        return reverse(cur,next);

    }

    ListNode* swapPairs(ListNode* head) {

        head = reverse(nullptr,head);

        delete dummyHead;//释放

        return head;

    }

Leetcode 19 删除链表的倒数第N个节点

题目链接 19. 删除链表的倒数第 N 个结点
文章链接 https://programmercarl.com/0019.%E5%88%A0%E9%99%A4%E9%93%BE%E8%A1%A8%E7%9A%84%E5%80%92%E6%95%B0%E7%AC%ACN%E4%B8%AA%E8%8A%82%E7%82%B9.html
视频链接 https://www.bilibili.com/video/BV1vW4y1U7Gf

思路

这题挺简单的，题中给的是倒数第几个，可以转换为要删除的节点的下标，就剩下基本的链表节点删除操作

代码

class Solution {

public:

    ListNode* removeNthFromEnd(ListNode* head, int n) {

        ListNode* dummyHead = new ListNode();

        //ListNode* cur = dummyHead->next;//不能定义到前面，因为要修改dummyHead的地址，但是此时的cur还是空地址

        if(!head) return {};

        dummyHead->next = head;

        int size = 0;

        ListNode* cur = dummyHead->next;

        ListNode* pre = dummyHead;

        while(cur){

            cur = cur->next;

            size++;

        }

        cur = dummyHead->next;

        int index = size-n;

        //cout<<size<<" "<<index<<endl;

        while(index--){

            pre = cur;

            cur = cur->next;

            cout<<cur->val<<endl;

        }

        pre->next = cur->next;

        delete cur;

        head = dummyHead->next;

        delete dummyHead;

        return head;

    }

};

Leecode 面试题 02.07. 链表相交

题目链接 面试题 02.07. 链表相交
文章链接 https://programmercarl.com/%E9%9D%A2%E8%AF%95%E9%A2%9802.07.%E9%93%BE%E8%A1%A8%E7%9B%B8%E4%BA%A4.html

思路

这题最重要的一个点就是链表相交的节点是指针相等，而不是每个节点的值相等。我的思路是定义双指针分别指向两个链表的头，分别计算链表的长度，长的链表让指针先移动到和另一个指针相同的起点出发（不太严谨），再开始遍历知道两个指针相等即为交点

代码

class Solution {

public:

    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {

        int sizeA=0,sizeB = 0;

        ListNode* curA = headA;

        ListNode* curB = headB;

        int sub = 0;

        while(curA){

            curA = curA->next;

            sizeA++;

        }//链表a的长度

        while(curB){

            curB = curB->next;

            sizeB++;

        }//链表b的长度

        curA = headA;

        curB = headB;

        sub = abs(sizeA-sizeB);

        if(sizeA>sizeB){

            while(sub--){

                curA = curA->next;

            }

        }else if(sizeB>sizeA){

            while(sub--){

                curB = curB->next;

            }

        }

        while(curA!=curB){

            curA = curA->next;

            curB = curB->next;

        }

        return curA;//curB也可以

    }

};

Leecode 142 环形链表II

题目链接 142. 环形链表 II
文章链接 https://programmercarl.com/0142.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8II.html
视频链接 https://www.bilibili.com/video/BV1if4y1d7ob

思路

这题翻译一下就是找到环形链表的入口点。判断链表有环可以用双指针，如果快指针和慢指针相遇，则链表一定有环，否则慢指针永远也追不上快指针。寻找入口点引用一下卡哥证明的思路

代码

class Solution {

public:

    ListNode *detectCycle(ListNode *head) {

        ListNode* fast = head;

        ListNode* slow = head;

        do{

            if(!fast||!fast->next) return nullptr;

            slow = slow->next;

            fast = fast->next->next;

        }while(fast!=slow);//让两个指针相遇

        slow = head;

        while(fast!=slow){

            slow = slow->next;

            fast = fast->next;

        }//从相遇开始触发，相遇时即为入口点

        return fast;

    }

};

本题收获

这道题我只想到了用快慢指针判断有环，但是没想出来怎么去找入口点，还是要大胆的利用数学公式来解决一些问题