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;
        }
    }