java list快速排序算法_排序算法之 Java改进版快速排序算法

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 ProSimpleQuick {

public int[] sort(int[] arr,int left,int right){

if ( arr == null || arr.length <= 1 ){

return arr;

}

if(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;

sort(arr,left,m - 1);

sort(arr,m + 1, right);

}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 intList = new ArrayList();

for(int i = 0; i < 100000; i++){

intList.add(100000 - 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 ProSimpleQuick().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. 当数组的数量小于10的时候，拒绝使用快速排序，使用插入法排序。这样做提高了性能，有效减少了栈溢出的概率。

3. 基准的选择不再盲目性： arr[left] <= arr[mid] <= arr[right],交换， arr[mid]和arr[right]，基准为：arr[right].

4. 实战测试：4核CPU和8G内存下，对100000个整型元素的数组排序， 逆序需要 20 毫秒， 有序需要：23 毫秒

*/

}