（以下均按照从小到大排序）

1.冒泡排序

比较两个相邻的元素，将较大的元素交换到右边，较小的元素交换到左边。

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换相邻两个元素
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}

2.选择排序

每次选择最小（或最大）的元素放到已排序序列的末尾。

void selectionSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[min_idx]) {
                min_idx = j;
            }
        }
        // 将最小值放到已排序序列的末尾
        int tmp = arr[i];
        arr[i] = arr[min_idx];
        arr[min_idx] = tmp;
    }
}

3.插入排序

将未排序的元素逐个插入到已排序序列中的正确位置。

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;
    }
}

4.快速排序（最快）

将一个大的数组分成两个小的数组，分别对两个小的数组进行排序，最终实现整个数组的排序。

void quickSort(int arr[], int left, int right) {
    if (left >= right) return;
    int i = left, j = right, x = arr[left];
    while (i < j) {
        while (i < j && arr[j] >= x) j--;
        if (i < j) arr[i++] = arr[j];
        while (i < j && arr[i] < x) i++;
        if (i < j) arr[j--] = arr[i];
    }
    arr[i] = x;
    quickSort(arr, left, i - 1);
    quickSort(arr, i + 1, right);
}

5.归并排序（最稳定）

该算法将一个大的数组分成两个小的数组，分别对两个小的数组进行排序，最后将两个有序的小数组进行归并，形成一个新的有序数组。

void merge(int arr[], int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;
    int L[n1], R[n2];
    for (int i = 0; i < n1; i++) L[i] = arr[left + i];
    for (int j = 0; j < n2; j++) R[j] = arr[mid + 1 + j];
    int i = 0, j = 0, k = left;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k++] = L[i++];
        } else {
            arr[k++] = R[j++];
        }
    }
    while (i < n1) arr[k++] = L[i++];
    while (j < n2) arr[k++] = R[j++];
}

void mergeSort(int arr[], int left, int right) {
    if (left >= right) return;
    int mid = (left + right) / 2;
    mergeSort(arr, left, mid);
    mergeSort(arr, mid + 1, right);
    merge(arr, left, mid, right);
}

模板实现

1.sort()函数

它可以用来对数组或容器进行排序，使用方便，效率高。sort()函数底层采用快速排序算法，并结合了一些优化手段，能够在大多数情况下实现高效排序。

#include <algorithm>  // 包含 sort 函数

int arr[] = {3, 1, 4, 2, 5};
int n = sizeof(arr) / sizeof(int);

// 对数组进行排序
sort(arr, arr + n);

// 对容器进行排序
vector<int> vec = {3, 1, 4, 2, 5};
sort(vec.begin(), vec.end());

未加其他条件时，sort()函数默认进行升序排序。

语法：sort(start , end , cmp)

cmp是用于规定排序的方法，可不填（此时默认升序）。cmp可以是一个自定义的函数名字

start, end得是一个指针。

注：begin()函数和end()函数是STL标准库提供的函数模板，以begin()函数为例，其语法格式为：

template<class T,size_t N>
T* begin(T(&arr)[N]);  //返回指针

2.传入一个比较函数cmp

bool compare(int a, int b) {
    return a > b; // 降序排列
}

int arr[] = {3, 1, 4, 2, 5};
int n = sizeof(arr) / sizeof(int);

// 按照自定义规则对数组进行排序
sort(arr, arr + n, compare);

一维数组排序