代码随想录算法训练营第四天

最新推荐文章于 2024-06-01 23:14:10 发布

z.y.5

最新推荐文章于 2024-06-01 23:14:10 发布

阅读量260

点赞数 4

文章标签：算法 c++ leetcode

本文链接：https://blog.csdn.net/xzyzyzzy/article/details/138710261

版权

LeetCode 24.两两交换链表中的结点

/**
 * 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) {
        ListNode* dummyhead=new ListNode(0,head);
        ListNode* pre=dummyhead;
        while(pre->next){
            ListNode* curr1=pre->next;
            if((pre->next)->next){
                ListNode* curr2=(pre->next)->next;
                ListNode* tmp=curr2->next;
                curr2->next=curr1;
                curr1->next=tmp;
                pre->next=curr2;
                pre=curr1;
            }
            else break;
        }
        ListNode* res=dummyhead->next;
        delete dummyhead;
        return res;
    }
};

自己第一次没看题解独立做出来的题目，这在训练营中还是第一次哈哈。

运用了虚拟头结点的方法

思路：

将一整个链表拆分成小部分，每一个部分有四个结点：四结点结构

交换前：pre -> (pre->next) -> ((pre->next)->next) -> (((pre->next)->next)->next)

将他们用不同字符表示：

pre -> curr1 -> curr2 -> tmp

交换后：pre -> curr2 -> curr1 ->tmp

最后将pre更新为 curr1

考虑临界情况：

运用虚拟头结点，所以不用考虑头结点的特殊情况，将每一个结点都做为中间结点考虑。用两个条件来判断能否进行交换：

(1) while(pre->next)这里其实就是curr1，先要判断curr1存在与否

(2) if((pre->next)->next) 这时判断curr2存在与否

最后将pre更新为curr1，这时tmp存在与否我们并不知道，但是可以继续while循环判断

else break; 条件很重要，此时是不存在curr2的状态，就是到头了，不管链表是奇数个还是偶数个，不能拆成一个小的四结点结构就不能交换

能更新pre就继续循环，不能就是到头了，结束返回头结点。

卡哥的思路跟我差不多，但是他只用了一个curr来间接表示所有点，比较难理解。

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

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyhead=new ListNode(0,head);
        ListNode* fast=dummyhead;
        ListNode* slow=dummyhead;
        while(n--){
            if(fast)fast=fast->next;
        }
        while(fast->next){
            fast=fast->next;
            slow=slow->next;
        }
        ListNode* tmp=slow->next;
        slow->next=slow->next->next;
        delete tmp;
        tmp=nullptr;

        ListNode* res=dummyhead->next;
        delete dummyhead;
        return res;
    }
};

这个也是自己独立做的，做了链表的题目，底层思路都差不多，过程分析清楚就能做出来。

思路：双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。

要返回头结点，运用dummyhead思想，将head当作普通结点，遍历时会把head判断一遍，最后记得删除dummyhead空间
这里先让fast移动，第二个判断while(fast->next)是让slow移动到要删除的前一位，或者也可像卡哥一样让fast第一次while(n--)后再多走一步

LeetCode 面试题 02.07. 链表相交

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* currA=headA;
        ListNode* currB=headB;
        int lenA=0,lenB=0;
        while(currA){
            currA=currA->next;
            lenA++;
        }
        while(currB){
            currB=currB->next;
            lenB++;
        }

        if(lenA>=lenB){
        int n=lenA-lenB;
        while(n--){
            headA=headA->next;
        }
        while(headA!=nullptr && headA!=headB){
            headA=headA->next;
            headB=headB->next;
        }
        return headA;
        }

        else{
        int n=lenB-lenA;
        while(n--){
            headB=headB->next;
        }
        while(headB!=nullptr && headA!=headB){
            headA=headA->next;
            headB=headB->next;
        }
        return headB;
        }
        return nullptr;
    }
};

这里自己想不出来，参照了卡哥的思路。

简单来说，就是求两个链表交点节点的指针。这里同学们要注意，交点不是数值相等，而是指针相等。

思路：我们求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置，这时在重新开始遍历。

LeetCode 142.环形链表II

这题是真想不到，数学理解+编程，过程理解了写代码比较简单，但是真想不到啊。

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(fast==slow){
            ListNode* index1=fast;
            ListNode* index2=head;
            while(index1!=index2){
            index1=index1->next;
            index2=index2->next;
            }
            return index1;
            }
        }
        
        return NULL;
        
    }
};