148使用快速排序解决排序链表问题

package leetcode;

import java.util.Arrays;
import java.util.Comparator;

public class p148 {
      public static class ListNode {
      int val;
      ListNode next;
      ListNode() {}
      ListNode(int val) { this.val = val; }
      ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  }
    public static void main(String[] args) {
        int[] array={-1,5,3,4,0};
        ListNode head=new ListNode(-1);
        ListNode tmp=head;
        for (int i=1;i<array.length;i++){
            ListNode j=new ListNode(array[i]);
            tmp.next=j;
            tmp=tmp.next;
        }
        tmp=null;
        sortList2(head);
        while (head!=null){
            System.out.println(head.val);
            head=head.next;
        }



    }

    /**
     * 9:50-10.27 没写出来，快速排序使用的是下标小于，而这里结点只能用不等于，所以就会有很多问题。。。。
     * 思路1：使用快速排序的思想，遍历一次数组获取到最后一个结点的引用，之后对其进行快速排序
     * 时间复杂度：O(nlgn)
     * 空间复杂度：O(1)
     */
    public static ListNode sortList(ListNode head) {
        if (head==null || head.next==null)
            return head;
        ListNode rear=head;
        while (rear.next!=null)
            rear=rear.next;
        quickSort(head,rear);
        return head;
    }
    public static void quickSort(ListNode head,ListNode rear){
        if (head!=null && rear!=null && head!=rear){
            ListNode[] pair=partation(head, rear);
            ListNode prePosition=pair[0];
            ListNode position=pair[1];
            quickSort(head,prePosition);
            quickSort(position.next,rear);
        }
    }
    public static ListNode[] partation(ListNode head,ListNode rear){
        if (head.next==rear){
            if (head.val>rear.val){
                int tmp= head.val;
                head.val= rear.val;
                rear.val= head.val;
            }
            return new ListNode[]{head,rear};
        }
        int pivot=head.val;
        ListNode i=head;
        ListNode prePositon=head;
        for (ListNode j=i.next;j!=null;j=j.next){
            if (j.val<i.val){
                i=i.next;
                int tmp=i.val;
                i.val=j.val;
                j.val=tmp;
            }
            if (j.next==null){
                prePositon=j;
            }
        }
        head.val=i.val;
        i.val=pivot;
        return new ListNode[]{prePositon,i};
    }
    /**
     * 思路二：直接封装到一个数组中，使用自带的快速排序解决
     * 时间复杂度：O(nlgn)
     * 空间复杂度：O(n)
     */
    public static ListNode sortList2(ListNode head) {
        if (head==null || head.next==null) // 如果没有数或只有一个数则直接返回
            return head;
        ListNode i=head;
        int ct=0;
        while (i!=null){ // 计算要创建多大的数组
            i=i.next;
            ct++;
        }
        ListNode[] array=new ListNode[ct]; // 创建数组并对其进行赋值
        i=head;
        ct=0;
        while (i!=null){
            array[ct++]=i;
            i=i.next;
        }
        Arrays.sort(array, new Comparator<ListNode>() { // 按结点中的值进行排序
            @Override
            public int compare(ListNode o1, ListNode o2) {
                if (o1.val>o2.val)
                    return 1;
                else if (o1.val<o2.val) {
                    return -1;
                }else{
                    return 0;
                }
            }
        });
        for (ct=0;ct< array.length-1;ct++){ // 将数组中的值用指南按顺序连接起来即可
            array[ct].next=array[ct+1];
        }
        array[ct].next=null;
        return array[0];
    }
}