LeetCode 链表 24 19 160 142

Leetcode 24 Swap Nodes in Pairs

    ListNode* swapPairs(ListNode* head) {
        ListNode *dummyNode = new ListNode(0);
        dummyNode->next = head;
        ListNode *orig = dummyNode;
        ListNode *pre = head;
        if(pre == NULL ||pre ->next == NULL){
            return pre;
        }
        ListNode *cur = pre->next;
        while(cur != NULL){
            ListNode *tmp = cur->next;
            cur->next = pre;
            pre->next = tmp;
            orig->next = cur;
            if(tmp == NULL)break;
            pre = tmp;
            cur = tmp->next;
            orig = orig->next->next;
        }

        return dummyNode->next;
    }

指针法：

用了三个指针，分别指向两个相邻的元素和前一组相邻元素的后一个元素（第一次写的时候没有写怎么与前一组元素相连）相邻的两个交换位置，并与前一组相连

(递归法)

Leetcode 19 remove Nth Node From End of List

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *dummy = new ListNode(0);
        dummy->next = head;
        ListNode *fast = dummy;
        ListNode *low = dummy;
        for(int i = 0; i<n; i++){
            fast = fast->next;
        }
        while(fast->next != NULL){
            fast = fast->next;
            low = low->next;
        }
        ListNode *tmp = low->next;
        low->next = tmp->next;
        delete tmp;
        return dummy->next;
    }
};

有快慢两个指针，fast先走n步，然后两个指针同时前进，直到fast走到尽头

注意：

1. fast需要走到末尾的值，而不是直接到NULL,这样low才是删除节点的前一个node

2. 使用虚拟头节点

leetcode 160

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int Na = 0;
        int Nb = 0;
        ListNode *pa = headA;
        ListNode *pb = headB;
        while(pa != NULL){
            Na++;
            pa = pa->next;
        }
        while(pb != NULL){
            Nb++;
            pb = pb->next;
        }

        pa = headA;
        pb = headB;

        if(Na < Nb){
            swap(Na, Nb);
            swap(pa, pb);
        }

        int n = Na - Nb;
        while(n--){
            pa = pa->next;
        }
        while(pa!= NULL){
            if(pa == pb)
               return pa;
            pa = pa->next;
            pb = pb->next;
        }
        return NULL;
    }
};

同样设置两个指针，先算出两个链表的长度，再让长的链表的指针先走，使他们能够同时到达相交的节点

Leetcode142 Linked List Cycle2

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *slow = head;
        ListNode *fast = head;
        while(fast != NULL && fast->next != NULL){
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast)break;
        }
        if(fast ==NULL || fast->next == NULL){
            return NULL;
        }
        slow = head;
        while(slow != fast){
            slow = slow->next;
            fast = fast->next;
        }

        return slow;
    }
};

有快慢两个指针，快指针每次走两步，慢指针每次走一步，最后一定会在环内相遇。此时从环的起点到相遇点的距离是快慢指针一起走过的，假设距离为k，那么fast剩余在环内走过的步数也为y,所以当两个指针一个从起点出发，一个从相遇点出发，都以一步向前行进，一定可以在环的起点相遇

注意：要注意到无环的情况