八大排序算法之快速排序Java版

快速排序

  快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。

  具体算法描述如下：
      步骤1：从数列中挑出一个元素（一般选择第一个或者最后一个数），称为 “基准”（pivot ）；
      步骤2：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
           在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
      步骤3：递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

算法分析

• 最佳情况：T(n) = O(nlogn)
• 最差情况：T(n) = O(n2)
• 平均情况：T(n) = O(nlogn)

 

代码如下(既有以第一个数为基准的也有以最后一个数为基准的):

public class QuickSort {

    public static void main(String[] args) {
        //定义一个大点的数组，测试快速排序需要多长时间
        // 给8w个随机数排序
        //int arr[] = new int[]{1,3,2,4,5,7,6,8};
        int arr[] = new int[10]; //快速排序8000w个数据只要6s
        //随机生成数
        for (int i = 0; i < arr.length; i++) {
            //生成0~100w之间的随机数
            arr[i] = (int) (Math.random() * 100);
        }
        System.out.println("排序前");
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("%d%c", arr[i], (i + 1) % 10 == 0 ? '\n' : 32);
        }
        long startTime = Long.valueOf(String.valueOf(System.currentTimeMillis()));
        quickSort(arr,0,arr.length-1);
        long endTime = Long.valueOf(String.valueOf(System.currentTimeMillis()));
        System.out.println("\n排序后");
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("%d%c", arr[i], (i + 1) % 10 == 0 ? '\n' : 32);
        }
        System.out.println("\n优化后的快速排序(移位法)给" + arr.length + "个数据排序的时间(ms)为:" + (endTime - startTime)); // 6ms 8w, 626ms 800w
    }

    /**
     * 实现快速排序算法
     * @param arr
     */
    private static void quickSort(int[] arr,int left,int right) {
        if (left < right){
            int pivotIndex = partition(arr,left,right);
            quickSort(arr,left,pivotIndex-1); //左递归
            quickSort(arr,pivotIndex+1,right);//右递归
        }
    }

    private static int partition(int[] arr, int left, int right) {
        //以最后一个数为基准
        int pivot = arr[right];
        int pivotIndex = left;
        for (int j = left; j < right; j++) {
            if (arr[j] < pivot){ //从小到大排序
                //交换
                int temp = arr[pivotIndex];
                arr[pivotIndex] = arr[j];
                arr[j] = temp;
                //向后移
                pivotIndex++;
            }
        }

        //交换
        int temp = arr[pivotIndex];
        arr[pivotIndex] = arr[right];
        arr[right] = temp;
        //返回基准值的下标
        return pivotIndex;

        //以第一个数为基准
        /*int pivot = arr[left];
        int pivotIndex = right;
        for (int j = right; j > left; j--) {
            if (arr[j] > pivot){ //从小到大排序
                //交换
                int temp = arr[pivotIndex];
                arr[pivotIndex] = arr[j];
                arr[j] = temp;
                //向前移
                pivotIndex--;
            }
        }

        //交换
        int temp = arr[pivotIndex];
        arr[pivotIndex] = arr[left];
        arr[left] = temp;
        //返回基准值的下标
        return pivotIndex;*/

    }

}