代码随想录day4:链表总结

两两交换链表中的节点

一开始自己的思路只是两两交换，并没有说涉及到前一个节点。实际上两两交换涉及到了三个节点
使用虚拟头结点，这样一次性处理三个节点。且每次组里第一个节点其实数值没变。

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;
            temp1->next=temp2;

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

迭代法：发现的规律是，本质上一组同时改变新的节点。重复的是，原来head-》next也就是newhead变成了新的头结点。而且要每次返回交换顺序的头结点给上一组。

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head == nullptr || head->next == nullptr) return head;
        ListNode* newhead= head->next;
        head->next = swapPairs(newhead->next);
        newhead->next=head;
        return newhead;

    }
};

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

难点，如果只想遍历一次的话，如何做到呢？借用双节点的 巧妙思路。快指针先走N步，慢指针跟上，快指针走到结尾的时候，快指针比慢指针多走了N步，也就是慢指针到了倒数第N个。
写错的地方：
虚拟头结点是赋予地址dummyhead->next=head;而不是指向头指针：dummyhead=head;
删除节点是让节点的地址域next指向下下个节点slow->next=slow->next->next;而不是slow=slow->next->next;
最后返回头结点是return dummyhead->next;而不用返回头结点自身return dummyhead;

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 = fast->next;
        }
        while(fast->next != nullptr){
            slow = slow->next;
            fast = fast->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 sizeA = 0;
        int sizeB = 0;
        int n = 0;
        while(curA != NULL){
            sizeA++;
            curA = curA->next;
        }
        while(curB != NULL){
            sizeB++;
            curB = curB->next;
        }
        if(sizeA < sizeB){
            curA=headB;
            curB=headA;
        }
        else{
            curA=headA;
            curB=headB;
        }   
        n=abs(sizeA-sizeB);
        //cout<<"n"<<n<<endl;
        while(n && curA != NULL){
            //cout<<"n:"<<n<<"curA:"<<curA->val<<endl;
            curA = curA->next;
            n--;
        }
        while(curA != NULL && curB != NULL){
            //cout<<"curA"<<curA->val<<endl;
            //cout<<"curB"<<curB->val<<endl;
            if(curA == curB)
                return curA;
            else{
                curA = curA->next;
                curB = curB->next;
            }
        }
        return NULL;
    }
};

环形链表的交叉入口

双指针的题，快慢指针，追击问题。想到了最后总会相遇，但是忘记了数学推导一下入口怎么找。