[leetcode] Sort List

题目描述：Sort a linked list in O(n log n) time using constant space complexity

这个题目本身的时间复杂度很容易让人想到mergesort的算法复杂度，所以考虑用mergesort的方法进行解题。但是在学习mergesort时，存储元素的是数组，而现在如果存储结构变成链表。算法的大体思想是按照mergesort的思想进行的，主要分以下步骤：

1. 将链表分为左右两部分；
2. 对左边的链表调用mergesort的函数；
3. 对右边的链表调用mergesort的函数；
4. 将左右的排好序的链表进行合并merge;

算法本身的思想很简单，主要难度在编程过程中对于一些特殊情况的考虑上，这主要集中在对merge函数的编写上。

merge函数和以数组方式存储的merge会有不同，主要是直接进行操作，而不用另外开辟空间进行额外存储。主要思路是：

将right链表中的节点依次加入left节点中，其中涉及到对指针的移动，很容易出现问题。

下面针对编程过程中需要考虑的一些特殊情况进行说明：

• 第一种情况：考虑首节点的问题。在最开始，左边的current和before都指在了首节点。在合并右边节点的过程中和普通的合并方式会有不同。
• 第二种情况：考虑左边的current节点为空，右边的节点不为空的情况。

 

/**
 * 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) {
        if(head == NULL || head -> next == NULL)
            return head;
        
        int size = 0;
        ListNode* current = head;
        while(current != NULL){
            current = current->next;
            size++;
        }
        current = head;
        for(int i = 0; i < size / 2 - 1; i++){
            current = current -> next;
        }
        ListNode* left = head;
        ListNode* right = current -> next;
        current -> next = NULL;
        
        left = sortList(left);
        right = sortList(right);
        head = merge(left,right);
        return head;
    }
    
    ListNode* merge(ListNode* left, ListNode* right){
        
        ListNode* leftCurrent = left;
        ListNode* leftBefore = left;
        ListNode* rightCurrent = right;
        ListNode* rightNext = right -> next;
        
        while(leftCurrent != NULL && rightCurrent!= NULL){
            if(rightCurrent -> val < leftCurrent -> val){
                if(leftBefore == leftCurrent){
                    rightCurrent -> next = leftBefore;
                    leftBefore = rightCurrent;
                    left = leftBefore;
                    leftCurrent = leftBefore -> next;
                    rightCurrent = rightNext;
                    if(rightCurrent != NULL)
                        rightNext = rightCurrent -> next;
                }
                else{
                    rightCurrent -> next = leftBefore -> next;
                    leftBefore -> next = rightCurrent;
                    leftBefore = rightCurrent;
                    rightCurrent = rightNext;
                    if(rightCurrent != NULL)
                        rightNext = rightCurrent -> next;
                }
            }
            else{
                leftBefore = leftCurrent;
                if(leftCurrent != NULL)
                    leftCurrent = leftCurrent -> next;
            }
        }
        if(rightCurrent != NULL)
            leftBefore -> next = rightCurrent;
        
        return left;

    }
};