代码随想录算法训练营day4

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

1.1 题目链接

. - 力扣（LeetCode）

1.2 题解

/**
 * 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* vir=new ListNode(0);
        vir->next=head;
        ListNode* cur=vir;


        while(cur->next!=nullptr&&cur->next->next!=nullptr)
        {
            ListNode* tmp1=cur->next;
            ListNode* tmp2=cur->next->next->next;

            cur->next=cur->next->next;
            cur->next->next=tmp1;
            cur->next->next->next=tmp2;

            cur=cur->next->next;
           
        }
        return vir->next;

    }
};

1.3 解释

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

2.1 题目链接

. - 力扣（LeetCode）

2.2 题解

暴力解法，顺便复习一下反转链表，先将链表反转过来，再去顺序删除第n个节点，删除完之后再反转过来：

/**
 * 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) 
    {
        head=reverseList(head);
        ListNode* vir=new ListNode(0);
        vir->next=head;
        ListNode* cur=vir;
        for(int i=1;i<n;i++)
        {
            cur=cur->next;
        }
        ListNode* tmp=cur->next;
        cur->next=tmp->next;

        head=reverseList(vir->next);
        return head;



    }
private:
ListNode* reverseList(ListNode* head)
{

    ListNode* pre=nullptr;
    ListNode* cur=head;
    while(cur)
    {
        ListNode* tmp=cur->next;
        cur->next=pre;
        
        pre=cur;
        cur=tmp;
    }
    return pre;
}
};

最优解，定义快慢指针，快指针先走n+1步，然后快慢指针同时走，当快指针走到了NULL时，慢指针刚好走到要删除的节点的前一个节点：

/**
 * 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* vir=new ListNode(0);
        vir->next=head;
        ListNode* fast=vir;
        ListNode* slow=vir;

        //先n+1步
        while(n>=0)
        {
            fast=fast->next;
            n--;
        }
        while(fast)
        {
            slow=slow->next;
            fast=fast->next;
        }
        ListNode* tmp=slow->next;
        slow->next=tmp->next;
        delete tmp;
        tmp=nullptr;

        return vir->next;

    }

};

3.链表相交

3.1 题目链接

. - 力扣（LeetCode）

3.2 题解

/**
 * 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 lengthA=0;
        int lengthB=0;
        //求链表长度
        while(curA)
        {
            curA=curA->next;
            lengthA++;
        }
        while(curB)
        {
            curB=curB->next;
            lengthB++;
        }

        //重置curA和curB
        curA=headA;
        curB=headB;

        //确保A链表是那个短链表
        if(lengthA>lengthB)
        {
            //交换两个链表头部
            ListNode* tmp=headA;
            headA=headB;
            headB=tmp;

            //头节点交换了那cur指针也要交换
            ListNode* tmp_p=curA;
            curA=curB;
            curB=tmp_p;
        }

        //两链表差值
        int length=abs(lengthA-lengthB);

        //curB先走length步
        while(length--)
        {
            curB=curB->next;
        }

        //同时移动
        while(curA)
        {
            if(curA==curB)
            {
                return curA;
            }
            curA=curA->next;
            curB=curB->next;
        }
        return nullptr;
    }
};

末尾位置对齐，先让长链表的cur指针先走两条链表长度的差值，再同时走，若指针相同则返回。

4.环形链表

4.1 题目链接

. - 力扣（LeetCode）

4.1 题解

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

        return nullptr;
    }
};

定义快慢指针，快指针每次走两步，慢指针每次走一步，通过数学证明可知当快慢指针相遇时在环上，此时从相遇点出发到环入口的距离等于从head出发到环入口的距离。