Leetcode总结 链表专题

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* dummy = new ListNode(-1);
        ListNode* pre = dummy;
        int carry = 0;
        while(l1 || l2)
        {
            int res = carry;
            int a = l1 ? l1->val : 0;
            int b = l2 ? l2->val : 0;
            res += a + b;
            carry = res / 10;
            int t = res % 10;
            pre->next = new ListNode(t);
            pre = pre->next;
            if(l1) l1 = l1->next;
            if(l2) l2 = l2->next; 
        }
        if(carry) pre->next = new ListNode(1);
        return dummy->next;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *dummy = new ListNode(-1);
        dummy->next = head;
        ListNode *first = dummy, *second = dummy;
        for(int i = 0; i < n; i ++) first = first->next;
        while(first->next)
        {
            first = first->next;
            second = second->next;
        }
        second->next = second->next->next;
        return dummy->next;
    }    
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* dummy = new ListNode(-1);
        ListNode* pre = dummy;
        while(l1 && l2)
        {
            if(l1->val < l2->val)
            {
                pre->next = l1;
                l1 = l1->next;
            }
            else 
            {
                pre->next = l2;
                l2 = l2->next;
            }
            pre = pre->next;            
        }
        if(l1) pre->next = l1;
        if(l2) pre->next = l2;
        return dummy->next;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size() == 0) return NULL;
        if(lists.size() == 1) return lists[0];
        if(lists.size() == 2) return mergeTwoLists(lists[0], lists[1]);
        int mid = lists.size() / 2;
        vector<ListNode*> sub1_lists;
        vector<ListNode*> sub2_lists;
        for(int i = 0; i < mid; i ++)        
            sub1_lists.push_back(lists[i]);        
        for(int i = mid; i < lists.size(); i ++)
            sub2_lists.push_back(lists[i]);
        ListNode* l1 = mergeKLists(sub1_lists);
        ListNode* l2 = mergeKLists(sub2_lists);
        return mergeTwoLists(l1, l2);
    }

    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2)
    {
        ListNode* dummy = new ListNode(-1);
        ListNode* head = dummy;
        while(l1 && l2)
        {
            if(l1->val <= l2->val)
            {
                head->next = l1;
                l1 = l1->next;
            }
            else
            {
                head->next = l2;
                l2 = l2->next;
            }
            head = head->next;
        }
        head->next = (l1 == NULL) ? l2 : l1;
        return dummy->next;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head == NULL || head->next == NULL) return head;
        ListNode* headNext = head->next;
        head->next = swapPairs(headNext->next);
        headNext->next = head;
        return headNext;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* pre = NULL; //头
        ListNode* next = NULL; //尾
        ListNode* cur = head;
        ListNode* check = head; //检查链表长度够不够翻转
        int count = 0, len = 0;
        while(len < k && check)
        {
            check = check->next;
            len ++;
        }
        if(len == k)
        {
            while(count < k && cur)
            {
                next = cur->next;
                cur->next = pre;
                pre = cur;
                cur = next;
                count ++;
            }
            if(next)
                head->next = reverseKGroup(next, k);
            return pre;
        }
        else return head;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(head == NULL) return head;
        ListNode* tail;
        ListNode*a = head;
        int n = 0;
        for(auto p = head; p; p = p->next)
        {
            n ++;
            tail = p;
        }
        k %= n;
        if(!k) return head;
        for(int i = 0; i < n - 1 - k; i ++) a = a->next;
        ListNode* next = a->next;
        tail->next = head;
        a->next = NULL;
        return next;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode*dummy = new ListNode(-1);
        dummy->next = head;
        ListNode*p = dummy;
        while(p->next)
        {
            ListNode* q = p->next;
            while(q && q->val == p->next->val)
                q = q->next;
            if(p->next->next == q) p = p->next;
            else p->next = q;
        }
        return dummy->next;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(!head) return 0;
        ListNode* p = head, *q = head;
        while(p)
        {
            if(p->val != q->val)
            {
                q->next = p;
                q = p;
            }
            p = p->next;
        }
        q->next = NULL;
        return head;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode*dummmy = new ListNode(-111111111);
        dummmy->next = head;
        ListNode*pre = dummmy;
        while(pre->next)
        {
            if(pre->val == pre->next->val) pre->next = pre->next->next;
            else pre = pre->next;
        }
        return dummmy->next;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(head == NULL) return head;
        ListNode*a = head;
        while(a->next)
        {
            if(a->val == a->next->val) a->next = a->next->next;
            else a = a->next;
        }
        return head;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        ListNode* before = new ListNode(-1);
        ListNode* after = new ListNode(-1);
        ListNode* pb = before, *pa = after;
        for(ListNode* p = head; p; p = p->next)
        {
            if(p->val < x)
            {
                pb->next = p;
                pb = p;
            }
            else{
                pa->next = p;
                pa = p;
            }            
        }
        pb->next = after->next;
        pa->next = NULL;
        return before->next; 
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if(m == n) return head;
        if(!head) return 0;
        ListNode* dummy = new ListNode(-1);
        dummy->next = head;
        ListNode* a = dummy;
        for(int i = 0; i < m - 1; i ++) a = a->next;
        ListNode* b = a;
        b = b->next;
        ListNode* c = b->next;
        for(int i = 0; i < n - m; i ++)
        {
            ListNode* next = c->next;
            c->next = b;
            b = c;
            c = next;
        }
        ListNode* an = a->next;
        a->next = b;
        an->next = c;
        return dummy->next;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* sortedListToBST(ListNode* head) {
        if(!head) return 0;
        return dfs(head, 0);
    }

    TreeNode* dfs(ListNode* head, ListNode* tail)
    {
        if(head == tail) return 0;
        ListNode* slow = head;
        ListNode* fast = head;
        while(fast != tail && fast->next != tail)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        TreeNode* root = new TreeNode(slow->val);
        root->left = dfs(head, slow);
        root->right = dfs(slow->next, tail);
        return root;
    }
};

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(!head) return head;
        Node* p = head, *tempP;
        while(p)
        {
            tempP = new Node(p->val, p->next, p->random);
            tempP->next = p->next;
            p->next = tempP;
            p = p->next->next;
        }
        p = head;
        while(p)
        {
            if(p->random)
            {
                p->next->random = p->random->next;
            }
            else p->next->random = NULL;
            p = p->next->next;
        }
        p = head;
        Node* copyHead = p->next;
        while(p)
        {
            tempP = p->next;
            p->next = p->next->next;
            if(tempP->next)
                tempP->next = tempP->next->next;
            p = p->next;
        }
        return copyHead;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(!head || !head->next) return 0;
        ListNode* a = head, *b = head->next;
        while(a && b)
        {
            if(a == b) return true;
            a = a->next;
            b = b->next;
            if(b) b = b->next;
        }
        return false;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if(!head) return head;
        ListNode* a = head, *b = head;
        while(a && b)
        {
            a = a->next;
            b = b->next;
            if(b) b = b->next;
            else return 0;
            if(a == b)
            {
                a = head;
                while(a != b)
                {
                    a = a->next;
                    b = b->next;
                }
                return b;
            }
        }
        return 0;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void reorderList(ListNode* head) {
        if(!head) return;
        int n = 0;
        for(auto p = head; p; p = p->next) n ++;
        if(n <= 2) return;
        ListNode* mid = head;
        for(int i = 0; i < (n + 1) / 2 - 1; i ++) mid = mid->next;
        ListNode* a = mid->next;
        mid->next = NULL;
        ListNode* b = a->next;
        a->next = NULL;
        while(b)
        {
            ListNode* next = b->next;
            b->next = a;
            a = b;
            b = next;
        }
        b = head;
        while(a)
        {
            ListNode* next = a->next;
            a->next = b->next;
            b->next = a;
            a = next;
            b = b->next->next;
        }
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* insertionSortList(ListNode* head) {
        ListNode *dummy = new ListNode(-1);
        while(head)
        {
            ListNode*p = dummy;
            while(p->next && p->next->val <= head->val) p = p->next;
            ListNode* next = head->next;
            head->next = p->next;
            p->next = head;
            head = next;
        }
        return dummy->next;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        return head == NULL ? NULL : mergeSort(head);
    }

    ListNode* mergeSort(ListNode* node)
    {
        if(!node->next) return node;
        ListNode* a = node, *b = node;
        ListNode* breakN = node;
        while(a && a->next)
        {
            a = a->next->next;
            breakN = b;
            b = b->next; //b为中点
        }
        breakN->next = NULL;
        ListNode*l = mergeSort(node);
        ListNode*r = mergeSort(b);
        return mergeTwoList(l, r);
    }

    ListNode* mergeTwoList(ListNode*l1, ListNode*l2)
    {
        ListNode*dummy = new ListNode(-1);
        ListNode*cur = dummy;
        while(l1 && l2)
        {
            if(l1->val <= l2->val)
            {
                cur->next = l1;
                l1 = l1->next;
            }
            else
            {
                cur->next = l2;
                l2 = l2->next;
            }
            cur = cur->next;
        }
        cur->next = (l1 == NULL ? l2 : l1);
        return dummy->next;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* a = headA, *b = headB;
        while(a != b)
        {
            if(!a) a = headB;
            else a = a->next;
            if(!b) b = headA;
            else b = b->next;
        } //如果不想交 走a + b 后都为NULL
        return a;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode *dummy = new ListNode(-1);
        dummy->next = head;
        for(ListNode *p = dummy; p; )
        {
            if(p->next && p->next->val == val)
                p->next = p->next->next;
            else
                p = p->next;
        }
        return dummy->next;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(!head) return head;
        ListNode *p = NULL;
        while(head)
        {
            ListNode *next = head->next;
            head->next = p;
            p = head;
            head = next;
        }
        return p;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(!head || !head->next) return head;
        ListNode *p = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return p;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        ListNode *fast = head, *slow = head, *pre = NULL;
        while(fast)
        {
            slow = slow->next;
            fast = fast->next ? fast->next->next : fast->next;
        }
        while(slow)
        {
            ListNode *next = slow->next;
            slow->next = pre;
            pre = slow;
            slow = next;
        }
        while(head && pre)
        {
            if(head->val != pre->val)
                return false;
            head = head->next;
            pre = pre->next;
        }
        return true;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        node->val = node->next->val;
        node->next = node->next->next;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        ListNode *o = head;
        ListNode *e = head->next;
        ListNode *p = e;
        while(o->next && e->next)
        {
            o->next = e->next;
            o = o->next;
            e->next = o->next;
            e = e->next;
        }
        o->next = p;
        return head;
    }
};