【算法】排序_快速排序

快速排序

定义

基本思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分分别进行快速排序，整个排序过程可以递归进行，以达到整个数据变成有序序列

稳定性

不稳定

时间复杂度

O(N * log^N)

代码

测试用例

int arr[] = {2,4,3,1,6,5};

原代码

    /**
     * 快速排序
     * @param arr
     * @param len
     */
    public static void quickSort(int[] arr, int len){
        System.out.println("初始数据 " + Arrays.toString(arr) + "\n\n");
        quickSort(arr,0,len-1);
    }

    /**
     * 快速排序
     * @param arr
     * @param low
     * @param high
     */
    public static void quickSort(int[] arr,int low,int high) {

        int mid;
        if (low<high){
            mid = partition(arr,low,high); // 进行分割操作并返回基准元素
            quickSort(arr,low,mid -1); // 右区间递归快速排序
            quickSort(arr,mid+1,high); // 左区间递归快速排序
        }
    }

    /**
     * 返回基准
     * @param arr
     * @param low
     * @param high
     * @return
     */
    public static int partition(int[] arr,int low, int high){
        System.out.println("开始下标 "+ low);
        System.out.println("结束下标 "+ high);

        int i = low; // 待处理第一个下标
        int j = high; // 待处理最后一个下标
        // 分界值
        int pivot = arr[low];
        System.out.println("分界值 [" + pivot + "]");
        while (i<j){

            // 从右往左扫描  跳出循环：j==i 或 arr[j] <= arr[pivot]
            while (i<j && arr[j]>pivot){
                j--;
            }

            // arr[i] 和 arr[j] 交换后，i右移一位
            if (i<j){
                swap(arr,i,j);
                System.out.println("右侧遍历 本次交换结果"+ Arrays.toString(arr));
                i++;
            }

            // 从左往右扫描 跳出循环 i==j 或 arr[i]>pivot
            while (i<j && arr[i]<=pivot){
                i++;
            }

            // arr[i] 和 arr[j] 交换后，j左移一位
            if (i<j){
                swap(arr,i,j);
                System.out.println("左侧遍历 本次交换结果" + Arrays.toString(arr));
                j--;
            }
        }
        // 返回最终划分完成后基准匀速所在的位置 i==j
        System.out.println("新基准下标 " + i + "\n");
        return i;
    }

代码解释

第一次对整体进行遍历，以第一个作为基准，分为两部分
具体遍历过程：
j：先从右往左，找到小于等于基准的数之后，跳出循环
交换i j 所指向的元素，i++；此时arr[i]待判断
i：从左往右，找到大于基准的数之后，跳出循环
交换i j 所指向的值，j–；此时arr[j]待判断； arr[i]已判断
结束条件：i==j （本轮遍历结束）

每次遍历的基准都是arr[low]；

运行结果

交换函数

    /**
     * 交换函数
     * @param arr
     * @param i
     * @param j
     */
    public static void swap(int[] arr,int i ,int j){
        int temp = arr[j];
        arr[j] = arr[i];
        arr[i] = temp;
    }

扩展 应用

分类问题

题面
给定⼀个数组arr，和⼀个数num，请把⼩于等于num的数放在数组的左边，⼤于num的数放在数组的
右边。
思路
注：指定num不一定在数组中

指针p从-1位置开始，规划p左侧为⼩于num的数的区域，然后准备⼀个指针q指向下标0位置，如果q
指向元素⼩于等于num，则q指向元素与p+1指向元素交换，p、q往后移动；如果q指向元素⼤于
num，则q往后移动，直到q移出数组。
时间复杂度
O(N)

代码实现

/**
 * @Classname Classify
 * @Description 分类问题
 */
public class Classify {
    public static void main(String[] args) {
        // 测试数据
        int arr[] = {2,1,1,1,4,8,1,6,5};
        partition(arr,3);
    }

    /**
     * 分类
     * @param arr
     * @param pivot 分界值
     * @return
     */
    public static int partition(int[] arr,int pivot){

        System.out.println("分界值 [" + pivot + "]");
        System.out.println("初始数据 " + Arrays.toString(arr)+"\n");

        int i = -1; // 用于记录比pivot小的值的下标 -1表示不存在
        int j = 0; // 用于遍历
        for (;j<arr.length;j++){
            // 只要比pivot小就和arr[i]交换
            if (j<arr.length && arr[j]<=pivot){
                swap(arr,i+1,j);
                i++;
                System.out.println("第"+(i+1)+"次交换结果 " +Arrays.toString(arr));
            }
        }
        System.out.println("最终结果 " + Arrays.toString(arr)+"\n");





        // 以下代码用于打印结果
        System.out.println("前"+(i+1)+"个为小于等于"+pivot+"的元素");
        System.out.println(pivot+"之前:");
        System.out.print("[ ");
        for (int n =0;n<=i;n++){
            System.out.print(arr[n] + " ");
        }
        System.out.print("]");

        System.out.println("\n"+pivot+"之后:");
        System.out.print("[ ");
        for (int n =i+1;n<arr.length;n++){
            System.out.print(arr[n] + " ");
        }
        System.out.println("]");
        return i;
    }

    /**
     * 交换函数
     * @param arr
     * @param i
     * @param j
     */
    public static void swap(int[] arr,int i ,int j){
        int temp = arr[j];
        arr[j] = arr[i];
        arr[i] = temp;
    }

}

运行结果

荷兰国旗问题

题面
给定⼀个数组arr，和⼀个数num，请把⼩于num的数放在数组的左边，等于num的数放在数组的中
间，⼤于num的数放在数组的右边。
时间复杂度
O(N)
代码实现

/**
 * @Classname HollandFlag
 * @Description 荷兰国旗
 */
public class HollandFlag {
    public static void main(String[] args) {
        // 测试数据
        int arr[] = {-1,-2,-3,2,1,1,1,4,8,1,6,5};
        partition(arr,arr.length,1);
    }

    /**
     *
     * @param arr
     * @param len
     * @param pivot
     * @return
     */
    public static int partition(int[] arr,int len,int pivot){
        System.out.println("分界值 [" + pivot + "]");
        System.out.println("初始数据 " + Arrays.toString(arr)+"\n");

        int less = -1; // 记录比pivot小的值的下标 -1 表示没有
        int more = len; // 记录比pivot大的值的下标 arr.length表示没有

        System.out.println("分界值 [" + pivot + "]");
        int i=0;
        while (i<len&&less<more){
            if (arr[i]<pivot){
                swap(arr,i++,++less);
                System.out.println("小于"+Arrays.toString(arr));
            }else if (arr[i]>pivot&&i<more){// 因为是从左向右遍历 
            								// 所以交换过来的数据（arr[i],原arr[--more]）并没有被判断，所以这里i不加一  
            								// 且要保证more和i的大小关系
                swap(arr,i,--more);
                System.out.println("大于"+Arrays.toString(arr));
            }else {
                i++;
            }
        }
        System.out.println("最终结果 " + Arrays.toString(arr)+"\n");
        
        
        
        
        
        
        // 以下代码用于打印结果
        System.out.println("小于"+pivot);
        System.out.print("[ ");
        for (int n =0;n<=less;n++){
            System.out.print(arr[n] + " ");
        }
        System.out.print("]");

        System.out.println("\n等于"+pivot);
        System.out.print("[ ");
        for (int n =less+1;n<more;n++){
            System.out.print(arr[n] + " ");
        }
        System.out.print("]");

        System.out.println("\n大于"+pivot);
        System.out.print("[ ");
        for (int n =more;n<len;n++){
            System.out.print(arr[n] + " ");
        }
        System.out.print("]");
        return i;
    }



    /**
     * 交换函数
     * @param arr
     * @param i
     * @param j
     */
    public static void swap(int[] arr,int i ,int j){
        int temp = arr[j];
        arr[j] = arr[i];
        arr[i] = temp;
    }
}

运行结果