Java选择排序：逐步可视化算法执行过程-java教程-PHP中文网

Java选择排序：逐步可视化算法执行过程

碧海醫心

发布： 2025-08-26 21:46:13

原创

238人浏览过

Java选择排序：逐步可视化算法执行过程

本教程详细讲解如何在Java中实现选择排序算法，并重点介绍如何修改代码以在每一步迭代完成后输出数组的当前状态。通过在排序主循环中添加打印语句，开发者可以清晰地追踪算法的执行过程，从而更好地理解其工作原理和每一步的变化。

1. 引言：理解选择排序与可视化需求

选择排序（selection sort）是一种简单直观的排序算法。其基本思想是：在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。重复这个过程，直到所有元素均排序完毕。

对于初学者或在调试时，仅仅看到排序前和排序后的数组状态往往不够。我们可能需要了解算法在每一步迭代中对数组做了哪些修改，这有助于我们更深入地理解算法的执行逻辑和每一步的决策。本文将基于一个现有的Java选择排序实现，演示如何添加代码以可视化每一步迭代的中间状态。

2. 选择排序算法基础

选择排序的核心在于两步：寻找最小元素和交换。

寻找最小元素： 从当前未排序部分的起始位置开始，遍历到数组末尾，找到其中最小元素的索引。
交换： 将找到的最小元素与当前未排序部分的第一个元素进行交换。

这个过程会重复 n-1 次（n 为数组长度），因为当 n-1 个元素都归位后，最后一个元素自然也就在正确的位置上。

以下是实现选择排序所需的辅助方法：

立即学习“Java免费学习笔记（深入）”；

public class SelectionSortVisualizer {

    /**
     * 将整数数组转换为易于阅读的字符串格式。
     * 例如：[1|5|2|8]
     * @param a 待转换的整数数组
     * @return 数组的字符串表示
     */
    private static String arrayToString(int[] a) {
        String str = "[";
        if (a.length > 0) {
            str += a[0];
            for (int i = 1; i < a.length; i++) {
                str += "|" + a[i];
            }
        }
        return str + "]";
    }

    /**
     * 从指定起始位置到数组末尾，返回最小元素的索引。
     * @param from 搜索的起始索引
     * @param a 待搜索的数组
     * @return 最小元素的索引
     */
    private static int smallestPosFrom(int from, int[] a) {
        int pos = from;
        for (int i = from + 1; i < a.length; i++) {
            if (a[i] < a[pos]) {
                pos = i;
            }
        }
        return pos;
    }

    /**
     * 交换数组中两个指定位置的元素。
     * @param a 待操作的数组
     * @param pos1 第一个元素的索引
     * @param pos2 第二个元素的索引
     */
    private static void swap(int[] a, int pos1, int pos2) {
        int temp = a[pos1];
        a[pos1] = a[pos2];
        a[pos2] = temp;
    }

    // 原始的sort方法，不包含迭代输出
    public static void sort(int[] a) {
        for (int i = 0; i < a.length - 1; i++) {
            int pos = smallestPosFrom(i, a);
            swap(a, i, pos);
        }
    }

    public static void main(String[] args) {
        int[] myArray = {64, 25, 12, 22, 11};
        System.out.println("原始数组为: " + arrayToString(myArray));
        sort(myArray); // 调用原始排序方法
        System.out.println("排序后数组为: " + arrayToString(myArray));
    }
}

登录后复制

在上述 main 方法中，我们只能看到原始数组和最终排序后的数组。要观察中间过程，我们需要对 sort 方法进行修改。

3. 实现迭代过程可视化

为了在每一步迭代完成后显示数组的当前状态，我们只需在 sort 方法的主循环内部，每次元素交换操作完成后，添加一个打印数组的语句。

修改后的 sort 方法如下：

可赞AI

文字一秒可视化，免费AI办公神器

查看详情

public class SelectionSortVisualizer {
    // ... (arrayToString, smallestPosFrom, swap 方法保持不变) ...

    /**
     * 对数组进行选择排序，并在每次迭代后打印数组的当前状态。
     * @param a 待排序的整数数组
     */
    public static void sortWithIterationOutput(int[] a) {
        for (int i = 0; i < a.length - 1; i++) {
            // 找到当前未排序部分的最小元素索引
            int pos = smallestPosFrom(i, a);
            // 将最小元素与当前未排序部分的第一个元素交换
            swap(a, i, pos);

            // 在每次交换完成后，打印数组的当前状态
            String arrayAfterIteration = arrayToString(a);
            System.out.println("第 " + (i + 1) + " 轮排序后数组: " + arrayAfterIteration);
        }
    }

    public static void main(String[] args) {
        int[] myArray = {64, 25, 12, 22, 11};
        System.out.println("原始数组为: " + arrayToString(myArray));

        // 调用带有迭代输出的排序方法
        sortWithIterationOutput(myArray); 

        System.out.println("最终排序后数组为: " + arrayToString(myArray));
    }
}

登录后复制

修改逻辑解释：

我们将 sort 方法更名为 sortWithIterationOutput 以区分。
在 for (int i = 0; i < a.length - 1; i++) 循环内部，每次 swap(a, i, pos); 操作完成后，数组的 i 位置上的元素就已经确定是当前未排序部分的最小值了。
此时，调用 arrayToString(a) 将当前数组状态转换为字符串。
使用 System.out.println 打印出当前迭代的轮次（i+1）和数组的字符串表示。

4. 完整代码示例

将所有组件整合在一起，形成一个完整的、可运行的Java类：

public class SelectionSortVisualizer {

    /**
     * 将整数数组转换为易于阅读的字符串格式。
     * 例如：[1|5|2|8]
     * @param a 待转换的整数数组
     * @return 数组的字符串表示
     */
    private static String arrayToString(int[] a) {
        String str = "[";
        if (a.length > 0) {
            str += a[0];
            for (int i = 1; i < a.length; i++) {
                str += "|" + a[i];
            }
        }
        return str + "]";
    }

    /**
     * 从指定起始位置到数组末尾，返回最小元素的索引。
     * @param from 搜索的起始索引
     * @param a 待搜索的数组
     * @return 最小元素的索引
     */
    private static int smallestPosFrom(int from, int[] a) {
        int pos = from;
        for (int i = from + 1; i < a.length; i++) {
            if (a[i] < a[pos]) {
                pos = i;
            }
        }
        return pos;
    }

    /**
     * 交换数组中两个指定位置的元素。
     * @param a 待操作的数组
     * @param pos1 第一个元素的索引
     * @param pos2 第二个元素的索引
     */
    private static void swap(int[] a, int pos1, int pos2) {
        int temp = a[pos1];
        a[pos1] = a[pos2];
        a[pos2] = temp;
    }

    /**
     * 对数组进行选择排序，并在每次迭代后打印数组的当前状态。
     * @param a 待排序的整数数组
     */
    public static void sortWithIterationOutput(int[] a) {
        for (int i = 0; i < a.length - 1; i++) {
            int pos = smallestPosFrom(i, a);
            swap(a, i, pos);
            String arrayAfterIteration = arrayToString(a);
            System.out.println("第 " + (i + 1) + " 轮排序后数组: " + arrayAfterIteration);
        }
    }

    public static void main(String[] args) {
        int[] myArray = {64, 25, 12, 22, 11};
        System.out.println("原始数组为: " + arrayToString(myArray));

        sortWithIterationOutput(myArray); 

        System.out.println("最终排序后数组为: " + arrayToString(myArray));
    }
}

登录后复制

5. 运行效果与输出分析

运行上述 main 方法，你将看到如下输出：

原始数组为: [64|25|12|22|11]
第 1 轮排序后数组: [11|25|12|22|64]
第 2 轮排序后数组: [11|12|25|22|64]
第 3 轮排序后数组: [11|12|22|25|64]
第 4 轮排序后数组: [11|12|22|25|64]
最终排序后数组为: [11|12|22|25|64]

登录后复制

输出分析：

原始数组： 显示了排序开始前的初始状态。
第 1 轮排序后： 最小元素 11 被找到并与 64 交换，放置在数组的第一个位置。
第 2 轮排序后： 在剩余未排序部分 [25|12|22|64] 中，最小元素 12 被找到并与 25 交换，放置在数组的第二个位置。
第 3 轮排序后： 在剩余未排序部分 [25|22|64] 中，最小元素 22 被找到并与 25 交换，放置在数组的第三个位置。
第 4 轮排序后： 在剩余未排序部分 [25|64] 中，最小元素 25 被找到并与 25 交换（此处没有实际改变，但逻辑上发生了交换），放置在数组的第四个位置。
最终排序后： 显示了整个排序过程完成后的数组状态。

通过这种方式，我们清晰地看到了选择排序算法是如何一步步将元素归位，最终完成排序的。

6. 注意事项

性能考量： 在每次迭代中进行打印操作会增加程序的执行时间。对于小型数组，这种开销可以忽略不计，但对于包含成千上万甚至更多元素的大型数组，频繁的I/O操作会显著降低排序效率。因此，这种可视化方法主要用于学习、调试和演示，不适用于对性能有严格要求的生产环境。
适用场景： 这种技术不仅适用于选择排序，也可以应用于其他排序算法（如冒泡排序、插入排序等），只需在相应的迭代循环内部添加打印语句即可。
灵活控制： 如果需要更精细的控制，例如只在特定条件下打印，或者将中间状态记录到日志文件而非直接输出到控制台，可以进一步封装打印逻辑。