Leetcode148. Sort List排序链表

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

示例 1:

输入: 4->2->1->3 输出: 1->2->3->4

示例 2:

输入: -1->5->3->4->0 输出: -1->0->3->4->5

不推荐：

 class Solution {
  public:
	  ListNode * sortList(ListNode* head) 
	  {
		  int len = GetLength(head);
		  if (len == 0 || len == 1)
			  return head;
		  return Merge(head, 0, len - 1);
	  }

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

	  ListNode* Merge(ListNode *head, int start, int end)
	  {
		  if (head == NULL || start > end)
		  {
			  return NULL;
		  }
		  if (start == end)
		  {
			  return new ListNode(head->val);
		  }
		  //
		  int mid = (start + end) / 2;
		  int cnt = mid;
		  ListNode* head1 = head;
		  while (cnt-- && head1 ->next != NULL)
		  {
			  head1 = head1->next;
		  }
		  head1 = head1 ->next;
		  head = Merge(head, start, mid);
//如果写mid + 1，end会出错，因为是链表，不是数组，而且head1已经到了第二个分治的链表的头部
		  head1 = Merge(head1, 0, (end - mid - 1));
		  ListNode *newHead = NULL;
		  ListNode* lastNode = NULL;
		  while (head != NULL && head1 != NULL)
		  {
			  if (head->val > head1->val)
			  {
				  if (lastNode == NULL)
				  {
					  newHead = new ListNode(head1->val);
					  lastNode = newHead;
				  }
				  else
				  {
					  lastNode->next = new ListNode(head1->val);
					  lastNode = lastNode->next;
				  }
				  head1 = head1->next;
			  }
			  else
			  {
				  if (lastNode == NULL)
				  {
					  newHead = new ListNode(head->val);
					  lastNode = newHead;
				  }
				  else
				  {
					  lastNode->next = new ListNode(head->val);
					  lastNode = lastNode->next;
				  }
				  head = head->next;
			  }
		  }

		  while (head != NULL)
		  {
			  if (lastNode == NULL)
			  {
				  newHead = new ListNode(head->val);
				  lastNode = newHead;
			  }
			  else
			  {
				  lastNode->next = new ListNode(head->val);
				  lastNode = lastNode->next;
			  }
			  head = head->next;
		  }
		  while (head1 != NULL)
		  {
			  if (lastNode == NULL)
			  {
				  newHead = new ListNode(head1->val);
				  lastNode = newHead;
			  }
			  else
			  {
				  lastNode->next = new ListNode(head1->val);
				  lastNode = lastNode->next;
			  }
			  head1 = head1->next;
		  }
		  return newHead;
	  }
  };

推荐做法：

1，快慢指针找中点；

2，递归调用mergeSort，

3，合并两个链表

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        return mergeSort(head);
    }
    
    ListNode* mergeSort(ListNode* node) {
        if (!node || !node->next) 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;
        }
    }
}