排序（简单算法C++）

按照算法复杂程度，将排序算法分为两类。这里介绍的是简单算法，包括冒泡排序、简单选择排序和直接插入排序。

一、冒泡排序

1.冒泡排序

冒泡排序的原理是：通过不断交换相邻两个元素的位置，把小的元素交换到前面，大的元素交换到后面。每次遍历数组，都会把当前最大（或最小）的元素放到最后一个位置，因此需要循环n-1次。在每次遍历过程中，从第一个元素开始，每次比较相邻两个元素的大小，如果当前位置的元素比下一个位置的元素大，就交换它们的位置。每次循环过程中，都会减少一个比较次数，因为最后一个位置已经排好序了，因此需要比较的元素数量也会相应减少。最终得到一个有序的数组。冒泡排序的时间复杂度为O(n^2)，不适合处理大规模数据。

#include <iostream>
using namespace std;

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {  // 循环n-1次
        for (int j = 0; j < n - i - 1; j++) {  // 每次循环比较n-i-1次
            if (arr[j] > arr[j+1]) {  // 如果当前位置比下一个位置大，则交换它们的值
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

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

    bubbleSort(arr, n);

    cout << "排序后的数组：" << endl;
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

2.优化后的冒泡排序

优化后的冒泡排序原理是：在每次遍历数组时，如果没有进行交换，说明已经排好序了，可以直接退出循环。为了判断当前循环是否进行了交换，引入了一个布尔变量swapped来记录。初始值为true，表示数组未排序完成，每次交换后将其设置为true。如果一次循环结束后，swapped的值没有发生变化，说明已经排好序了，可以退出循环。同时，还需要一个变量i来记录当前循环的位置，每次循环结束后将其增加1。这样就可以避免不必要的比较和交换操作，提高了冒泡排序的效率。优化后的冒泡排序的最好时间复杂度为O(n)，最坏时间复杂度仍然为O(n^2)。

#include <iostream>
using namespace std;

void bubbleSort(int arr[], int n) {
    bool swapped = true;  // 标记当前是否进行了交换
    int i = 0;  // 定义当前循环的位置
    for(int i = 0; i < n - 1 && swapped; i++)// 只要进行了交换，就继续循环
    {
        swapped = false;  // 初始值为false
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                swapped = true;  // 如果进行了交换，就将标记设置为true
            }
        }
    }
}

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

    bubbleSort(arr, n);

    cout << "排序后的数组：" << endl;
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

二、简单选择排序

简单选择排序的原理是：将数组分成有序和无序两部分，每次从无序部分中选择最小的元素，放到有序部分的末尾。具体实现时，使用两个嵌套循环，外层循环控制有序部分的末尾，内层循环从无序部分中选择最小的元素，然后将其与有序部分的末尾交换位置。在每次内层循环中，需要记录最小元素的索引，以便进行交换。优化选择排序的关键是减少交换次数，因为交换次数会影响排序的效率。因此，在选择最小元素时，不要立即进行交换，而是在一次内层循环结束后，如果最小元素不在有序部分的末尾，再进行交换。这样可以减少交换次数，提高排序的效率。简单选择排序的时间复杂度始终为O(n^2)，与数据的分布情况无关。但简单选择排序的性能上要略优于冒泡排序。

#include <iostream>
using namespace std;

void selectionSort(int arr[], int n) {
    int i, j, minIndex;
    for (i = 0; i < n - 1; i++) {
        minIndex = i;  // 假设当前元素是最小值
        for (j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;  // 更新最小值的索引
            }
        }
        if (minIndex != i) {
            // 将最小值与当前元素交换位置
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

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

    selectionSort(arr, n);

    cout << "排序后的数组：" << endl;
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

三、直接插入排序

直接插入排序的原理是：将一个待排序的元素插入到已经排好序的数组中，保证插入后仍然有序。具体实现中，从第二个元素开始遍历数组，记录当前需要插入的值，然后在已排序部分从后往前查找插入位置，如果当前值小于已排序部分的某个值，就将该值向后移动一位，继续往前查找。最后，将需要插入的值插入到已排序部分的正确位置。重复这个过程，直到所有的数都被排序。直接插入排序的时间复杂度为O(n^2)，最坏情况下为O(n^2)，最好情况下为O(n)。但直接插入排序的性能比简单选择排序和冒泡排序都要好一些。

#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[] = { 5, 2, 9, 3, 1, 7, 6, 8, 4 };
    int n = sizeof(arr) / sizeof(arr[0]);

    insertionSort(arr, n);

    cout << "排序后的数组：" << endl;
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

总结

以上为排序的简单算法，本人小白，主要用来记录，此文章参考chatGPT，如有错误，欢迎大佬们指点出来。