148.排序链表

题目描述：

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

示例 1:

输入: 4->2->1->3
输出: 1->2->3->4
示例 2:

输入: -1->5->3->4->0
输出: -1->0->3->4->5

思想1：

在链表中间断开，使用递归+归并排序对链表进行排序

代码：

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if(head==0 || head->next ==0)
            return head;
        
        ListNode* fast = head;
        ListNode* slow = head;
        ListNode* pre;

        while(fast!=0&&fast->next!=0){
            pre = slow;
            fast = fast->next->next;
            slow = slow->next;
        }
        pre->next = 0;//断开链的中点
        return merge(sortList(head),sortList(slow));

    }

    ListNode* merge(ListNode* l1, ListNode*l2){
        if(l1==0)return l2;
        if(l2==0)return l1;
        if(l1->val > l2->val){
            l2->next = merge(l2->next,l1);//这里实在是太漂亮了，代码竟然还可以这样写
            return l2;
        }
        else{
            l1->next = merge(l1->next,l2);
            return l1;
        }
    }
};

思想2（我自己的思路）：

遍历链表，每次确定val最小的位置min_ptr，将其值与当前链表头p的值交换

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        ListNode* p;
        p = head;
        while(p){
            int min_val = p->val;
            ListNode* q = p->next;
            ListNode* min_ptr=NULL;
            while(q){
                if(q->val<min_val){
                    min_val = q->val;
                    min_ptr = q;
                }
                q = q->next;
            }
            if(min_ptr){
                min_ptr->val = p->val;
                p->val = min_val;
            }
            p = p->next;
        }
        return head;
    }
};