代码随想录算法训练营day4(链表)

代码随想录算法训练营day4(链表)：

周末去看徐佳莹五月天演唱会了，补一下之前的习题。

学习内容：

学习产出：

24:
主要方法是设置虚拟头节点和用cur节点遍历链表，然后遵循dummy-next=2(节点)；2(节点)->next=1(节点)；1(节点)->next=3(节点)；前一个节点管理后两个节点的指向交换，要注意设置中间变量记录改变指向前的状态，因为cur在遍历时，它的指向一变就会切断改变前的链并增加新链。

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
            ListNode* dummy= new ListNode(0,head);
            ListNode* cur = dummy;
            while(cur->next!=nullptr&&cur->next->next!=nullptr){
            //注意这个条件，在链表只剩一个节点时或者无剩余节点时停止遍历。
            //![请添加图片描述](https://img-blog.csdnimg.cn/direct/be7d74846779444e94c100bd77be3601.png)
cur->next要写在cur->next->next前不然如果无节点会出现nullptr->next的空指针错误
                ListNode* temp1=cur->next;
                ListNode* temp2=cur->next->next;
                cur->next=cur->next->next;
                temp1->next=temp2->next;
                temp2->next=temp1;
                cur=cur->next->next;
            }
            return dummy->next;
            }
};

最容易想到的方法就是遍历两次，先计算链表长度，再设置虚拟头节点，遍历i-n+1次，设置虚拟头节点可以避免返回空指针的问题。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* cur=head;
        int i = 1,j = 0;
        while(cur->next!=nullptr){
            cur=cur->next;
            i++;
        }
        ListNode* dummy=new ListNode(0,head);
        ListNode* cur1=dummy;
        ListNode* temp=cur1;//记录移动前的上一个节点
        while(j<=i-n){
            temp=cur1;
            cur1=cur1->next;
            j++;
        }
        temp->next=cur1->next;//删除中间节点和链
        delete cur1;
        return dummy->next;
    }
};

官方给出的双指针法：
中心思想还是找到倒数第n个节点，也就是要遍历到第length-n+1个节点并将其删除。
所以双指针法，先让快指针从虚拟头节点开始走n步，然后让慢指针开始走，直到慢指针走到最后一个节点，这样慢指针这时走了length-n次，就是需要删除的节点的上一个节点 .

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;
        while(n-- && fast->next != NULL) {
            fast = fast->next;
        }
        while (fast->next != NULL) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next; 
        
        // ListNode *tmp = slow->next;  //C++释放内存的逻辑
        // slow->next = tmp->next;
        // delete tmp;
        
        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) { // 求链表A的长度
            lenA++;
            curA = curA->next;
        }
        while (curB != NULL) { // 求链表B的长度
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            swap (lenA, lenB);
            swap (curA, curB);
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap--) {
            curA = curA->next;
        }
        // 遍历curA 和 curB，遇到相同则直接返回
        while (curA != NULL) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

判断链表有环：
快慢指针，快指针走2，慢指针走1；有环一定会相遇。
判断环入口：

2(x+y)=x+y+n(y+z),n为圈数；快指针走的距离是慢指针的两倍
得到：x = (n - 1) (y + z) + z
这里n一定不小于1，因为快指针一定在环内至少走了一圈才能遇到慢指针，不然慢指针永远追不上快的。
从这个式子可以看出从头节点到入口的x, 一定比第一次相遇的节点到入口的z多（n-1）个（y+z），如果n=1那正好x=z；n等于其他数同理，一个从头节点出发每次走1的指针，和一个从第一次相遇节点出发每次走1的指针一定会相遇（只是前一个在走的时候，后一个可能在环里绕了（n-1）圈），而且是在环入口相遇。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            // 快慢指针相遇，此时从head 和 相遇点，同时查找直至相遇
            if (slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2; // 返回环的入口
            }
        }
        return NULL;
    }
};

链表总结：