java版 排序算法

/**
     * 交换 整形数组 中的元素
     *
     * @param nums
     * @param i
     * @param j
     */
    private static void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

冒泡排序

 /**
     * 冒泡排序
     *
     * @param nums
     */
    public static void bubbleSort(int[] nums) {
        int len = nums.length;
        boolean flag = true; // 判断是否已经有序
        // 需要将len-1个大的数排到右边，所以需要len-1次循环
        for (int i = 0; i < len - 1; i++) {
            // 每轮需要将剩余数据中的 最大的数排到最右边
            for (int j = 0; j < len - 1 - i; j++) {
                if (nums[j] > nums[j + 1]) {
                    swap(nums, j, j + 1);
                    flag = false;
                }
            }
            if (flag) break;
        }
    }

选择排序

/**
     * 选择排序
     *
     * @param nums
     */
    public static void selectSort(int[] nums) {
        int len = nums.length;
        // 找到最大数所在的索引，交换最大数到最右边的位置
        for (int i = len - 1; i > 0; i--) { // 通过 i 记录最后一个数的索引
            int maxValueIndex = 0;
            for (int j = 1; j <= i; j++) {
                if (nums[maxValueIndex] < nums[j]) {
                    maxValueIndex = j;
                }
            }
            if (maxValueIndex != i) {
                swap(nums, maxValueIndex, i);
            }
        }
    }

插入排序

/**
     * 插入排序
     *
     * @param nums
     */
    public static void insertionSort(int[] nums) {
        int len = nums.length;
        for (int i = 1; i < len; i++) {
            int insertValue = nums[i]; // 待插入的数
            int j = i - 1;
            while (j >= 0 && nums[j] > insertValue) {
                nums[j + 1] = nums[j];
                j--;
            }
            nums[j + 1] = insertValue;
        }
    }

希尔排序

/**
     * 希尔排序
     *
     * @param nums
     */
    public static void shellSort(int[] nums) {
        int len = nums.length;
        int gap = len / 2;
        while (gap > 0) {
            for (int i = gap; i < len; i++) {
                int insertValue = nums[i];
                int j = i - gap;
                while (j >= 0 && nums[j] > insertValue) { // 对相同步长的数进行插入排序
                    nums[j + gap] = nums[j];
                    j -= gap;
                }
                nums[j + gap] = insertValue;
            }
            gap /= 2;
        }
    }

计数排序

/**
     * 计数排序
     *
     * @param nums
     */
    public static void countingSort(int[] nums) {
        // 找出最小值
        // 找出最大值
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        for (int i : nums) {
            if (i < min) min = i;
            if (i > max) max = i;
        }
        // 确定数组长度
        int[] record = new int[max - min + 1];
        // 偏移量
        int offset = -min;
        // 计数
        for (int i : nums) {
            record[i + offset]++;
        }
        for (int i = 0, j = 0; i < record.length; i++) {
            while (record[i] > 0) {
                nums[j++] = i - offset;
                record[i]--;
            }
        }
    }

归并排序

/**
     * 1. 归并排序
     * @param nums
     */
    public static void mergeSort(int[] nums) {
        int[] temp = new int[nums.length];
        split(nums, 0, nums.length - 1, temp);
    }

    /**
     * 2. 归并排序
     * @param nums
     * @param left
     * @param right
     * @param temp
     */
    private static void split(int[] nums, int left, int right, int[] temp) {
        if (left == right) return;
        int mid = (left + right) >>> 1;
        split(nums, left, mid, temp);
        split(nums, mid + 1, right, temp);
        merge(nums, left, mid, mid + 1, right, temp);
        System.arraycopy(temp, left, nums, left, right - left + 1);
    }

    /**
     * 3. 归并排序
     * @param nums
     * @param i
     * @param iEnd
     * @param j
     * @param jEnd
     * @param temp
     */
    private static void merge(int[] nums, int i, int iEnd, int j, int jEnd, int[] temp) {
        int k = i;
        while (i <= iEnd && j <= jEnd) {
            temp[k++] = nums[i] < nums[j] ? nums[i++] : nums[j++];
        }
        while (i <= iEnd) temp[k++] = nums[i++];
        while (j <= jEnd) temp[k++] = nums[j++];
    }

快速排序（优化）

/**
     * 1. 快速排序
     *
     * @param nums
     */
    public static void quickSort(int[] nums) {
        int len = nums.length;
        partition(nums, 0, len - 1);
    }

    /**
     * 2. 快速排序
     *
     * @param nums
     * @param start
     * @param end
     */
    private static void partition(int[] nums, int start, int end) {
        if (start >= end) return;
        int randomIndex = (int) (Math.random() * (end - start + 1)) + start; // 选取随机值
        swap(nums, start, randomIndex);
        int baseValue = nums[start];
        int left = start;
        int right = end;
        while (left < right) {
            while (left < right && nums[right] >= baseValue) right--;
            while (left < right && nums[left] <= baseValue) left++;
            if (left < right) {
                swap(nums, left, right);
            }
        }
        if (left != start) {
            swap(nums, left, start);
        }
        while (left > start && nums[left] == nums[left - 1]) {  // 过滤相邻的重复数字
            left--;
        }
        while (right < end && nums[right] == nums[right + 1]) {
            right++;
        }
        partition(nums, start, left - 1);
        partition(nums, right + 1, end);
    }