leetcode 链表排序

对链表排序，用归并排序。题目要求空间时间复杂度为O(nlogn),但是空间复杂度为O(1)

1.自己写的程序，时间复杂度为O(nlogn),但是空间复杂度为O(n)

用快慢指针(分别走2步和1步)找到中间节点。但是最后排序的部分，用复制将排好序的部分粘贴会原来链表中，这个方法比较笨，而且增加空间复杂度，并不满足题目要求

leetcode 提交的时候说runtime error,但自己执行是通过的，可能因为时间复杂度的原因吧，需要后期再改

void mergesort(ListNode* head, ListNode* as, ListNode* ae, ListNode* bs, ListNode* be){
    vector<int> vec;
    ListNode* ps = as;
    ListNode* pe = be;
    int i= 0;
    int anum = ae - as;
    int bnum = be - bs;
    int ia = 0, ib = 0;
    while(ia <= anum && ib <= bnum){
        if(as->val <= bs->val){
            vec.push_back(as->val);
            as = as->next;
            ia++;
        }
        else{
            vec.push_back(bs->val);
            bs = bs->next;
            ib++;
        }
    }
    while(ia <= anum){
        vec.push_back(as->val);
        as = as->next;
        ia++;
    }
    while(ib <= bnum){
        vec.push_back(bs->val);
        bs = bs->next;
        ib++;
    }
    int pnum = pe - ps;
    int ip = 0;
    while(ip <= pnum){
        ps->val = vec[i++];
        ps = ps->next;
        ip++;
    }
}

void merge(ListNode* head,ListNode* start, ListNode* end){
    if(start < end){
        ListNode* former=start, * latter = start;
        int snum = end - start;
        int latt = 0;
        while(latt + 2 <= snum){
            former = former->next;
            latter = latter->next->next;
            latt = latt + 2;
        }
        if(latt+1 == snum){
            latter = latter->next;
        }
        merge(head,start,former);
        merge(head,former->next,latter);
        mergesort(head,start,former,former->next,end);
    }
    else
        return;
}

2.leetcode中大神的代码，这里粘贴是为了自己以后找起来方便

它是自底向上的，归并起来。step为1，2，4，8....

/**
 * merge the two sorted linked list l1 and l2,
 * then append the merged sorted linked list to the node head
 * return the tail of the merged sorted linked list
 */


ListNode* merge(ListNode* l1, ListNode* l2, ListNode* head){
    ListNode *cur = head;
    while(l1 && l2){
        if(l1->val > l2->val){
            cur->next = l2;
            cur = l2;
            l2 = l2->next;
        }
        else{
            cur->next = l1;
            cur = l1;
            l1 = l1->next;
        }
    }
    cur->next = (l1 ? l1 : l2);
    while(cur->next) cur = cur->next;
    return cur;
}

/**
 * Divide the linked list into two lists,
 * while the first list contains first n ndoes
 * return the second list's head
 */

ListNode* split(ListNode *head, int n){
    //if(!head) return NULL;
    for(int i = 1; head && i < n; i++) head = head->next;
    
    if(!head) return NULL;
    ListNode *second = head->next;
    head->next = NULL;
    return second;
}

ListNode *sortList(ListNode *head) {
    if(!head || !(head->next)) return head;
    
    //get the linked list's length
    ListNode* cur = head;
    int length = 0;
    while(cur){
        length++;
        cur = cur->next;
    }
    
    ListNode dummy(0);
    dummy.next = head;
    ListNode *left, *right, *tail;
    for(int step = 1; step < length; step <<= 1){
        cur = dummy.next;
        tail = &dummy;
        while(cur){
            left = cur;
            right = split(left, step);
            cur = split(right,step);
            tail = merge(left, right, tail);
        }
    }
    return dummy.next;
}

其余补充的部分，对链接初始化和输出打印部分

/**
 * Definition for singly-linked list.*/
  struct ListNode {
      int val;
      ListNode *next;
      ListNode(int x) : val(x), next(NULL) {}
  };
 
ListNode* init(int a[], int n){
    ListNode* q = NULL, *head = NULL;
    for(int i = 0; i < n; i++){
        ListNode* p = new ListNode(0);
        p->val = a[i];
        if(i==0){//不要忽略头结点的赋值
            head = q = p;
            continue;
        }
        q->next=p;
        q = q->next;
    }
    q->next = NULL;
    return  head;
    
}



void prints(ListNode* head){
    while(head){
        cout<<head->val<<" ";
        head = head->next;
    }
}


    


int main(int argc, const char * argv[]) {
    int a[]={2,5,3,7,9,4,1,8};
    //int a[]={2,1};
    ListNode* head =new ListNode(0);
    head=init(a,8);
    ListNode* L = sortList(head);
    prints(L);
    return 0;
}

3.最后提交上去的版本，能运行通过且过程简单易懂，也是从别人那里看到的

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:

    void mergesort(ListNode* head, ListNode* as, ListNode* ae, ListNode* bs, ListNode* be){
    vector<int> vec;
    ListNode* ps = as;
    ListNode* pe = be;
    int i= 0;
    int anum = ae - as;
    int bnum = be - bs;
    int ia = 0, ib = 0;
    while(ia <= anum && ib <= bnum){
        if(as->val <= bs->val){
            vec.push_back(as->val);
            as = as->next;
            ia++;
        }
        else{
            vec.push_back(bs->val);
            bs = bs->next;
            ib++;
        }
    }
    while(ia <= anum){
        vec.push_back(as->val);
        as = as->next;
        ia++;
    }
    while(ib <= bnum){
        vec.push_back(bs->val);
        bs = bs->next;
        ib++;
    }
    int pnum = pe - ps;
    int ip = 0;
    while(ip <= pnum){
        ps->val = vec[i++];
        ps = ps->next;
        ip++;
    }
}

void merge(ListNode* head,ListNode* start, ListNode* end){
    int hnum = end - start;
    if(hnum > 0){
        ListNode* former=start, * latter = start->next;
        while(latter!= NULL && latter->next != NULL){
            former = former->next;
            if(latter->next->next == NULL)
                latter = latter->next;
                else
                latter = latter->next->next;
        }
        
        merge(head,start,former);
        merge(head,former->next,latter);
        mergesort(head,start,former,former->next,end);
    }
    else
        return;
}

    ListNode* sortList(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        ListNode* p = head;
        while(p->next != NULL)
            p = p->next;
        merge(head,head,p);
        return head;
        }
};