LeetCode148——排序链表

思考：

提到O（nlogn）的时间复杂度进行排序首先就想到归并排序，但是空间复杂度不是O（n）吗？为什么是常熟级空间复杂度，常数级空间复杂度，指的是算法所需的额外存储空间与问题的输入规模无关。后来看到别人的博客：Sort List——经典（链表中的归并排序）“因为原来使用归并时，都是 O(N)的，需要复制出相等的空间来进行赋值归并。对于链表，实际上是可以实现常数空间占用的（链表的归并排序不需要额外的空间）”，在下面的操作也只是开辟了一个链表节点的空间。

注意：快慢指针找链表中点的停止条件：fast->next &&fast->next->next

归并排序，递归到最底层，将会是两个节点，所以就成了有序的，接下来就是简单的“合并两个有序的链表问题”。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode l(0); //建立一个新的链表
        ListNode*ptr = &l;
        while(l1&&l2){
            if(l1->val <= l2->val){
                ptr->next = l1;
                l1 = l1->next;
            }
            else{
                ptr->next = l2;
                l2 = l2->next;
            }
        //ptr表示当前的头部结点，添加一个节点之后，无论是l1,l2,都必须向后移动一个
            ptr = ptr->next;
        }
        if(l1){
            ptr->next = l1;
        }
        else if(l2){
            ptr->next = l2;
        }
        return l.next;
    }
  ListNode* sortList(ListNode* head) {
       if(head == NULL || head->next == NULL){
           return head;
       }  
      //通过快慢指针来找到链表的中点
      ListNode* fast = head,*slow = head;
      while(fast->next && fast->next->next){
          slow = slow->next;
          fast = fast->next->next;
      }
      ListNode*right = slow->next;
      slow->next = NULL;
      ListNode*l1 = sortList(head);
      ListNode*l2 = sortList(right);
      return mergeTwoLists(l1,l2);
  }
 };