选择排序和冒泡排序

日富一日824

已于 2024-12-02 10:29:21 修改

阅读量1k

点赞数 15

文章标签：笔记 c++ 算法蓝桥杯

于 2024-12-02 10:27:12 首次发布

本文链接：https://blog.csdn.net/ajsjnnn/article/details/144180460

版权

选择排序

方法介绍

选择排序（Selection Sort）是一种简单直观的排序算法。它的基本思想是：每一轮从未排序的部分中选择出最小（或最大）的元素，将其放到已排序部分的末尾。选择排序的工作过程如下：

### 算法步骤：

1. **初始化**：将待排序的数组或列表分为已排序和未排序两部分。初始时，已排序部分为空，未排序部分为整个数组。

2. **选择最小元素**：在未排序的部分中找到最小（或最大）元素。

3. **交换位置**：将找到的最小元素与未排序部分的第一个元素交换位置，这样未排序部分的第一个元素就成为了已排序部分的一部分。

4. **更新未排序部分**：将未排序部分的范围缩小，已排序部分增大。

5. **重复**：重复步骤 2 和 3，直到未排序部分为空。

### 示例：

假设我们有一个数组 `[64, 25, 12, 22, 11]`，我们使用选择排序对其进行排序：

1. **第一轮**：
- 找到最小值 `11`，交换到数组的最前面：
- 结果：`[11, 25, 12, 22, 64]`

2. **第二轮**：
- 在 `[25, 12, 22, 64]` 中找到最小值 `12`，交换：
- 结果：`[11, 12, 25, 22, 64]`

3. **第三轮**：
- 在 `[25, 22, 64]` 中找到最小值 `22`，交换：
- 结果：`[11, 12, 22, 25, 64]`

4. **第四轮**：
- 在 `[25, 64]` 中找到最小值 `25`，不需要交换：
- 结果：`[11, 12, 22, 25, 64]`

5. **第五轮**：
- 只剩下一个元素 `64`，已排序完成。

最终排序后的数组为 `[11, 12, 22, 25, 64]`。

### 性能分析：

- **时间复杂度**：
- 最坏情况：O(n^2)
- 平均情况：O(n^2)
- 最好情况：O(n^2)

这里的 n 是数组的长度。选择排序在每一轮中都需要遍历未排序的元素，因此时间复杂度是平方级别。

- **空间复杂度**：O(1)，选择排序是原地排序算法，不需要额外的存储空间。

- **稳定性**：选择排序是不稳定的，因为在选择最小元素时可能会改变相同元素的相对位置。

### 总结：

选择排序是一种简单易懂的排序算法，但由于其效率较低，通常不适用于大规模数据的排序。在实际应用中，选择排序主要用于教育和学习目的，以帮助理解排序的基本概念。

题目描述

有一个数组 nums：2 1 3 -4 8 7

选择排序，从小到大排序，每次在剩余的元素中选择一个最大的放在后面

具体代码

//有一个数组 nums：2 1 3   -4 8 7
//选择排序
#include<iostream>
#include<algorithm>
using namespace std;

//升序排序
void up_sort(int a[],int n)
{
    for (int i = 0; i < n - 1; i++)
    {
        int minindex = i;
        for (int j = i + 1; j < n; j++)
        {
            if (a[j] < a[minindex])minindex = j;
        }swap(a[minindex],a[i]);
    }
}

//降序排序
void down_sort(int a[], int n)
{
    for (int i = 0; i < n-1; i++)
    {
        int maxindex = i;
        for (int j = i + 1; j < n; j++)
        {
            if (a[j] > a[maxindex])maxindex = j;
        }swap(a[maxindex], a[i]);
    }
}

int main()
{
    int a[6] = { 2,1,3,-4,8,7 };

    up_sort(a, 6);
    for (auto i : a)cout << i << " ";

    cout << endl;

    down_sort(a, 6);
    for (auto i : a)cout << i << " ";

    return 0;
}

思路分析

一共两层循环，第一层循环控制交换次数，n个元素，排序完成就要交换n-1次，每次第二层循环开始，假设我是升序，那我就假设minindex=i，第二层循环从i+1开始一直到结束，如果有比最小值小的就存起来，第二层循环结束之后，minindex里面存的就是最小的值，然后用swap语句交换一下最小值和第i个就可以了，降序的话就反过来，每次存储最大值即可。

结果展示

注意事项

其实选择排序这样像我一样只是一种风格而已，仅供大家参考，写法可以有很多种，但是核心思想都是差不多的

冒泡排序

方法介绍

冒泡排序是一种简单的排序算法，它通过重复地遍历待排序的数组，比较相邻元素并交换它们的顺序，从而将较大的元素“冒泡”到数组的末尾。这个过程会持续进行，直到没有需要交换的元素为止，数组就被排序完成。

冒泡排序的基本步骤

比较相邻元素：从数组的开始位置开始，比较相邻的两个元素。
交换元素：如果前一个元素比后一个元素大，则交换它们的位置。
重复过程：继续比较下一个相邻的元素，直到遍历完整个数组。
多次遍历：对整个数组重复上述过程，直到没有需要交换的元素为止。

冒泡排序的时间复杂度

最坏和平均情况：O(n²)，当数组是逆序时，需要进行最多的比较和交换。
最好情况：O(n)，当数组已经是有序的情况下，只需进行一次遍历。
空间复杂度：O(1)，因为只使用了常数级别的额外空间。

题目描述

有一个数组 nums：2 1 3 -4 8 7

选择排序，从小到大排序，每次在剩余的元素中选择一个最大的放在后面

具体代码

//有一个数组 nums：2 1 3   -4 8 7
//选择排序
#include<iostream>
#include<algorithm>
using namespace std;

//升序排序
void up_sort(int a[],int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n - i-1; j++)
        {
            if (a[j] > a[j + 1])swap(a[j], a[j + 1]);
        }
    }
}

//降序排序
void down_sort(int a[], int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n - i - 1; j++)
        {
            if (a[j] < a[j + 1])swap(a[j], a[j + 1]);
        }
    }
}

int main()
{
    int a[6] = { 2,1,3,-4,8,7 };

    up_sort(a, 6);
    for (auto i : a)cout << i << " ";

    cout << endl;

    down_sort(a, 6);
    for (auto i : a)cout << i << " ";

    return 0;
}