LeetCode-148-排序链表-C语言

使用常数存储空间，使用归并排序，分治的思想，不断将链表等分，只到单节点为止，再对链表进行合并排序。
对链表等分时间复杂度O(lg2N),对两个排序链表进行合并，时间复杂度O(N)，因此时间复杂度为O（Nlg2N）。代码如下。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


typedef struct ListNode Node;

/* 合并两个排序链表 */
Node *merge(Node *l1, Node *l2){
    Node *head = NULL;
    Node *rear = NULL;
    
    while(l1 && l2){
        if(l1->val < l2->val ){
            if(!head){
                head = l1;
            }else{
                rear->next = l1;
            }
            rear = l1;
            l1 = l1->next;
        }else{
            if(!head){
                head = l2;
            }else{
                rear->next = l2;
            }
            rear = l2;
            l2 = l2->next;
        }
    }
    
    if(l2){
        if(head){
            rear->next = l2;    
        }else{
            head = l2;
        }
    }
    if(l1){
        if(head)
            rear->next = l1;
        else{
            head = l1;
        }
    }
    
    return head;
}

/* 将链表从中间分为两个链表，并返回后一个链表的头 */
Node *get_mid(Node *node){
    Node *p = node;
    Node *mid = node;
    Node *last_mid = NULL;
    
    
    if(!node || !node->next){
        return NULL;
    }
    
    /* 使用快慢指针法，p每次移动两个节点，mid每次一个节点， */
    while(p){
        p = p->next;
        if(p)
            p = p->next;
        
        last_mid = mid;
        mid = mid->next;
    }
    
    /* 将链表截断 */
    last_mid->next = NULL;
    
    return mid;
}

Node *merge_sort(Node *node){
    
    /* 递归调用的返回条件，注意在递归调用时，将递归的返回条件放在开头，对最原始的参数进行判断
     * 如果对参数进行了其他操作，有可能导致不准的情况。
     */
    if(!node || !node->next){
        return node;
    }
    
    /* 将链表一分为二 */
    Node *l1 = node;
    Node *l2 = get_mid(node);
    
    /* 分别对两个链表进行递归排序 */
    l1 = merge_sort(l1);
    l2 = merge_sort(l2);

    /* 合并两个已排序的链表 */
    return merge(l1, l2);
}

struct ListNode* sortList(struct ListNode* head){

    return merge_sort(head);
    
}

第二种方法，借助一个list等长的数组，将所有node->val地址放到数组中，使用快速排序，对数组进行排序。
空间复杂度O(N)，时间复杂度为O(N),因为首先获取了list长度。
代码如下。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
inline void swap(int *a, int *b){
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

typedef struct ListNode Node;

int get_len(Node *head){
    int i=0;
    Node *p = head;
    
    while(p){
        p = p->next;
        i++;
    }
    
    return i; 
}


void sort(int **arr, int start, int end){
    if(start >= end){
        return;
    }
    
    /*  first sort */
    /* 8 4 6 7 9 10 */
    int temp = *(arr[start]);
    int i= start; 
    int j= end;
    
    while(start < end){
        while(start<end && *(arr[end]) >= temp){
            end--;
        }    
        
        
        while(start<end && *(arr[start]) <= temp ){
            start++;
        }
        
        swap(arr[end], arr[start]);
    }
    
    swap(arr[start], arr[i]);
    
    
    /* and than recure */
    sort(arr, i, start);
    sort(arr, start+1, j);
    
}

struct ListNode* sortList(struct ListNode* head){
    Node *p = head;
    int len = get_len(head);
    
    if(!len){
        return head;
    }
    
    int **arr  = (int **)malloc(sizeof(int *) * len);
    int i=0;
    while(p){
        arr[i++] = &p->val;
        
        p = p->next;
    }
    
    
    sort(arr, 0, len-1);

    free(arr);
    return head;
}