LeetCode Sort List 链表排序（规定 O(nlogn) ）

Status: Accepted
Runtime: 66 ms

题意：根据给出的单链表，用O(nlogn)的时间复杂度来排序。由时间复杂度想到快排、归并这两种排序。本次用的是归并排序。递归将链表的规模不断二分到只剩下1或2个元素为止，这也是递归出口，一旦出现这两种情况就可以返回。这里有个问题，链表也能二分？可以的，只是麻烦了些，用两个指针可以实现找到中点。本次代码没有详细分析具体的复杂度，但确实是归并。

注意：要考虑空链表，单个元素的链表，以及多个元素的链表。

LeetCode的代码：

 /**
  * Definition for singly-linked list.
  * struct ListNode {
  *     int val;
  *     ListNode *next;
  *     ListNode(int x) : val(x), next(NULL) {}
  * };
  */
 class Solution {
 public:
     ListNode *sorted(ListNode *head) {
         //递归出口
         if(!head->next)    return head;
         if(!head->next->next)    //只有两个结点时就可以排序并返回了
         {
             if(head->val > head->next->val )
             {
                 head->next->next=head;
                 head=head->next;
                 head->next->next=;
             }
             return head;
         }        

         //找中点。方法：p2每往后移2步，p1就移1步，当p2到达最后一个结点时，p1刚好在中间
         ListNode *p1=head,*p2=head;
         while(p2)
         {
             if(p2->next)
             {
                 p2=p2->next->next;    //允许p2为空，但若p2->next为空，则p2->next->next会出错
                 p1=p1->next;
             }
             else    break;
         }
         ListNode * sec=p1->next;    //左一半的最后一个结点的next必须为空，此举是必须的
         p1->next=;

         //二分递归
         ListNode * temp1=sorted(head);
         ListNode * temp2=sorted(sec);

         //归并，且返回
         ListNode * sorted_head=NULL,*sorted_rear=NULL,*jus=NULL;
         if(temp1->val < temp2->val )    //初始化链表头尾
         {
             sorted_head=sorted_rear=temp1;
             temp1=temp1->next;
             jus=temp1;    //jus摆在刚减少元素的那个链表，以方便判断是否该链表已没有元素了
         }
         else
         {
             sorted_head=sorted_rear=temp2;
             temp2=temp2->next;
             jus=temp2;
         }
         while(jus)    //两个链表都非空
         {
             if(temp1->val < temp2->val)
             {
                 sorted_rear->next=temp1;
                 temp1=temp1->next;
                 jus=temp1;
             }
             else
             {
                 sorted_rear->next=temp2;
                 temp2=temp2->next;
                 jus=temp2;
             }
             sorted_rear=sorted_rear->next;
         }
         if(!temp1)    //temp1为空
             sorted_rear->next=temp2;
         else
             sorted_rear->next=temp1;
         return sorted_head;
     }

     ListNode *sortList(ListNode *head) {
         if(!head)    return ;
         if(head->next==NULL)    return head;
         return sorted(head);
     }
 };

Sort list

可自己测试的代码：

 #include <iostream>
 using namespace std;

 struct ListNode {
     int val;
     ListNode *next;
 };

 ListNode *sorted(ListNode *head) {
     //递归出口
     if(!head->next)    return head;
     if(!head->next->next)    //只有两个结点时就可以排序并返回了
     {
         if(head->val > head->next->val )
         {
             head->next->next=head;
             head=head->next;
             head->next->next=;
         }
         return head;
     }        

     //找中点。方法：p2每往后移2步，p1就移1步，当p2到达最后一个结点时，p1刚好在中间
     ListNode *p1=head,*p2=head;
     while(p2)
     {
         if(p2->next)
         {
             p2=p2->next->next;    //允许p2为空，但若p2->next为空，则p2->next->next会出错
             p1=p1->next;
         }
         else    break;
     }
     ListNode * sec=p1->next;    //左一半的最后一个结点的next必须为空，此举是必须的
     p1->next=;

     //二分递归
     ListNode * temp1=sorted(head);
     ListNode * temp2=sorted(sec);

     //归并，且返回
     ListNode * sorted_head=NULL,*sorted_rear=NULL,*jus=NULL;
     if(temp1->val < temp2->val )    //初始化链表头尾
     {
         sorted_head=sorted_rear=temp1;
         temp1=temp1->next;
         jus=temp1;    //jus摆在刚减少元素的那个链表，以方便判断是否该链表已没有元素了
     }
     else
     {
         sorted_head=sorted_rear=temp2;
         temp2=temp2->next;
         jus=temp2;
     }
     while(jus)    //两个链表都非空
     {
         if(temp1->val < temp2->val)
         {
             sorted_rear->next=temp1;
             temp1=temp1->next;
             jus=temp1;
         }
         else
         {
             sorted_rear->next=temp2;
             temp2=temp2->next;
             jus=temp2;
         }
         sorted_rear=sorted_rear->next;
     }
     if(!temp1)    //temp1为空
         sorted_rear->next=temp2;
     else
         sorted_rear->next=temp1;
     return sorted_head;
 }

 ListNode *sortList(ListNode *head) {
     if(!head)    return ;
     if(head->next==NULL)    return head;
     return sorted(head);
 }

 int main()
 {

     ListNode * head=new(ListNode);
     head->val=;    //链表有1个元素
     head->next=NULL;
     ListNode * p=head;
     ListNode * temp=NULL;

     //int a[11]={2,1,3,6,5,8,4,9,7,10};
     int a[]={,};    //元素自己随意添加
     for(int i=;i<;i++)    //在这里控制元素个数。
     {
         temp=new(ListNode);
         temp->val=a[i];
         temp->next=NULL;
         p->next=temp;
         p=p->next;
     }
     p=sortList(head);
     while(p)
     {
         printf("%d\n",p->val);
         p=p->next;
     }

     return ;
 }

Test Code