leetcode------Sort List

标题：	Sort List
通过率：	21.3%
难度：	中等

Sort a linked list in O(n log n) time using constant space complexity.

本题就是一个排序的问题，但是是针对单向链表去处理，那么问题关键就是怎么去处理链表，时间复杂度为nlogn，所以可以使用：

1、归并排序。

2、快速排序。

我分别实现了上述两种算法，

第一种：对于实现归并排序的关键就是如何找到链表的中间值和如何去合并两个链表，对于如何合并两个链表是比较简单的，用一个额外的链表每次都链接两个链表中值较小的那一个，但是对于如何找到中间值，我参考了网上的思路，用两个指针，一个指针每次走一步，一个指针每次走两步，当快指针走到头时，慢指针所处的位置就是中间值，下面看代码：

java代码：

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode sortList(ListNode head) {
        if(head==null||head.next==null)return head;
        ListNode mid=getMid(head);
        ListNode sec=mid.next;
        mid.next=null;
        return combineList(sortList(head),sortList(sec));
    }
    public ListNode combineList(ListNode first,ListNode second){
        ListNode result=new ListNode(1);
        ListNode tmp=result;
        while(first!=null&&second!=null){
            if(first.val<second.val){
                tmp.next=first;
                first=first.next;
            }
            else
            {
                tmp.next=second;
                second=second.next;
            }
            tmp=tmp.next;
        }
        if(first!=null){
            tmp.next=first;
        }
        if(second!=null){
            tmp.next=second;
        }
        return result.next;
    }
    public ListNode getMid(ListNode head){
        ListNode p=head;
        ListNode q=head;
        while(q.next!=null&&q.next.next!=null){
            p=p.next;
            q=q.next.next;
        }
        return p;
        
    }
}

python代码：

class Solution:
    def mergeTwoLists(self, l1, l2):
        head = ListNode(0)
        current = head
        while l1 != None and l2 != None:
            if l1.val <= l2.val:
                current.next, current, l1 = l1, l1, l1.next
            else:
                current.next, current, l2 = l2, l2, l2.next
        if l1 != None:
            current.next = l1
        if l2 != None:
            current.next = l2
        return head.next
        
    def sortList(self, head):
        if head == None or head.next == None:
            return head
        fast, slow, prev = head, head, None
        while fast != None and fast.next != None:
            prev, fast, slow = slow, fast.next.next, slow.next
        prev.next = None
        sorted_l1 = self.sortList(head)
        sorted_l2 = self.sortList(slow)
        return self.mergeTwoLists(sorted_l1, sorted_l2)

第二种是快排，快排的关键是扫描，但是单向链表不支持双向扫描，那么就需要用两个指针，一前一后从链表的开头开始扫描，当前指针的值小于key时，进行与后指针的值交换。

java代码如下：

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode sortList(ListNode head) {
       quickSort(head,null);
       return head;
        
    }
    public void quickSort(ListNode start,ListNode end){
        if(start!=end){
            ListNode position=getPostion(start,end);
            quickSort(start,position);
            quickSort(position.next,end);
        }
        
    }
    public ListNode getPostion(ListNode start,ListNode end){
        ListNode p=start;
        int key=p.val;
        ListNode q=p.next;
        int tmp=0;
        while(q!=end){
            if(q.val<key){
                p=p.next;
                tmp=p.val;
                p.val=q.val;
                q.val=tmp;
            }
            q=q.next;
        }
        tmp=start.val;
        start.val=p.val;
        p.val=tmp;
        return p;
    }
}