力扣:24. 两两交换链表中的节点19.删除链表的倒数第N个节点面试题 02.07. 链表相交142.环形链表II

24. 两两交换链表中的节点（100%，51%）

 链表的顺序交换还是考虑用三个指针来进行转换，俗称双指针方法？hahaaaa

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head == nullptr || head->next == nullptr)
        {   
            return head;
        }   //链表交换还是用三个指针来操作
        ListNode* left = head;
        ListNode* right = head->next;
        ListNode* temp;
        head = right;
        while(left!=nullptr && right!=nullptr)
        {
            temp = left;
            left->next = right->next;
            right->next = left;
            left = left->next;
            if(left==nullptr) break;//链表为偶数最后就不要两两交换
            right = left->next;
            if(right == nullptr) temp->next = left;//链表为奇数最后一个不动
            else temp->next = right;
        }
        return head;
    }
};

19.删除链表的倒数第N个节点（77%，21%）

 快慢指针，也是数学游戏，和判断指针中是否有环一样， 不过链表的题用虚头结点感觉确实方便很多~

    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* fakeHead = new ListNode(0);//链表变换就用虚表头
        fakeHead->next = head;
        ListNode* fast = head;  //快慢指针,和环形相交差不多
        ListNode* slow = fakeHead;  //主要还是数学游戏
        int index = 1;
        while( fast->next != nullptr )
        {

            if(index >= n)
            {
                slow = slow->next;
            }
            fast = fast->next;
            index++;
        }
        slow->next = slow->next->next;
        return fakeHead->next;
    }

面试题 02.07. 链表相交（88%，30%）

 如果是找出两个链表的节点个数再找交点就很简单了，通过两者节点差值来找

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* tempA = headA;
        ListNode* tempB = headB;
        int A = 0;
        int B = 0;
        while(tempA!=nullptr || tempB!=nullptr)
        {
            if(tempA != nullptr)
            {
                tempA = tempA -> next;
                A++;
            }
            if(tempB != nullptr)
            {
                tempB = tempB -> next;
                B++;
            }
        }    //找两个链表节点个数
        int num = A -B;    //差值
        tempA = headA;
        tempB = headB;
        if(A > B)    //寻找两个链表的共同起点，找到了再一起动
        {
            for(int i = 0; i < A-B; i++)
            {
                tempA = tempA->next;
            }
        }
        else
        {
            for(int i = 0; i < B-A; i++)
            {
                tempB = tempB->next;
            }
        }
        while(tempA!=nullptr && tempB!=nullptr)
        {
            if(tempA == tempB)
            {
                return tempB;
            }
            tempA = tempA->next;
            tempB = tempB->next;
        }
        return nullptr;
    }

142.环形链表II （76%，45%）

环形链表开始确实不好想出来，是删除链表倒数第几个节点的进阶版感觉， 重点还是用数学公式把快慢指针走的步数个所在节点表示出来就更能理解了，我没想到。

    ListNode *detectCycle(ListNode *head) {
        ListNode* slow = head;//又是一个双指针数学游戏
        ListNode* fast = head;//画图列公式应该能找到fast和slow的位置关系
        while(fast!=nullptr && fast->next!=nullptr)
        {
            slow=slow->next;
            fast=fast->next->next;
            if(fast == slow)
            {
                fast=head;
                while(fast!=slow)   
                {
                    fast=fast->next;
                    slow=slow->next;
                }
                return fast;
            }
        }
        return nullptr;
    }