算法第四天|两两交换链表中的节点LeetCode24、删除链表的倒数第N个节点LeetCode19、链表相交LeetCode02.07、环形链表ⅡLeetCode142

两两交换链表中的节点

题目链接：LeetCode24、两两交换链表中的节点

整体思路：

使用一个虚拟头节点会非常好做

（将当前要交换的两个节点的前一个节点叫做当前节点）

1、使用临时的指针tmp1保存当前节点的下一个节点；使用临时的指针tmp2保存当前节点的下下下节点；

2、将当前节点的next指针指向下下个节点，实现后边节点向前

3、将当前节点的下个节点（已经换成了下下节点）的next指针指向tmp指向的位置，实现前边节点向后

4、将当前节点的下下个节点（原来的当前节点下一个节点）的next指针指向tmp2指向的地址，实现将链表后边的节点链接

/**
 * 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_node = new ListNode(0);
        vir_node->next = head;
        //定义一个当前节点
        ListNode* cur = vir_node;
        //判断当前节点的下一个节点、下下个节点是存在的
        while(cur->next!=nullptr&&cur->next->next!=nullptr)
        {
            //使用临时节点保存当前节点的下一个节点
            ListNode* tmp = cur->next;
            //使用临时节点保存当前节点的下下下节点
            ListNode* tmp2 = cur->next->next->next;
            //将当前节点指向下一个节点，转换到指向下下个节点
            cur->next = cur->next->next;
            //将当前节点的下下个节点指向当前节点的下一个节点
            cur->next->next = tmp;
            //将转换后的当前节点的下下下个节点指向第四个节点
            cur->next->next->next = tmp2;
            //将当前节点向后移动两位，准备下个循环
            cur = cur->next->next;
        }
        head = vir_node->next;
        delete vir_node;
        return head;

        
    }
};

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

题目链接：LeetCode19、删除链表的倒数第N个节点

整体思路：

1、因为可能涉及到头节点的问题，使用虚拟头节点会更好

2、使用双指针（快慢指针），快的先走n步，之后快慢指针同时移动，当快指针移动到最后一个节点（next指针为nullptr），此时慢指针位于需要删除的节点的前一个节点

/**
 * 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) {
        //使用快慢指针，找到倒数的第n个节点的前一个节点
        //需要让快指针先走n步，之后两个指针同时走，当快指针找到最后一个节点，慢指针的位置就是要删除的节点的上一个节点
        //使用虚拟头节点，便于处理头节点的特殊性
        ListNode* vir_code =new ListNode(0,head);
        ListNode* fast_code = vir_code;
        ListNode* slow_code = vir_code;
        while(n--&&fast_code!=nullptr)
        {
            fast_code = fast_code->next;
        }

        //让fast走到最后一个节点
        while(fast_code->next!=nullptr)
        {
           fast_code = fast_code->next;
           slow_code = slow_code->next;
        }
         //开始删除
        ListNode* tmp = slow_code->next;
        slow_code->next = slow_code->next->next;
        delete tmp;
        head = vir_code->next;
        delete vir_code;
        return head;
    }
   
};

链表相交

题目链接：LeetCode、02.07 链表相交

整体思路：

主要是理解什么叫做相交：相交之后的所有节点指针一致（值、next指针），所以会数量相同。

        所以可以判断两个链表的长度，将长的链表移动到与短的链表一致的位置之后，开始遍历两个链表，查找第一个相同的节点指针（值、next）

/**
 * 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) {
        //理解相交的意思：后边所有节点一样
        //所以相交后，之后的长度必须相同，可以将长的链表移动到与短的链表一致，在开始寻找交点
        
        //计算连哥哥链表的长度
        int lenA=0,lenB=0;
        ListNode*curA=headA;
        ListNode*curB=headB;
        for(;curA!=nullptr;curA=curA->next)
        {
            lenA++;
        }
        while(curB!=nullptr)
        {
            lenB++;
            curB=curB->next;
        }
        curA=headA;
        curB=headB;
        //判断长度，使长的链表的长度与短的一致
        while(lenA>lenB)
        {
            curA = curA->next;
            lenA--;
        }
        while(lenB>lenA)
        {
            curB = curB->next;
            lenB--;
        }
        //开始同时遍历
        while(curA!=nullptr&&curB!=nullptr)
        {
            if(curA==curB)break;
            curA = curA->next;
            curB = curB->next;
        }
        if(curA!=nullptr)return curA;
        else return nullptr;


        
    }
};

环形链表Ⅱ

题目链接：LeetCode142 环形链表Ⅱ

整体思路：

        1、判断是否有环:使用一个快指针一个慢指针，快指针每次移动两个节点，慢指针每次移动一个节点。这样一定可以在环中相遇。（同时要注意是否越界）
        2、寻找环的入口：设入环长度为x，入环到相遇为y，环剩余长度为z
那么相遇时：x+y是slow指针的距离，相差两倍：2(x+y)就是fast距离
        3、2（x+y）= x+y+n(y+z)--->x+y = n(y+z)--->x = (n-1)(y+z)+z:n一定是大于等于1的，因为n表示fast指针在环中出入多少次，大于等于才能追上slow。
        4、当等于1时，x = z ；即如果在相遇的y节点之后，从头节点和z的起始节点同时指针向前前进，最后相遇的地方就是环形入口的节点；当n！=1的时候 ，是一样的，只是多转了n-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*fast_code  = head;
        ListNode*slow_code = head;
        while(fast_code!=nullptr&&fast_code->next!=nullptr&&fast_code->next->next!=nullptr)
        {
            fast_code = fast_code->next->next;
            slow_code = slow_code->next;
            if(fast_code == slow_code)//相遇
            {
                ListNode* cur = fast_code;
                slow_code = head;
                while(cur!=slow_code)
                {
                    cur = cur->next;
                    slow_code = slow_code->next;
                }
                break;
            }
        }
        if(fast_code!=nullptr&&fast_code->next!=nullptr&&fast_code->next->next!=nullptr)return slow_code;
        else return nullptr;
        
    }
};