代码随想录day4｜ 两两交换链表中的节点、删除链表中倒数第N个节点、链表相交、环形链表

两两交换链表中节点

这种需要处理第一个节点的题目，需要设置一个虚拟头节点，同时在更改的指针指向的时候，设立两个临时指针，将需要改变的三个节点的顺序依次改变。代码如下：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* cur = dummyHead;
        while(cur->next != nullptr && cur->next->next != nullptr)
        {
            ListNode* temp1 = cur->next;
            ListNode* temp2 = cur->next->next->next;

            cur->next = cur->next->next;
            cur->next->next = temp1;
            cur->next->next->next = temp2;

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

 删除链表中的倒数第n个节点

思想就是使用双指针，让fast指针先走n+1步，然后再让两个指针同时向前走，这样一来，当fast指针走完了全程，slow指针就可以走到要删除的那个节点的前一个位置。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* fast = dummyHead;
        ListNode* slow = dummyHead;
        while(n-- && fast->next != NULL)//fast指针向前走n步
        {
            fast = fast->next;
        }
        fast = fast->next;//fast指针向前走1步
        while(fast != NULL)
        {
            fast = fast->next;
            slow = slow->next;
        }
        ListNode* temp = slow->next;
        slow->next = slow->next->next;
        delete temp;
        return dummyHead->next;
    }
};

链表相交

这道题两串链表有相交部分，那么从相交点开始到最后一个节点都应该是一样的。我们可以先判断两个链表的长度，求出他们之间的差值，然后让长的链表向前进差值，这样以来两个链表接下来要走的长度就是相同的，只要后面出现了节点一致，那么就说明这两个链表之间有交集。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0,lenB = 0;
        while(curA != NULL)
        {
            curA = curA->next;
            lenA++;
        }
        while(curB != NULL)
        {
            curB = curB->next;
            lenB++;
        }
        curA = headA;
        curB = headB;
        if(lenB > lenA)
        {
            swap(lenA,lenB);
            swap(curA,curB);
        }
        int count = lenA - lenB;
        while(count--)
        {
            curA = curA->next;
        }
        while(curA != NULL)
        {
            if(curA == curB)
            {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

环形链表

 这道题需要用双指针的思想，设置两个指针，一快一慢，fast指针前进两个单位，slow指针前进一个单位，当他们两个指针相遇时，就说明有环。这是因为fast相当于slow来说每次前进一个单位，所以最后一定能过追赶上slow。如何找到入口地址就不赘述了。代码如下：

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;
    }
};