选择排序 java实现-从头到尾，逐一选美，找最小的，交换位置

算法就是真言

已于 2024-08-15 09:07:52 修改

阅读量689

点赞数 6

分类专栏：算法学习文章标签： java 算法开发语言

于 2024-08-14 17:34:05 首次发布

本文链接：https://blog.csdn.net/m0_50272029/article/details/141196403

版权

算法学习专栏收录该内容

2 篇文章 0 订阅

订阅专栏

选择排序是一种非常直观的排序算法。为了让它更通俗易懂，我们可以把它比作一个校园选美比赛，选美比赛中，大家都排成一排，然后评委逐个挑选出最漂亮的选手，把她们按顺序排好。

故事背景：校园选美比赛

在一所学校里，举办了一场选美比赛。共有10位选手参加，她们站成一排，等着评委来为她们打分，并按照美丽程度排好顺序。

评委的任务是找到站在最前面的选手和剩下所有选手中最漂亮的那一位，接着把她们交换位置。然后评委再向后移动一位，重复这个过程，直到所有选手都排好了。

选择排序的过程（选美比赛）

假设选手们的美丽程度用整数表示，数值越小表示越漂亮。选手们按顺序站好后，评委要做以下的工作：

第一轮比赛：评委从所有选手中挑选最漂亮的一位，把她放到第一个位置。
- 比如，评委看着前面的选手，觉得第三位选手最漂亮，于是把她和第一位选手交换位置。
第二轮比赛：评委忽略已经排好的第一位选手，从剩下的选手中挑选最漂亮的一位，把她放到第二个位置。
- 这次评委觉得第七位选手最漂亮，于是把她和第二位选手交换位置。
重复这个过程：评委依次挑选剩下选手中最漂亮的一位，并将她放在正确的位置，直到所有选手都按照美丽程度排好了。

选择排序的 Java 实现

我们可以用Java代码来模拟这个选美比赛，代码如下：

import java.util.Arrays;

public class BeautyContest {

    public static void main(String[] args) {
        // 模拟选手的美丽值，数字越小越漂亮
        int[] beauty = { 6, 9, 2, 4, 8, 5, 3, 7, 1, 10 };

        System.out.println("比赛前选手的美丽值: " + Arrays.toString(beauty));

        // 执行选择排序
        selectionSort(beauty);

        System.out.println("比赛后选手的美丽值: " + Arrays.toString(beauty));
    }

    // 选择排序算法
    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[minIndex];
                arr[minIndex] = arr[i];
                arr[i] = temp;
            }

            // 输出每一轮比赛后的结果
            System.out.println("第 " + (i + 1) + " 轮比赛后: " + Arrays.toString(arr));
        }
    }
}

代码解释

初始化选手美丽值：我们用一个整数数组 beauty 表示10位选手的美丽值，其中数字越小的选手越漂亮。
选择排序算法：selectionSort 方法负责“选美”过程。外层循环表示每一轮比赛，每一轮都挑选出当前最漂亮的一位选手，将她放在正确的位置。内层循环用于寻找当前轮次中最漂亮的选手。
输出比赛过程：在每一轮比赛结束后，打印出当前选手的排列顺序，这样我们可以看到整个排序的过程，就像在观看选美比赛一样。

故事总结

通过这个校园选美比赛的比喻，我们可以看到选择排序的本质——每一轮比赛中都挑选最漂亮的选手，把她放到正确的位置。虽然选择排序的效率不算最高，但它的逻辑简单明了，特别适合理解和入门。就像比赛中的选手一样，稳扎稳打，最终可以得到一个正确的排序结果。

要理解并想到这一步，需要掌握几个核心的编程思维模型和概念。以下是一些关键的思维过程，帮助你理解如何构建这一段代码：

1. 分而治之的思维

选择排序本质上是通过分而治之的策略来排序数组。程序员会把问题分解成一个个小步骤：在未排序部分中找到最小值，然后将其放到合适的位置。这个思维模型可以帮助你一步一步解决复杂问题。

如何应用：先把问题分解。比如，在这个排序问题中，先把数组分成已经排序的部分和未排序的部分，然后逐步处理未排序的部分。

2. 迭代与循环的思维

在解决排序问题时，程序员需要考虑如何逐步处理数组中的每一个元素。迭代思维让你考虑每次处理一个元素，并重复这一过程，直到满足条件。

如何应用：使用循环结构来迭代数组的每一个元素。外层循环决定当前要处理的元素，内层循环则用于寻找剩下部分中的最小元素。

3. 最优选择的思维

选择排序的核心思想是每次都做出“最优选择”，即找到当前未排序部分中最小的元素，并将其放到当前应放的位置。这种思维要求你时刻关注当前局部的最优解，并确保局部最优能累积为全局最优。

如何应用：在 for 循环中，通过比较 arr[j] 和 arr[minIndex]，不断更新最优选择，即找到当前最小的元素。

4. 状态更新的思维

程序的状态是随着执行而改变的。在每一步操作中，你需要更新某些变量的状态来反映当前程序的进展。这种思维让你意识到，每次选择之后，状态（如 minIndex 的值）都会改变。

如何应用：在代码中，当找到一个更小的值时，立即更新 minIndex，这样 minIndex 始终指向当前未排序部分的最小元素。

5. 从具体到抽象的思维

编程问题常常从具体的操作开始，逐渐抽象出通用的算法。比如，在选择排序中，最初你可能手动寻找最小值并交换位置，最终抽象出一个通用的算法。

如何应用：一开始可以手动跟踪数组中每个元素的位置，然后逐渐把这个过程抽象为代码，通过变量和循环自动化这一过程。

6. 条件判断与分支的思维

条件判断是编程的基础之一。程序员需要通过条件判断来决定是否更新当前的最优解。在这里，当发现一个新的元素比当前的 minIndex 位置元素更小时，更新 minIndex。

如何应用：使用 if 语句进行比较判断，确保只在找到更优解时才更新 minIndex。

总结

通过以上这些思维模型，你可以逐步理解如何构建选择排序算法的核心步骤。尤其是“最优选择”的思维模型，它帮助你意识到在每一轮循环中找到最优解（即最小的元素）是关键。当你掌握了这些思维模型，你就能够轻松推导出 int minIndex = i; 这一行代码的逻辑，并理解内层循环的意义。

        // 内层循环：在剩下的选手中挑选出最漂亮的一位
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;  // 更新最漂亮选手的位置
            }
        } 怎么能快速记住这段代码

要快速记住这段代码，可以从理解其核心逻辑、分解步骤以及使用一些记忆技巧入手。以下是具体方法：

1. 理解核心逻辑

遍历剩余元素：这段代码的核心是通过一个循环遍历数组中尚未排序的部分，寻找其中最小的元素，并更新其索引（minIndex）。
条件判断与更新：if (arr[j] < arr[minIndex]) 用来比较当前元素和已知最小值的大小。如果找到一个更小的值，就更新 minIndex。

2. 分解代码步骤

遍历范围：for (int j = i + 1; j < n; j++) 表示从当前 i 位置的下一个元素开始遍历到数组末尾，这是在查找未排序部分的最小值。
比较与更新：if (arr[j] < arr[minIndex]) 用来判断 arr[j] 是否小于当前最小值 arr[minIndex]，如果是，则更新 minIndex 为 j。

3. 类比记忆

扫描比赛选手：可以想象自己是一个评委，依次扫描所有还未评分的选手，看到更漂亮的就记下她的位置。这种类比有助于更生动地记住循环和判断的逻辑。

4. 口头或手写练习

反复手写或口述这段代码，可以大声说出：“从第一个未排序的选手开始，依次比较，找到最小的，更新位置”。这种反复的练习可以强化记忆。

5. 记忆口诀

为这段代码编一个简单的记忆口诀，比如：
- 从后扫遍，找最小，位置变。

6. 代码模版

将这段代码视为“寻找最小值”的模版。以后遇到类似的问题，直接从记忆中提取这段代码模版。比如，当需要在一部分数组中找出最小值时，就会联想到这个 for 循环。

7. 多次实践

反复在不同的场景中使用这段代码，比如在其他排序算法中尝试实现类似的逻辑，实践可以帮助加深记忆。

8. 视觉化记忆

你可以通过画图来帮助记忆，画出数组的样子，然后标注出 i 和 j 的位置，想象 minIndex 如何被更新，这种视觉化的方法可以帮助你更容易理解并记住这段代码。

通过理解核心逻辑、分解步骤、类比记忆和实践等方法，你可以更快地记住这段代码。

        // 交换位置，将最漂亮的选手放到当前位置
        if (minIndex != i) {
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        } 怎么能快速记住这段代码

记住这段交换代码可以通过理解其背后的逻辑和使用一些记忆技巧来实现。以下是一些方法，帮助你快速记住这段代码：

1. 理解代码背后的逻辑

交换元素的核心思想：这段代码的目的是将找到的最小元素（最漂亮的选手）放到当前位置。在数组排序中，交换是常见操作，你只需要记住这是为了把两个位置的元素对调。
条件判断：if (minIndex != i) 用来判断是否需要交换。如果当前位置 i 已经是最小值所在位置，就不需要交换；否则，就要把最小值放到当前位置。

2. 三步交换法

这段代码的结构很固定，可以通过将其分解为三个简单的步骤来记忆：

保存最小值：int temp = arr[minIndex]; 这一步是保存找到的最小值，以便在交换时不会丢失。
把当前位置的值放到最小值的位置：arr[minIndex] = arr[i]; 这是交换的第一步，把当前的元素移到最小值的位置。
把最小值放到当前位置：arr[i] = temp; 最后一步是把保存的最小值放到当前位置。

记住这三个步骤可以帮助你快速复现这段代码。

3. 类比记忆

可以将这段代码类比为物品交换：

想象你有两个箱子（arr[i] 和 arr[minIndex]），你想把两个箱子的东西交换。
你先把一个箱子的内容（最小值）临时存放在一个空箱子里（temp），然后把另一个箱子的内容放入第一个箱子，最后把临时存放的内容放回第二个箱子。

4. 口头或手写练习

多次手写这段代码，或者在脑海中重复，口头上讲述交换的逻辑和步骤。比如，反复说出：“保存最小值、将当前位置的值放到最小值位置、将最小值放回当前位置”。

5. 记忆口诀

编个简短的口诀来帮助记忆，比如：

取临时、放当前、最小值归原。

6. 实践

实践是最好的记忆方式。多次在不同场景中使用这段代码，在实际项目或练习中应用它，自然就会记住。

7. 代码模版

将这段代码当作一个“交换模版”来记忆，以后遇到类似的问题时，直接从记忆中提取这个模版。例如，你可以在大脑中把它与“交换算法”或“选择排序”关键词绑定。

通过理解逻辑、分解步骤、类比记忆和多次实践，你会发现记住这段代码变得更容易了。

   // 外层循环：从头到尾进行“选美”
    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;
        }怎么能快速记住这段代码

要快速记住这段代码，结合理解逻辑、分解步骤、记忆技巧以及多次实践是最有效的方法。下面是具体的步骤：