【原创】leetCodeOj --- Sort List 解题报告

今日leetcode链表题全制霸

原题地址：
https://oj.leetcode.com/problems/sort-list/
题目内容：

Sort List

Sort a linked list in O(n log n) time using constant space complexity.

方法：

题目要求是链表排序，同时时间复杂度要求O(n log n)，空间复杂度要求常数空间。这意味着你不可以把链表拷贝到数组中，用一个map保留值和指针的对应关系，最后在构造一个链表。

我们需要考察不同的排序算法，看看哪种排序算法可以处理链表。关键在于哪种排序算法对于随机访问的依赖度低。

快排：首位指针，排除

堆排：要有两个儿子，排除

那就只能用归并排序了。

这次先给代码再分析复杂度

全部代码：

/**
* 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)
return NULL;
int len = countLength(head);
if (len == 1)
return head;
int mid = len / 2;
ListNode *sec = dividedLst(head,mid);
head = sortList(head);
sec  = sortList(sec);
head = mergeList(head,sec);
return head;
}

ListNode *mergeList(ListNode *lst1,ListNode *lst2)
{
if (!lst2)
return lst1;
if (!lst1)
return lst2;
ListNode *ptr_lst1 = lst1;
ListNode *ptr_lst2 = lst2;
ListNode *begin = (ListNode *)malloc(sizeof(ListNode));
ListNode *tail  = begin;
tail->next = NULL;
while (ptr_lst1 && ptr_lst2)
{
if (ptr_lst1->val < ptr_lst2->val)
{
tail->next = ptr_lst1;
ptr_lst1   = ptr_lst1->next;
tail->next->next = NULL;
tail = tail->next;
}
else
{
tail->next = ptr_lst2;
ptr_lst2   = ptr_lst2->next;
tail->next->next = NULL;
tail = tail->next;
}
}
if (!ptr_lst1 && ptr_lst2) // lst1 is empty and lst2 has some
tail->next = ptr_lst2;
if (!ptr_lst2 && ptr_lst1) // lst1 has some and lst2 is empty
tail->next = ptr_lst1;
return begin->next;
}

int countLength(ListNode *head)
{
int count = 0;
while (head)
{
count ++;
head = head->next;
}
return count;
}

ListNode *dividedLst(ListNode *lst1,int mid)
{
ListNode *pre = lst1;
int count = 0;
while (lst1)
{
if (mid == count)
{
pre->next = NULL;
return lst1;
}
count ++;
pre = lst1;
lst1 = lst1->next;
}
}
};

sort函数中，计算长度是n，合并是n，找中点是n/2，常数个n还是n

因此时间复杂度就是O(n log n)