Java排序算法 [选择、冒泡、快排]

import java.io.UnsupportedEncodingException;
import java.util.*;

public class Hello {
    public static void main(String[] args) throws UnsupportedEncodingException {
        int number = 100000;
        int [] randm_number = new int[number];
        Random random = new Random();
        for (int i = 0;i<number;i++){
            randm_number[i] = random.nextInt(number);
        }
        System.out.println(Arrays.toString(randm_number));

        //经典：
        long start1 = System.currentTimeMillis();
        QuickSort(randm_number,0,randm_number.length -1);
        long end1 = System.currentTimeMillis();
        System.out.println(end1 - start1);

        //冒泡：
        long start2 = System.currentTimeMillis();
        BubbleSort(randm_number);
        long end2 = System.currentTimeMillis();
        System.out.println(end2 - start2);

        //新快速
        long start3 = System.currentTimeMillis();
        Arrays.sort(randm_number);
        long end3 = System.currentTimeMillis();
        System.out.println(end3 - start3);

        System.out.println(Arrays.toString(randm_number));

    }

    /**
     * 冒泡
     * @param array
     */
    public static void BubbleSort(int[] array){
        for (int i = 0;i<array.length -1;i++){
            for (int j=0;j<array.length - i -1;j++){
                if (array[j]<array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
        }
    }

    /**
     * 经典快排
     * @param array
     * @param L
     * @param R
     */
    public static void QuickSort(int[] array,int L ,int R){
        if (L >= R){
            return;
        }
        int left = L, right = R;
        int poivot = array[left];

        while (left < right){
            while (left < right && array[right] >= poivot) {
                right--;
            }
            if (left < right){
                array[left] = array[right];
            }
            while (left < right && array[left] <= poivot){
                left++;
            }
            if (left < right){
                array[right] = array[left];
            }
            if (left >= right){
                array[left] = poivot;
            }
        }
        QuickSort(array, L,right-1);
        QuickSort(array,right+1, R);
    }
}

结果：

089, 81236, 3234, 71171, 78906, 67248, 81941, 24658, 84343, 35482, 50401, 57262, 42241, 984, 66610, 92974, 37661, 61599, 96782, 14025,
95
11074
4
[2, 3, 7, 7, 8, 10, 11, 11, 12, 13, 14, 15, 15, 16, 16, 17, 17, 19, 19, 19, 21, 21, 22, 22, 22, 22, 24, 24, 24, 24, 34, 37, 37, 39,

评价：
通过性能测试结果可以看出：冒泡排序的效率最低；DualPivotQuicksort的效率最高。

通过网络资料和jdk1.8的排序实现方式上可以看出，新版的快排在经典快排的基础上增加了poivot分隔点，将原来的入参数组一个分给点分成两份，改为了两个分隔点分成三份。

对于一次array[i]的访问可看做一次元素扫描，在内存频率提升不如cpu提升效率高的今天，降低元素扫描次数即可提升整个排序效率