排序算法之JAVA终极快速排序法

Posted 2020-06-17

package net.qh.test.sort;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

/**
 * Created by Administrator on 2016/03/01.
 */
public class TermSimpleQuick {

    public int[] sort(int[] arr,int left,int right){
        if ( arr == null || arr.length <= 1 ){
            return arr;
        }
        if(right - left >= 9){
            while(right - left >= 9 ){
                int i = left;
                int j = right;
                int mid = (left + right) / 2;
                if(arr[i] > arr[mid]){
                    int temp = arr[i];
                    arr[i] = arr[mid];
                    arr[mid] = temp;
                }
                if(arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
                if(arr[mid] > arr[j]){
                    int temp = arr[mid];
                    arr[mid] = arr[j];
                    arr[j] = temp;
                }
                int temp = arr[mid];
                arr[mid] = arr[right - 1];
                arr[right - 1] = temp;

                int k = i;
                int l = right - 1;
                int m = k;
                int n = l - 1;
                while(true){
                    while(m < l){
                        if(arr[m] > arr[l]){
                            break;
                        }
                        m++;
                    }
                    while(k < n){
                        if(arr[n] < arr[l]){
                            break;
                        }
                        n--;
                    }
                    if(m >= n) break;
                    int tem = arr[m];
                    arr[m] = arr[n];
                    arr[n] = tem;
                }
                int tem = arr[l];
                arr[l] = arr[m];
                arr[m] = tem;
                if(l - m > m - k){
                    sort(arr,m + 1, right);
                    right = m - 1;
                }else{
                    sort(arr,left,m - 1);
                    left = m + 1;
                }
            }
        } else {
            int i = left + 1;
            int j = right;
            for ( ; i <= j; i++){
                int k = i - 1;
                int temp = arr[i];
                while(true){
                    if(arr[k] > arr[i]){
                        arr[k + 1] = arr[k];
                    }else{
                        break;
                    }
                    arr[k] = temp;
                    k--;
                }
            }
        }
        return arr;
    }


    public static void main(String[] args){

        List<Integer> intList = new ArrayList<Integer>();
        for(int i = 0; i < 1000000; i++){
            intList.add(1000000 - i);
        }
        int[] arr = new int[intList.size()];
        for(int j = 0; j < arr.length; j++){
            arr[j] = intList.get(j);
        }
//        for(int temp : arr){
//            System.out.print(temp + ", ");
//        }
        System.out.println("");
        long start = Calendar.getInstance().getTimeInMillis();
        arr = new TermSimpleQuick().sort(arr,0,arr.length-1);
        long end = Calendar.getInstance().getTimeInMillis();
        System.out.println("所需毫秒：" + (end - start));
//        for(int temp : arr){
//            System.out.print(temp + ", ");
//        }
    }

    /**
         1. 该快速排序法是终极版的快速排序。
         2. 删除底部递归：小的分区使用递归，大的分区使用循环。
         3. 基准的选择不再盲目性： arr[left] <= arr[mid] <= arr[right],交换， arr[mid]和arr[right]，基准为：arr[right].
         4. 实战测试：4核CPU和8G内存下，对100000个整型元素的数组排序， 逆序需要 17 毫秒， 有序需要：28 毫秒
         4. 实战测试：4核CPU和8G内存下，对1000000个整型元素的数组排序， 逆序需要 55 毫秒， 有序需要：57 毫秒
     */

}