选择排序：深入剖析与实践_java 选择排序原理通俗理解-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_45969711/article/details/145837856

选择排序：深入剖析与实践

在 Java 编程的世界里，排序算法是处理数据的重要工具。今天，让我们一同深入探索选择排序这一经典算法，了解它的工作原理、实现方式、性能表现以及优化策略。

一、选择排序的基本概念

选择排序是一种简单直观的排序算法。它的核心思想是将数组分为已排序和未排序两部分，每一轮从未排序部分中选择最小（或最大）的元素，将其与未排序部分的第一个元素交换位置，逐步扩大已排序部分，直至整个数组有序。

二、选择排序的原理

初始状态：将数组的第一个元素视为已排序部分，其余元素为未排序部分。

选择最小元素：在未排序部分中遍历，找出最小的元素。

交换位置：将找到的最小元素与未排序部分的第一个元素交换位置，此时已排序部分增加一个元素，未排序部分减少一个元素。

重复步骤：不断重复上述选择和交换的过程，直到未排序部分为空，整个数组完成排序。

三、Java 代码实现

public class SelectionSort {

    public static void main(String[] args) {

        int[] array = {
            64,
            34,
            25,
            12,
            22,
            11,
            90
        };

        selectionSort(array);

        for (int num: array) {

            System.out.print(num + " ");

        }

    }

    public static void selectionSort(int[] arr) {

        int n = arr.length;

        for (int i = 0; i < n - 1; i++) {

            int minIndex = i;

            for (int j = i + 1; j < n; j++) {

                if (arr[j] < arr[minIndex]) {

                    minIndex = j;

                }

            }

            if (minIndex != i) {

                int temp = arr[i];

                arr[i] = arr[minIndex];

                arr[minIndex] = temp;

            }

        }

    }

}

在这段代码中，外层循环控制已排序部分的边界，每一轮确定一个最小元素并将其放置到正确位置。内层循环用于在未排序部分中寻找最小元素的索引，最后进行交换操作。

四、性能分析

时间复杂度：无论数组的初始状态如何，选择排序都需要进行 n (n - 1)/2 次比较，其中 n 是数组的长度，所以它的时间复杂度始终为 O (n²)。这意味着在处理大规模数据时，选择排序的效率较低。

空间复杂度：选择排序在排序过程中只需要几个临时变量来辅助交换操作，所以空间复杂度为 O (1)，是一种原地排序算法。

五、优化策略

减少不必要的交换：在传统选择排序中，即使当前位置的元素已经是最小的，仍然会进行一次不必要的交换（自己和自己交换）。可以通过增加一个判断条件来避免这种情况。

public static void optimizedSelectionSort(int[] arr) {

    int n = arr.length;

    for (int i = 0; i < n - 1; i++) {

        int minIndex = i;

        for (int j = i + 1; j < n; j++) {

            if (arr[j] < arr[minIndex]) {

                minIndex = j;

            }

        }

        // 只有当最小元素不是当前元素时才进行交换

        if (minIndex != i) {

            int temp = arr[minIndex];

            arr[minIndex] = arr[i];

            arr[i] = temp;

        }

    }

}

利用堆结构优化：可以将选择排序和堆排序的思想结合起来。首先构建一个最小堆，然后每次从堆顶取出最小元素，将其与未排序部分的第一个元素交换，再对堆进行调整。这样可以将选择最小元素的时间复杂度从 O (n) 降低到 O (log n)，从而整体时间复杂度降为 O (n log n)。不过这种方式实现相对复杂，且会增加额外的空间开销。

// 构建最小堆

public static void buildMinHeap(int[] arr) {

    int n = arr.length;

    for (int i = n / 2 - 1; i >= 0; i--) {

        heapify(arr, n, i);

    }

}

// 堆调整

public static void heapify(int[] arr, int n, int i) {

    int smallest = i;

    int left = 2 * i + 1;

    int right = 2 * i + 2;

    if (left < n && arr[left] < arr[smallest]) {

        smallest = left;

    }

    if (right < n && arr[right] < arr[smallest]) {

        smallest = right;

    }

    if (smallest != i) {

        int temp = arr[i];

        arr[i] = arr[smallest];

        arr[smallest] = temp;

        heapify(arr, n, smallest);

    }

}

// 利用堆优化的选择排序

public static void heapOptimizedSelectionSort(int[] arr) {

    buildMinHeap(arr);

    int n = arr.length;

    for (int i = n - 1; i > 0; i--) {

        int temp = arr[0];

        arr[0] = arr[i];

        arr[i] = temp;

        heapify(arr, i, 0);

    }

}