[leetcode]Sort List

题目要求：
Sort a linked list in O(n log n) time using constant space complexity.

 数据结构定义：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

这里用的数据结构是单链表。时间复杂度是O(n log n)的排序算法有：堆排序，快速排序，归并排序。题目要求使用常量的空间复杂度，这三种排序方法的空间复杂度分别是O(n),O(1),O(n)[对于数组]。归并排序的空间复杂度是O(n)，因为对于数组，归并排序需要额外的O(n)的空间来处理数组，而对于链表而言，操作都是对指针的，所以可以将空间复杂度降到O(1)。

这里使用归并排序来实现代码。

/**
 * 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)
            return head;
        else if (head->next == NULL) 
            return head;
        
        ListNode *slow = head, *fast = head;
        while (fast->next != NULL && fast->next->next != NULL)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        
        fast = slow;
        slow = slow->next;
        fast->next = NULL;
        
        fast = sortList(head);
        slow = sortList(slow);
        
        return mergeList(fast,slow);
        
    }
    ListNode* mergeList(ListNode* list1Head, ListNode* list2Head){
        if (list1Head == NULL) return list2Head;
        if (list2Head == NULL) return list1Head;
        
        ListNode* result, *temp;
        // initialize the first node of the merged result list
        if (list1Head->val < list2Head->val){
            result = list1Head;
            list1Head = list1Head->next;
        }
        else
        {
            result = list2Head;
            list2Head = list2Head->next;
        }
        // operate the result list with temp
        temp = result;
        // end merge if at least one of the two lists reaches the tail node
        while (list1Head != NULL && list2Head != NULL){
            if (list1Head->val < list2Head->val){
                temp->next = list1Head;
                list1Head = list1Head->next;
            }
            else{
                temp->next = list2Head;
                list2Head = list2Head->next;
            }
            temp = temp->next;
        }
        
        if (list1Head != NULL)
            temp->next = list1Head;
        else
            temp->next = list2Head;
            
        return result;
    }
};

这个简单的OJ浪费了我大概半个多小时在调试BUG，实在有点太菜了。AC之前我的代码遇到了下面几个恶心的BUG。

1. 在找到链表的中间节点后，用head和slow来表示左右两个子脸变的时候，没有把中间节点的next指针置为空，导致程序无限递归，最后导致堆溢出。

2. 在合并排序数组的函数中，处理未添加到result链表中的节点（64~67）时，if语句条件写错了。....

.....

沉心学习，努力积累，希求爆发。