java排序算法｜快速排序

快速排序

• • • • 算法描述
      • 时间复杂度
      • 算法演示图
      • 代码实现
      • • 第一种
        • 运行结果
        • 第二种
        • 运行结果

算法描述

• 从数列中挑出一个元素，称为 “基准”（pivot）；
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
• 简单来说就是：挖坑填数 + 分而治之

时间复杂度

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

算法演示图

代码实现

第一种

public class QuickSort {
    public static int[] quickSort(int[] array, int L, int R) {
        if (L >= R)
            return array;
        //定义子串的左下标和右下标
        int left = L;
        int right = R;
        //得到基数
        int pivot = array[left];
        while (left < right) {
            //左边的下标小右边的下标且 基数右边的值大于基数
            while (left < right && array[right] >= pivot) {
                right--;
            }
            if (left < right) {
                array[left] = array[right];
            }
            while (left < right && array[left] <= pivot) {
                left++;
            }
            if (left < right) {
                array[right] = array[left];
            }
            //如果两个下标相等那么将基数赋值在相等的下标的位置
            if (left >= right) {
                array[left] = pivot;
            }
        }
        //分配左右子串遍历
        //遍历左子串
        quickSort(array, L, right - 1);
        //遍历右子串
        quickSort(array, right + 1, R);
        return array;
    }

    public static void main(String[] args) {
        int[] array = {3,43,38,5,47,15,36,26,27,2,46,4,19,50,48};
        int[] sort = quickSort(array, 0, array.length - 1);
        for (int i = 0; i < sort.length; i++) {
            System.out.print(sort[i] + " ");
        }
    }
}

运行结果

第二种

public class QuickSort {
    /**
     * 快速排序算法
     * @param array
     * @param start
     * @param end
     * @return
     */
    public static int[] quickSort(int[] array, int start, int end) {
        if (array.length < 1 || start < 0 || end >= array.length || start > end) return null;
        int smallIndex = partition(array, start, end);
        if (smallIndex > start)
            quickSort(array, start, smallIndex - 1);
        if (smallIndex < end)
            quickSort(array, smallIndex + 1, end);
        return array;
    }

    /**
     * 快速排序算法——partition
     * @param array
     * @param start
     * @param end
     * @return
     */
    public static int partition(int[] array, int start, int end) {
        int pivot = (int) (start + Math.random() * (end - start + 1));
        int smallIndex = start - 1;
        swap(array, pivot, end);
        for (int i = start; i <= end; i++)
            if (array[i] <= array[end]) {
                smallIndex++;
                if (i > smallIndex)
                    swap(array, i, smallIndex);
            }
        return smallIndex;
    }

    /**
     * 交换数组内两个元素
     * @param array
     * @param i
     * @param j
     */
    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static void main(String[] args) {
        int[] array = {3, 43, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        int[] sort = quickSort(array, 0, array.length - 1);
        for (int j : sort) {
            System.out.print(j + " ");
        }
    }
}

运行结果