简单排序的那些事儿（c++详细讲解）

一 、选择排序

初始位置：选择排序从数组的第一个元素开始，假设它已经是最小值。
寻找最小元素：在剩余未排序的元素中（从第二个元素开始），找到最小元素的索引。
交换位置：将找到的最小元素与数组的第一个元素交换位置。此时，数组的前两个元素已经是最小的两个元素。
重复过程：将数组的起始位置向后移动一位（即从第二个元素开始），重复步骤2和步骤3，直到整个数组排序完成。

特点：选择排序每次遍历都能找到最小（或最大）的元素，但是它不会直接放在正确的位置上，而是通过交换的方式逐步移动到正确的位置。

选择排序的时间复杂度分析：
最好情况：数组已经是有序的，但是选择排序不会提前结束，所以时间复杂度仍然是 O(n^2)。
平均情况：需要比较和交换的元素数量是固定的，时间复杂度为 O(n^2)。
最坏情况：数组完全逆序，需要进行最多的比较和交换，时间复杂度为 O(n^2)。
选择排序的空间复杂度是 O(1)，因为它只需要一个额外的变量来存储最小元素的索引，不需要额外的存储空间

#include<iostream>
#include<algorithm>
using namespace std;

void selectiong(int arr[],int n)
{
	if (arr == NULL || n < 2)
	{
		return;
	}
	for (int i = 0; i < n; i++)
	{
		int mindex = i;
		for (int j = i + 1; j < n; j++)
		{
			mindex = arr[j] < arr[mindex] ? j : mindex;
		}
		std::swap(arr[i],arr[mindex]);
	}
}

int main()
{
	int arr[] = {1,8,68,574,99,25,30,12};
	int n = sizeof(arr) / sizeof(arr[0]);
	selectiong(arr,n);
	for (auto i : arr)
	{
		cout << i << "  " << endl;
	}

	return 0;
}

输出结果：

1  8  12  25  30  68  99  574

二、冒泡排序

冒泡排序（Bubble Sort）是一种简单的排序算法，它通过重复遍历要排序的数列，比较相邻元素的大小，并在必要时交换它们的位置，使得较大的元素逐渐“冒泡”到数列的末尾。这个过程类似于气泡在水中上升，因此得名冒泡排序。下面是冒泡排序的基本步骤：

开始排序：从数组的第一个元素开始，比较相邻的元素（比如第一个和第二个元素）。
比较与交换：如果发现相邻的元素顺序错误（即第一个元素大于第二个元素），就交换它们的位置。这样，较大的元素就会“冒泡”到右边。
继续遍历：继续比较下一对相邻元素，重复上述比较和交换的过程，直到数组的最后一个元素。这样，数组的最后一个元素就是最大的元素。
重复过程：在完成第一次遍历后，数组中的最大元素已经被放到了正确的位置。然后，从数组的第一个元素开始，再次进行遍历，但这次可以忽略最后一个已经排序好的元素。重复这个过程，每次遍历的范围都会缩小，因为每次都会确定一个元素的位置。
结束条件：当进行到某次遍历后，没有发生任何交换时，说明数组已经完全排序，此时可以结束排序过程。

冒泡排序的时间复杂度分析：

最好情况：数组已经是有序的，只需要进行一次遍历，时间复杂度为 O(n)。
平均情况：需要进行大约 n/2 次遍历，时间复杂度为 O(n^2)。
最坏情况：数组完全逆序，需要进行 n-1 次遍历，时间复杂度为 O(n^2)。
冒泡排序的空间复杂度是 O(1)，因为它不需要额外的存储空间，所有的操作都在原地进行。

#include <iostream>
using namespace std;

// 冒泡排序函数
void bubbleSort(int arr[], int n) {
    bool swapped;
    for (int i = 0; i < n - 1; i++) {
        swapped = false;
        // 内层循环用于进行相邻元素的比较和交换
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换相邻元素
                swap(arr[j], arr[j + 1]);
                swapped = true;
            }
        }
        // 如果在这一轮遍历中没有发生交换，说明数组已经排序完成
        if (!swapped) {
            break;
        }
    }
}

// 主函数
int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);

    cout << "Original array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    bubbleSort(arr, n);

    cout << "Sorted array:   ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

三、插入排序

插入排序（Insertion Sort）是一种简单直观的排序算法，它的工作原理类似于我们整理扑克牌时的行为：我们通常将手中的牌插入到已经排序好的牌堆中的适当位置。插入排序的基本步骤如下：

初始假设：假设数组的第一个元素（或前两个元素）已经是有序的。
选择元素：从数组的第二个元素开始（对于第一个元素，这个步骤是跳过的），将其作为“当前元素”。
比较与插入：将当前元素与它前面的元素进行比较，如果当前元素小于前面的元素，就将当前元素向前移动（即与前面的元素交换位置），直到找到合适的位置插入当前元素。
重复过程：继续处理数组中的下一个元素，重复步骤2和步骤3，直到整个数组都被处理过。
结束条件：当所有的元素都被插入到正确的位置时，排序完成。

插入排序的时间复杂度分析：

最好情况：如果数组已经是有序的，那么只需要进行一次遍历，时间复杂度为 O(n)。
平均情况：在平均情况下，时间复杂度为 O(n^2)。
最坏情况：如果数组是完全逆序的，那么每次插入都需要比较和移动元素，时间复杂度为 O(n^2)。
插入排序的空间复杂度是 O(1)，因为它不需要额外的存储空间，所有的操作都在原地进行。

#include <iostream>
using namespace std;

// 插入排序函数
void insertionSort(int arr[], int n) {
    // 从第一个元素开始，假设它已经是有序的
    for (int i = 1; i < n; i++) {
        int key = arr[i]; // 当前要插入的元素
        int j = i - 1;

        // 将当前元素与它前面的元素进行比较，找到合适的插入位置
        while (j >= 0 && arr[j] > key) {
            // 如果前面的元素大于当前元素，将前面的元素向后移动
            arr[j + 1] = arr[j];
            j--;
        }
        // 将当前元素插入到找到的位置
        arr[j + 1] = key;
    }
}

// 主函数
int main() {
    int arr[] = {9, 5, 1, 4, 3, 6, 2, 8, 7, 0};
    int n = sizeof(arr) / sizeof(arr[0]);

    cout << "Original array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    insertionSort(arr, n);

    cout << "Sorted array:   ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}