[Java]排序算法>交换排序>【快速排序】(O(N*logN)/不稳定/N较大/无序/仅顺序存储)

1 快速排序

1.1 算法思想

快速排序是由冒泡排序改进而得的。
在冒泡排序过程中，只对相邻的2个记录进行比较；因此，每次交换2个相邻记录时，只能消除1个逆序。
若能通过2个（不相邻）记录的1次交换，消除多个逆序，则：会大大加快排序的速度。
而快速排序方法中的1次交换，则：可能消除多个逆序。

1.2 算法特征

• 属于【交换排序】的1种
  • 冒泡排序
  • 快速排序
    • 每次交换2个(不相邻)记录时，可消除多个记录
    • 平均情况下，内部排序中最快的1种
• 适用于【稳定性】：不稳定
• 适用于【规模N】：较大
• 适用于【有序性】：无序
• 适用于【存储结构】：顺序存储结构（链式存储结构难以实现）
• 【时间复杂度】：O(nlogn)(最好) / O(nlogn)(平均) / O(n*n)(最坏)
• 【空间复杂度】：O(logn) (最好) / ------------- / O(n) (最坏)
• 相关口诀：
  • 【(选)希堆快】不稳定，【二希堆快】顺序存，【归堆快】时NlogN

1.3 算法实现

import java.util.*;
public class QuickSort {
    private static void quickSortOfJDK(int[] array, int left, int right) {//JDK的快速排序
        for (int i = left, j = i; i < right; ) {
            int tmp = array[i + 1];
            while (array[j] < tmp) {//不符合升序
                array[j + 1] = array[j];
                if (j-- == left) {
                    break;
                }
            }
            array[j + 1] = tmp;
            i = i + 1;
            j = i;
        }
    }

    private static int partition(int[] array, int low, int high) {
        int pivotValue = array[low]; //将第1(low)个元素所处位置空置起来，方便交换；且以第1个元素作为 分割标准值
        while (low < high) {
            while (low < high && pivotValue < array[high]) {
                high--;
            }//右边满足升序时
            array[low] = array[high]; //将此时不满足上述条件的high处值 移至 事先空置的 low 处存储 （则 high处空置)
            while (low < high && pivotValue > array[low]) {
                low++;
            }//左边满足升序时
            array[high] = array[low];//将此时不满足上述条件的low处值 移至 事先空置的 high 处存储
        }
        //不满足 low < high时： 即 此时 pivot的两边已排序完毕
        array[low] = pivotValue;
        return low;
    }

    private static void sort(int[] array, int left, int right) {
        if (left < right) {
            int pivot = partition(array, left, right); //分界符
            sort(array, left, pivot - 1);
            sort(array, pivot + 1, right);
        }
    }

    public static int[] quickSort(int[] array) {
        int left = 0, right = array.length - 1;
        int[] resultArray = Arrays.copyOfRange(array, 0, array.length);

        sort(resultArray, left, right);
        return resultArray;
    }
}

1.4 测试实现

import java.util.Scanner;

public class Main {
    public static void print(int[] array){
        if(array==null || array.length<1){
            return;
        }
        for(int i=0;i<array.length-1;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println(array[array.length-1]);
    }

    public static void main(String[] args) {
        //1 输入 一组 乱序的数值 数组
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        String [] strValues = input.trim().split(" ");
        int [] array = new int[strValues.length];
        for(int i=0,len=strValues.length;i<len;i++){
            array[i] = Integer.valueOf(strValues[i]).intValue();//假定所有输入均为合规的整型数值
        }
//        print(array);// test - 输出 所输入的数据

        //2 排序
        int [] sortedArray = QuickSort.quickSort(array);//快速排序
        //3 输出
        print(sortedArray);
    }
}

//console - input↓
3 6 5 8 9 4 2 7
//console - output↓
2 3 4 5 6 7 8 9

1.5 参考文献

• 《数据结构（C语言-第2版-严蔚敏 吴伟民 著）》：Page242