Leetcode 148. Sort List

题意：链表排序，要求复杂度n*logn;

思路：这道题用了好长时间 ，我先用快速排序做的，结果超时了，发现样例中重复数据很多，看来有意不让用快拍。于是乎想到了归并排序，这应该是我第一次写完整的归并排序，特意分模块优美了一些。一下就是链表的归并排序

ListNode* sortList(ListNode* head) {
        ListNode *p;
        
        if(head == NULL)
            return NULL;
        if(head->next ==NULL)
            return head;
        if(head->next->next == NULL){
            if(head->val > head->next->val){
                p = head->next;
                p->next = head;
                head ->next = NULL;
                head = p;
                
                //return head;
            }
            return head;
        }
        
        //异步指针得到中点
        ListNode *pf,*ps;
        
        pf = ps = head;
        while(pf != NULL){
            pf = pf->next;
            if(pf == NULL)
                break;
            pf = pf->next;
            ps = ps->next;
        }

        //中点划分，得到两个子链表
        ListNode *h1,*h2;
        h1 = head;
        h2 = ps->next;
        ps->next = NULL;
        
        //递归，令子链表为分别为有序链表
        h1 = sortList(h1);
        h2 = sortList(h2);
        
        //合并两个有序链表
        ListNode my(0);
        p = &my;
        while(h1 !=NULL && h2!=NULL){
            if(h1->val > h2->val){
                p->next = h2;
                h2 = h2->next;
            }
            else {
                p->next = h1;
                h1 = h1->next;
            }
            p = p->next;
        }
        while(h1 != NULL){
            p ->next = h1;
            h1 = h1->next;
            p = p->next;
        }
        while(h2 != NULL){
            p->next = h2;
            h2 = h2 ->next;
            p = p->next;
        }
        p->next = NULL;
        return my.next;
    }