快速排序(剑指offer )

原创

编程牧马人 2022-06-19 00:25:28 ©著作权

文章标签 排序算法算法 java 快速排序插入排序 文章分类 数据结构与算法人工智能

©著作权归作者所有：来自51CTO博客作者编程牧马人的原创作品，请联系作者获取转载授权，否则将追究法律责任

import java.util.Random;

/**
 * 
 * @Version ：
 * @Description : 快速排序
 */
public class QuickSort {

    public static void main(String[] args) {
        int[] arr = {1, 8, 3, 9, 4, 5, 7, 6};
        quickSort(arr, 8, 0, 7);
        for (int i = 0; i < 8; i++) {
            System.out.println(arr[i]);
        }

//        int i = (int) (0.7 * 8);
//        System.out.println(i);

    }

    public static void quickSort(int[] arr, int length, int start, int end) {
        if (start == end) {
            return ;
        }
        int index = partition(arr, length, start, end);
        if (index > start) {
            quickSort(arr, length, start, index - 1);
        }

        if (index < end) {
            quickSort(arr, length, index + 1, end);
        }
    }
    // 分割
    public static int partition(int[] arr, int length, int start, int end) {
        if (arr == null || length == 0) {
            return 0;
        }
        // 随机取值 pivot
        int index = randomInt(start, end);
        // 交换到最后一个节点上
        swap(arr, index, end);
        // 双指针 small index
        int small = start - 1;
        for (index = start; index < end; index++) {
            /**
             *  small 是左指针，寻在大于 arr[end]的数， index 是右指针，寻找小于arr[end] 的数
             *  arr[index] > arr[end] index++
             *  arr[index] < arr[end] small++
             *  1、如果 arr[index] < arr[end] 一直小于， 则small 一直++到最后， 此时数组是正序，例如 [1,2,3,4，5,6,7] -> [1,2,3,7,5,6,4] 此时 small 随 index 变化
             *  2、如果 arr[index] > arr[end] ,此时 small 停留在上一个阶段的最后一个小于 <arr[end] 值身上，例如 [1,2,3,5,6,8,4,7,9] -> [1,2,3,9,6,8,4,7,5]
             *       此时 arr[end] = 5
             *       [1,   2,   3,   9,   6,    8,    4,    7,   5]
             *      index
             *      small
             *           index
             *           small
             *                index
             *                small
             *                     index index index index(找小于arr[end] 的值)
             *                     small (此时交换)
             *
             *       [1,   2,   3,   4,   6,    8,    9,    7,   5]
             *
             */
            if (arr[index] < arr[end]) {
                small++;
                if (small != index) {
                    swap(arr, index, small);
                }

            }
        }
        small++;
        swap(arr, small, end);
        return small;
    }
    public static int randomInt(int min, int max) {
//        return (int) (min + Math.random() * max);
        return (int) (min + Math.random()*(max - min +1));
    }
    // 中轴元素选取
    public static int randomIntrange(int[] arr, int start, int end) {
        int mid = start + (end - start) >> 1;
        int y1 = arr[start] > arr[mid] ? start : mid;
        int y2 = arr[start] > arr[end] ? start : end;
        int y3 = arr[mid] > arr[end] ? mid : end;
        if (y1 == y2) {
            return y3;
        }else {
            return y1 > y2 ? y2 : y1;
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}