【数据结构排序算法篇】----选择排序【实战演练】

最新推荐文章于 2024-07-09 17:00:28 发布

xxxhuxxx

最新推荐文章于 2024-07-09 17:00:28 发布

阅读量1.1k

点赞数 28

分类专栏：深入数据结构 - 从基础到实战文章标签：排序算法数据结构算法

本文链接：https://blog.csdn.net/m0_71685576/article/details/136056559

版权

深入数据结构 - 从基础到实战专栏收录该内容

15 篇文章 2 订阅

订阅专栏

本文介绍了选择排序的基本概念、步骤、时间复杂度和空间复杂度，通过实例演示了排序过程，并讨论了其在面试中的应用。作者鼓励读者通过练习和理解不同排序算法来深化数据结构学习。

摘要由CSDN通过智能技术生成

在这里插入图片描述

作为一名对技术充满热情的学习者，我一直以来都深刻地体会到知识的广度和深度。在这个不断演变的数字时代，我远非专家，而是一位不断追求进步的旅行者。通过这篇博客，我想分享我在某个领域的学习经验，与大家共同探讨、共同成长。请大家以开放的心态阅读，相信你们也会在这段知识之旅中找到启示。

前言

前面我们已经学习了较为简单的冒泡排序，相信大家对排序也有了新的认识，今天我们就来谈谈选择排序，通过对选择排序的讲解，搭配各种实战题目，来加强大家对排序算法新的认识，也希望同学们可以看完讲解后先将题目做一做。

一、什么是选择排序

选择排序是一种简单直观的比较排序算法。它的基本思想是：首先通过比较找出最小（或最大）元素，然后将它和数组的第一个元素交换。接下来，再从剩下的元素中找出最小（或最大）的元素，再与数组的第二个元素交换。如此继续，直到整个数组排序完成。

选择排序的过程大概可以分为以下几个步骤：

从数组的当前位置开始扫描数组，找到最小（或最大）元素的索引，这个位置可以称作“选择位置”。
将找到的最小（或最大）元素与“选择位置”上的元素交换。
对数组的剩余部分重复以上步骤。

选择排序的性能分析：

时间复杂度：由于选择排序需要两层循环，其平均和最坏情况下的时间复杂度均为 O(n^2)，其中 n 是数组的长度。
空间复杂度：选择排序是原地排序算法，因此空间复杂度为 O(1)。
不稳定性：选择排序是不稳定的排序算法，因为它在交换元素时可能会改变相等元素的初始相对位置。

选择排序比较适合小规模数据的排序，但由于其时间复杂度较高，在大规模数据排序时效率要低于其他效率更高的排序算法，如快速排序、归并排序等。

二、练习

较为简单的练习

这里有一个简单的选择排序的例题：

例题：“使用选择排序算法对数组 [29, 10, 14, 37, 13] 进行升序排序，并说明每一轮选择过程。”
解答：

选择排序的基本思想是遍历数组，每一轮都找出当前未处理序列中最小的元素，然后与未处理序列的第一个元素交换位置。

对于数组 [29, 10, 14, 37, 13]，选择排序的过程是这样的：

第1轮:

查找最小值：10
10 与第一个元素 29 交换位置
排序后的数组：[10, 29, 14, 37, 13]

第2轮:

从第二个元素开始查找最小值：13
13 与第二个元素 29 交换位置
排序后的数组：[10, 13, 14, 37, 29]

第3轮:

从第三个元素开始查找最小值：14 (这一轮实际上不需要做任何交换，因为第三个元素已经是当前最小值)
排序后的数组：[10, 13, 14, 37, 29]

第4轮:

从第四个元素开始查找最小值：29
29 与第四个元素 37 交换位置
排序后的数组：[10, 13, 14, 29, 37]

至此排序已经完成，因为最后一轮只剩一个元素，它必定是当前最大值。最终排序结果为：[10, 13, 14, 29, 37]。

这就是选择排序的基本操作。每一轮选择都保证了该轮选择位置开始到数组末尾部分的最小值被放置在了选择位置上。经过多轮这样的处理，数组最终达到有序状态。

较为复杂的练习

例题：“使用选择排序算法对数组 [64, 34, 25, 12, 22, 11, 90, 11, 64] 进行升序排序，并详细说明每一步骤。”
解答：

使用选择排序对数组进行升序排序的详细步骤如下：

初始数组：[64, 34, 25, 12, 22, 11, 90, 11, 64]

第1轮:

查找最小值：11（索引5）
11（索引5）与第一个元素64（索引0）交换位置
排序后数组：[11, 34, 25, 12, 22, 64, 90, 11, 64]

第2轮:

从第二个元素开始查找最小值：11（索引7）
11（索引7）与第二个元素34（索引1）交换位置
排序后数组：[11, 11, 25, 12, 22, 64, 90, 34, 64]

第3轮:

从第三个元素开始查找最小值：12（索引3）
12（索引3）与第三个元素25（索引2）交换位置
排序后数组：[11, 11, 12, 25, 22, 64, 90, 34, 64]

第4轮:

从第四个元素开始查找最小值：22（索引4）
22（索引4）与第四个元素25（索引3）交换位置
排序后数组：[11, 11, 12, 22, 25, 64, 90, 34, 64]

第5轮:

从第五个元素开始查找最小值：25（索引4，当前位置）
25 已处于正确位置，无需交换
排序后数组：[11, 11, 12, 22, 25, 64, 90, 34, 64]

第6轮:

从第六个元素开始查找最小值：34（索引7）
34（索引7）与第六个元素64（索引5）交换位置
排序后数组：[11, 11, 12, 22, 25, 34, 90, 64, 64]

第7轮:

从第七个元素开始查找最小值：64（索引7）
64（索引7）与第七个元素90（索引6）交换位置
排序后数组：[11, 11, 12, 22, 25, 34, 64, 90, 64]

第8轮（最后一轮）:

从第八个元素开始查找最小值：64（索引8）
64（索引8）与第八个元素90（索引7）交换位置
排序后数组：[11, 11, 12, 22, 25, 34, 64, 64, 90]

排序完成。最终排序结果为：[11, 11, 12, 22, 25, 34, 64, 64, 90]。

在选择排序中，每次迭代后最小的未排序元素都被放置到前面的正确位置，逐步完成整个数组的排序。这个例子比前一个例子更复杂，因为数组较长并且包含了重复的元素。请注意，即使11重复两次，在选择排序中它们也会被找到并放置在数组的开始两个位置，所以算法在处理重复值时也同样适用。

三、排序算法的优缺点

选择排序算法的优缺点可以从多个方面进行分析：

优点：

1. 简单易懂：选择排序的算法逻辑十分简单，它通过不断选择剩余元素中的最小值来实现排序，非常容易理解和实现。
2. 原地排序：不需要额外的大量存储空间，除了输入数组外，只需要一个额外的存储空间来保存临时变量（当前最小值的索引）。
3. 数据移动最小化：选择排序在交换过程中，每次迭代只需要做一次交换动作，即便是在数组完全逆序的情况下，其数据交换次数也不会增加。

缺点：

1. 时间复杂度高：不论数组的初始状态如何，选择排序都会执行 O(n^2) 次比较。因此，其平均和最坏情况下的时间复杂度都是 O(n^2)，这使得选择排序在处理较大数据集时效率低下。
2. 不稳定的排序算法：当存在相等的元素时，由于选择排序可能会跳过它们将更远处的元素交换到前面，从而打乱相等元素的初始相对顺序。
3. 性能问题：由于时间复杂度为 O(n^2)，选择排序在数据量大时表现不佳，特别是与 O(n log n) 时间复杂度的高效排序算法（如快速排序、归并排序等）相比，性能上差距明显。
4. 不适应动态数据：选择排序不适合对实时生成的数据或者动态变化的数据集进行排序，因为它需要在开始排序之前拥有完整的数据集。

综上所述，选择排序由于算法简单，可能适合于小数据量的排序任务。然而，在大多数实际应用场景中，会选择更高效的排序算法来处理数据。

四、面试题

由于选择排序算法比较简单，在实际面试考察中，题目一般都比较简单。不过如果面试官希望测试对选择排序的深入理解和编程细节，他们可能会问一些关于优化和特定情况的处理的问题。
下面提供一个简单的选择排序实现，并在注释中详细解释代码：

public class SelectionSort {
    public static void sort(int[] arr) {
        // arr.length 为数组的长度
        for (int i = 0; i < arr.length - 1; i++) {
            // 初始时假设最小值的位置从i开始
            int minIndex = i;
            
            // 在数组剩余部分寻找最小值的索引
            for (int j = i + 1; j < arr.length; 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(java.util.Arrays.toString(arr));
        }
    }

    public static void main(String[] args) {
        int[] exampleArray = {64, 25, 12, 22, 11};
        // 调用排序方法
        sort(exampleArray);
        // 打印排序结果
        System.out.println("Sorted array: ");
        System.out.println(java.util.Arrays.toString(exampleArray));
    }
}