leetcode—6/20

1. 對鏈表進行插入排序

對鏈表進行插入排序
算法：

1. 插入排序是迭代的，每次只移動一個元素，直到所有元素可以形成一個有序的輸出列表
2. 每次迭代中，插入排序只從一個輸入數據移除一個待排序的元素，找到它在序列中適當的位置，並將其插入
3. 重複直到所有輸入數據插入完爲止

ListNode* insertionSortList(ListNode* head) {
        ListNode* dummy = new ListNode(0);
        while(head)
        {
            ListNode* p = dummy;
            while(p -> next && p -> next -> val < head -> val)
            {
                p = p -> next;
            }
            ListNode* temp = p -> next;
            p -> next = head;
            head = head -> next;
            p -> next -> next = temp;
        }
        return dummy -> next;
    }

2. 排序鏈表

在O(nlogn)時間複雜度和常數級空間複雜度下，對鏈表進行排序

思路：

1. 快慢指針找中點
2. 遞歸調用mergeSort
3. 合併兩個鏈表

ListNode* sortList(ListNode* head) {
        return mergeSort(head);
    }
    ListNode* mergeSort(ListNode* node)
    {
        if(node == nullptr || node -> next == nullptr)
        {
            return node;
        }
        ListNode* fast = node;
        ListNode* slow = node;
        ListNode* breakN = node;
        while(fast && fast -> next)
        {
            fast = fast -> next -> next;
            breakN = slow;
            slow = slow -> next;
        }
        breakN -> next = nullptr;
        ListNode* l1 = mergeSort(node);
        ListNode* l2 = mergeSort(slow);
        return merge(l1, l2);
    }
    ListNode* merge(ListNode* l1, ListNode* l2)
    {
        if(l1 == nullptr)
        {
            return l2;
        }
        if(l2 == nullptr)
        {
            return l1;
        }
        if(l1 -> val <= l2 -> val)
        {
            l1 -> next = merge(l1 -> next, l2);
            return l1;
        }
        else
        {
            l2 -> next = merge(l2 -> next, l1);
            return l2;
        }
    }