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

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

题目链接：力扣

用虚拟头结点，这样会方便很多。

思路：这里的交换是将两个节点进行两个两个的交换，注意奇数和偶数的情况。

上述交换的过程是1和2进行交换，3和4进行交换，如果要是存在节点5，则不进行交换。
①由于存在偶数和奇数的情况，因此，这里的遍历的条件是有两个，while（cur->next!=nullptr
&&cur->next->next!=nullptr）{ }
②注意这里的断线顺序，需要将断线的顺序分析清楚。因此，断线过程之中，要保存节点1和节点3。
③将cur向后移动两位。

/**
 * 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) {

        //1.声明一个虚拟节点
        ListNode* dummyNode = new ListNode(0);

        dummyNode->next = head;

        ListNode* cur = dummyNode;

        //2.判断条件
        while(cur->next!=nullptr&&cur->next->next!=nullptr)
        {
            //3.存储节点1和节点3
            ListNode* temp = cur->next;

            ListNode*tem1 = cur->next->next->next;

            //cur连接节点2
            cur->next = cur->next->next;
            
            //节点2连接节点1
            cur->next->next=temp;

            //节点1连接节点3
            cur->next->next->next=tem1;

            //改变cur的指向
            cur = cur->next->next;
        }

        return dummyNode->next;

        
    }
};

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

双指针的操作，要注意，删除第N个节点，那么我们当前遍历的指针一定要指向 第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) {
       
       //1.声明一个虚拟节点
       ListNode* dummyHead = new ListNode(0);

       dummyHead->next=head;

       ListNode* fast = dummyHead;
       ListNode* slow = dummyHead;

        
       //先让fast走
       while(n--)
       {
           fast=fast->next;
       }


       while(fast->next!=nullptr)
       {
           slow=slow->next;
           fast=fast->next;
       }
       ListNode* tem=slow->next;
       slow->next=slow->next->next;
       delete tem;
       return dummyHead->next;


    }
};

面试题 02.07. 链表相交

题目链接:力扣

本题的思路:

①首先,得到最长的链表,比较两个链表长度
②将最长的链表前面几个元素进行剔除

③开始比较后面的元素是否相等

/**
 * 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* A = headA;
       ListNode* B = headB;

        int LenA = 0;
        int LenB = 0;

        if(A==NULL||B==NULL)
        {
            return NULL;
        }

       while(A!=NULL)
       {
           A=A->next;
           LenA++;

       }
       

       while(B!=NULL)
       {
           B=B->next;
           LenB++;
       }
      //重新赋值一定要记者,由于没有重新赋值,导致代码编译不过去
      A = headA;
      B = headB;

       if(LenB>LenA)
       {
           swap(A,B);
           swap(LenA,LenB);
       }

        int n = LenA-LenB;

        while(n--)
        {
            A = A->next;
        }

        //这个地方需要注意,A!=NULL,需要判断头节点
        while(A!=NULL)
        {
            if(A==B)
            {
                return A;
            }
            A = A->next;
            B = B->next;

        }
        return NULL;


    }
};

142.环形链表II 

题目连接:力扣

思路如下所示:

/**
 * 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 = head;
        ListNode* slow = head;

        //快指针每次移动两个位置,慢指针移动一个位置
        while(fast!=nullptr&&fast->next!=nullptr)
        {
            fast=fast->next->next;
            slow=slow->next;
            //相遇节点
            if(fast==slow)
            {
                ListNode* index1 = head;
                ListNode* index2 = fast;

                //初始的x位置相遇
                while(index1!=index2)
                {
                index1 = index1->next;
                index2 = index2->next;
                    
                }
                return index1;

            }


        }
        return nullptr;

    }
};