10种排序算法一：选择排序 - 不稳定-优快云博客

本文介绍了选择排序算法，包括其基本思想、时间复杂度和空间复杂度。提供了两种实现方式，一种是标准的选择排序，另一种是同时选取最大值与最小值的优化版，其时间复杂度为n*log(n)。代码示例展示了如何用Java实现这两种选择排序方法，并通过位运算优化了交换元素的过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

选择排序

/**
 * 排序算法 一：选择排序
 * 【思想】找到数组中最小的值，与组数最前或最后一值做交换
 * 时间复杂度：n^2
 * 空间复杂度：n
 * 【扩展】找到数组中最大和最小值，最小值与最前值做交换，最大与最后值做交换。
 * 时间复杂度: n*logn
 * 空间复杂度：n
 */
public class SelectionSort {

    public static void main(String[] args) {
        int[] arr = {55, 1, 77, 6, 322, 55, 64, 8};
        sort2(arr);
        System.out.println(Arrays.toString(arr));
    }

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

    /**
     * 通过位运算进行交换
     * <p>
     * 注意使用位运算时，应避免i和j相等，不然最后异或结果都为0，达不到交换的目的
     *
     * @param arr
     * @param i
     * @param j
     */
    public static void swapByMove(int arr[], int i, int j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

    /**
     * 选择排序：取最小值，从小到大排序
     * 时间复杂度：n * n
     */
    public static void sort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int minPosition = i;
            for (int j = i + 1; j < arr.length; j++) {
                minPosition = arr[minPosition] > arr[j] ? j : minPosition;
            }
            swap(arr, i, minPosition);
        }
    }

    /**
     * 选择排序，同时选最大值与最小值，从小到大排序。
     * 时间复杂度：n * log(n)
     *
     * @param arr
     */
    public static void sort2(int[] arr) {
        for (int i = 0; i < arr.length / 2 + 1; i++) {
            int minPosition = i;
            int maxPosition = i;
            for (int j = i + 1; j < arr.length - i; j++) {
                minPosition = arr[minPosition] > arr[j] ? j : minPosition;
                maxPosition = arr[maxPosition] < arr[j] ? j : maxPosition;
            }
            if (minPosition == maxPosition) //最小值和最大值下标相等，说明是最后一个数了，不用排了
                return;
            swap(arr, i, minPosition);

            if (i == maxPosition)   //当最小值要存放的位置刚好是最大值位置时，i与min交换后，最大值的位置在min位置
                maxPosition = minPosition;
            if (arr[arr.length - 1 - i] < arr[maxPosition])
                swap(arr, arr.length - 1 - i, maxPosition);
        }
    }
}