1.交换链表

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

前后指针实现

1.没有元素或者只有一个元素无意义

2.给出一个前驱prev，以及用来交换的两个节点cur和next

3.我当时是这么想的，如果两个指针一起动，那么就要用cur和next同时判断结束，也许这个条件会比较苛刻(我就烦这种边界条件)，所以我觉得动一个指针来判断条件就可以了

4.所以我选择用cur判断，在循环中确定next的指向；prev和cur的更新

5.判断条件就变成了cur是否为空，cur的next是否为空

6.循环进去说明需要交换，所以确定next的指向是cur的next；确定是否更新的是根节点；交换；更新prev，cur进入下一轮

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head==nullptr||head->next==nullptr)
            return head;
        ListNode* prev = nullptr;
        ListNode* cur = head;
        ListNode* next = head;
        while(cur&&cur->next)
        {
            next=cur->next;
            if(prev==nullptr)
                head=next;
            else
                prev->next=next;
            cur->next=next->next;
            next->next=cur;
            prev=cur;
            cur=cur->next;
        }
        return head;
    }
};

前驱？前驱！触发被动了一样的字眼，我是不是可以用递归做啊🤔

 递归交换

1.首先没有元素或者只有一个元素无意义，过

2.递归函数，确定参数头节点要传，因为会换；前驱next、cur和后继next

3.我们依然可以用一个节点进行判断是否到链表底部，cur是否空或者cur的next为空 -- 对应的就是链表是双数还是单数

4.往下传递归的参数其实只需要更新cur和prev，因为前驱必须确定下来，不然往下找不到了，cur也必须有因为我们的底部条件是靠cur判断的，prev等于现在的cur->next，cur等于cur->next->next，就是都得跨两个节点

5.执行交换的代码，next自然就是cur->next。先看是否需要更新的是头节点其条件是prev是否为nullptr；随后交换，返回即可

class Solution {
public:
    void _swapR(ListNode*& head,ListNode* prev,ListNode* cur,ListNode* next)
    {
        if(cur==nullptr||cur->next==nullptr)
            return;
        _swapR(head,cur->next,cur->next->next,next);
        next=cur->next;
        if(prev==nullptr)
            head=next;
        else
            prev->next=next;
        cur->next=next->next;
        next->next=cur;
        return;
    }

    ListNode* swapPairs(ListNode* head) {
        if(head==nullptr||head->next==nullptr)
            return head;
        _swapR(head,nullptr,head,head);
        return head;
    }
};

2. 快慢指针

我觉得代码实现很简单，主要是思想

想要找从后往前的数，就应该用快慢指针，先让快的指针走n次，然后快慢指针一起动，快指针到边界，慢指针的下一个就是我们要删除的节点。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* slow = head;
        ListNode* fast = head;
        for(int i=0;i<n;i++)
            fast=fast->next;
        if(fast==nullptr)
        {
            ListNode* tmp = slow;
            head = slow->next;
            delete tmp;
            return head;
        }
        while(fast->next)
        {
            slow=slow->next;
            fast=fast->next;
        }
        ListNode* tmp = slow->next;
        slow->next=tmp->next;
        delete tmp;
        return head;
    }
};

3.链表相交

面试题 02.07. 链表相交

因为只想时间复杂度为O(N)，空间复杂度为O(1)

所以我想的是给他们的长度算出来，做差值，然后长的那个往后走差值个数，这样两个链表同样一个长度往下走，那么只要知道什么时候两个节点地址一样，就返回

class Solution {
public:
    int getListNum(ListNode* root)
    {
        int num = 0;
        while(root)
        {
            root=root->next;
            num++;
        }
        return num;
    }

    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int NA = getListNum(headA);
        int NB = getListNum(headB);
        int gap = abs(NA-NB);
        ListNode* more = headA;
        ListNode* less = headB;
        if(NA<NB)
        {
            less = headA;
            more = headB;
        }
        for(int i=0;i<gap;i++)
        {
            more=more->next;
        }
        while(less!=nullptr&&more!=nullptr&&more!=less)
        {
            more=more->next;
            less=less->next;
        }
        return more;
    }
};

4.环形链表

142. 环形链表 II

哈希表 嘻哈表

讲个笑话，程序员在课本上学到了数据冲突可以用哈希表解决；到面试时，面试官问这个求职的程序员：“当程序员和项目经理发生冲突时要怎么解决”，“使用哈希表”程序员想都没想脱口而出。

使用哈希表可以直观的看到数据是否之前插入过，使用起来很简单，不过哈希表通过红黑树实现的这个背后逻辑才是关键，这里不说明了

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        set<ListNode*> s;
        ListNode* cur = head;
        while(cur)
        {
            if(s.find(cur)!=s.end())
                return cur;
            s.insert(cur);
            cur=cur->next;
        }
        return nullptr;
    }
};

快慢指针

操场上一个跑得快一个跑得慢，最终快的一定会把慢的套圈。这个题目的思路也是一样的

1.定义快慢指针，快指针走两个节点，慢指针走一个节点；其实可以如果真的有环，慢指针不动，快指针以一个节点为单位靠近慢指针

2.只要两个地址碰到一起，那确实是有环，不过题目要我们返回头一个链接上的节点，所以我们需要通过一个数学思想来解决

 最后得到x = (n - 1) (y + z) + z，说明x跟z长度一样

那么从fast和从头节点同时走，会遇到一样的节点

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* cur = head;
        ListNode* fast = head;
        int fastnum = 0;
        ListNode* slow = head;
        int slownum = 0;
        while(fast&&fast->next&&fast->next->next)
        {
            fast=fast->next->next;
            fastnum+=2;
            slow=slow->next;
            slownum++;
            if(slow==fast)
            {
                while(cur!=fast)
                {
                    cur=cur->next;
                    fast=fast->next;
                }
                return cur;
            }
        }
        return nullptr;
    }
};