代码随想录Day4：24. 两两交换链表中的节点，19.删除链表的倒数第N个节点 ，面试题 02.07. 链表相交 ，142.环形链表II

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

题目要求：

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。
你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

 使用虚拟头节点，代码实现：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyDode = new ListNode(0);
        dummyDode->next = head;
        ListNode* cur = dummyDode;
        while(cur->next != NULL && cur->next->next != NULL)
        {
            ListNode* tmp = cur->next;
            ListNode* tmp1 = cur->next->next->next;
            cur->next = tmp->next;
            cur->next->next = tmp;
            cur->next->next->next = tmp1;
            cur = cur->next->next;
        }
        return cur->next;
    }
};

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

题目要求：

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

我的思路：

先通过while语句找出整体链表的size，再算出要删除结点前一个结点的索引。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* cur = head;
        int size = 1;
        while(cur->next != NULL)
        {
            size++;
            cur = cur->next;
        }
        int index = size - n;//删除索引为index的结点
        ListNode* dummyNode = new ListNode(0);
        dummyNode->next = head;
        cur = dummyNode;
        while(index--)
        {
            cur = cur->next;//cur指向要删除结点的前一个节点
        }
        ListNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        return dummyNode->next;
    }
};

更简单（更妙）的方法：快慢指针法

代码实现：

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyNode = new ListNode(0);
        dummyNode->next = head;
        ListNode* slowNode = dummyNode;
        ListNode* fastNode = dummyNode;
        while(n--)
        {
            fastNode = fastNode->next;
        }
        while(fastNode->next != NULL)
        {
            fastNode = fastNode->next;
            slowNode = slowNode->next;
        }
        ListNode* tmp = slowNode->next;
        slowNode->next = tmp->next;
        delete tmp;
        return dummyNode->next;
    }
};

 面试题 02.07. 链表相交

题目要求：

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。
如果两个链表没有交点，返回 null 。

看到题目自己首先的想法就是暴力搜索，但是会做很多不必要的遍历。

两个链表如果有相交，那么两个链表倒数的某些节点地址一定是相同的，由于链表只能从前向后遍历，那么两个节点搜索指针从同一个位置开始向后遍历，一定能找到交点，两个搜索指针同时移动还可以少使用一个while语句。

实现代码;

lass Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int LenA = 0;
        int LenB = 0;
        while(curA != NULL)
        {
            LenA++;
            curA = curA->next;
        }

        while(curB != NULL)
        {
            LenB++;
            curB = curB->next;
        }

        curA = headA;
        curB = headB;
        if(LenB > LenA)
        {
            swap(LenA, LenB);
            swap(curA, curB);
        }

        int gap = LenA - LenB;

        while(gap--)
        {
            curA = curA->next;
        }

        while(curA != NULL)
        {
            if(curA == curB)
            {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

142.环形链表II

题目要求：

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 
如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

按照自己想法写出了暴力搜索的代码，LeetCode里超时了，于是去看了随想录里的解答，只能说 米奇妙妙屋，妙到家了 ...算法大佬真牛啊

代码实现：

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* slowNode = head;
        ListNode* fastNode = head;
        while(fastNode != NULL && fastNode->next != NULL)
        {
            slowNode = slowNode->next;
            fastNode = fastNode->next->next;
            if(slowNode == fastNode)
            {
                ListNode* slowNode = head;
                ListNode* index = fastNode;
                while(index != slowNode)
                {
                    index = index->next;
                    slowNode = slowNode->next;
                }
                return slowNode;
            }
        }
        return NULL;
    }
};

感想：

今天写链表的题目，明显感觉比昨天更熟练了，对链表的结构和特点以及常用的操作有了更深的理解。