最全排序算法（C/C++描述），包含原理讲解，算法分析

我们将涵盖几种最常见的排序算法，包括冒泡排序、选择排序、插入排序、归并排序、快速排序、堆排序、桶排序、基数排序和计数排序。每种算法将提供C++代码，并解释其原理、时间复杂度和空间复杂度。

1. 冒泡排序 (Bubble Sort)

原理

冒泡排序通过重复遍历数组，每次比较相邻元素并交换它们，如果它们的顺序错误。这个过程将最大或最小的元素逐步“冒泡”到数组的末端。

时间复杂度

• 最坏情况: O(n^2)
• 最好情况: O(n)
• 平均情况: O(n^2)

空间复杂度

• O(1)（原地排序）

C++代码

#include <iostream>
#include <vector>

using namespace std;

void bubbleSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
            }
        }
    }
}

int main() {
    vector<int> arr = {64, 34, 25, 12, 22, 11, 90};
    bubbleSort(arr);
    cout << "Sorted array: ";
    for (int val : arr) {
        cout << val << " ";
    }
    cout << endl;
    return 0;
}

2. 选择排序 (Selection Sort)

原理

选择排序通过反复找到未排序部分中的最小元素，并将其放在已排序部分的末尾。这个过程将数组逐渐分成已排序和未排序的两部分。

时间复杂度

• 最坏情况: O(n^2)
• 最好情况: O(n^2)
• 平均情况: O(n^2)

空间复杂度

• O(1)（原地排序）

C++代码

#include <iostream>
#include <vector>

using namespace std;

void selectionSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = 0; i < n - 1; i++) {//在i之后寻找最小（大）的值
        int minIdx = i;//保证如果没有找到，执行交换操作不会改变值
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j;
            }
        }
        swap(arr[minIdx], arr[i]);
    }
}

int main() {
    vector<int> arr = {64, 25, 12, 22, 11};
    selectionSort(arr);
    cout << "Sorted array: ";
    for (int val : arr) {
        cout << val << " ";
    }
    cout << endl;
    return 0;
}

3. 插入排序 (Insertion Sort)

原理

插入排序通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。每次将未排序部分的第一个元素插入到已排序部分的适当位置。

时间复杂度

• 最坏情况: O(n^2)
• 最好情况: O(n)
• 平均情况: O(n^2)

空间复杂度

• O(1)（原地排序）

C++代码

#include <iostream>
#include <vector>

using namespace std;

void insertionSort(vector<int>& arr) {
    int n = arr.size();
    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 = j - 1;
        }
        arr[j + 1] = key;//保证未找到时值不变
    }
}

int main() {
    vector<int> arr = {12, 11, 13, 5, 6};
    insertionSort(arr);
    cout << "Sorted array: ";
    for (int val : arr) {
        cout << val << " ";
    }
    cout << endl;
    return 0;
}

4. 归并排序 (Merge Sort)

原理

归并排序是一种分治算法。它将数组分成两部分，分别排序，然后合并这两部分。递归地将每部分再分成两部分，直到每部分只有一个元素，然后合并这些部分。

时间复杂度

• 最坏情况: O(n log n)
• 最好情况: O(n log n)
• 平均情况: O(n log n)

空间复杂度

• O(n)（需要辅助数组）

C++代码

#include <iostream>
#include <vector>

using namespace std;

void merge(vector<int>& arr, int l, int m, int r) {
    int n1 = m - l + 1;
    int n2 = r - m;
    vector<int> L(n1), R(n2);

    for (int i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (int j = 0; j < n2; j++)
        R[j] = arr[m + 1 + j];

    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

void mergeSort(vector<int>& arr, int l, int r) {//传入参数，数组，数组前后标
    if (l < r) {
        int m = l + (r - l) / 2;
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);
        merge(arr, l, m, r);
    }
}

int main() {
    vector<int> arr = {12, 11, 13, 5, 6, 7};
    mergeSort(arr, 0, arr.size() - 1);
    cout << "Sorted array: ";
    for (int val : arr) {
        cout << val << " ";
    }
    cout << endl;
    return 0;
}

5. 快速排序 (Quicksort)

原理

快速排序通过选择一个基准元素（pivot），将数组分成两部分，一部分小于基准元素，另一部分大于基准元素，然后递归地对这两部分进行排序。

时间复杂度

• 最坏情况: O(n^2)
• 最好情况: O(n log n)
• 平均情况: O(n log n)

空间复杂度

• O(log n)（递归调用栈的空间）

C++代码

#include <iostream>
#include <vector>

using namespace std;

int partition(vector<int>& arr, int low, int high) {
    int pivot = arr[high];
    int i = low - 1;

    for (int j = low; j < high; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[i + 1], arr[high]);
    return i + 1;
}

void quickSort(vector<int>& arr, int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

int main() {
    vector<int> arr = {10, 7, 8, 9, 1, 5};
    quickSort(arr, 0, arr.size() - 1);
    cout << "Sorted array: ";
    for (int val : arr) {
        cout << val << " ";
    }
    cout << endl;
    return 0;
}

6. 堆排序 (Heap Sort)

原理

堆排序利用堆这种数据结构来排序数组。首先将数组构造成一个最大堆，然后重复地将堆顶元素移除并放到数组的末尾，重新调整堆。

时间复杂度

• 最坏情况: O(n log n)
• 最好情况: O(n log n)
• 平均情况: O(n log n)

空间复杂度

• O(1)（原地排序）

C++代码

#include <iostream>
#include <vector>

using namespace std;

void heapify(vector<int>& arr, int n, int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;

    if (left < n && arr[left

] > arr[largest])
        largest = left;

    if (right < n && arr[right] > arr[largest])
        largest = right;

    if (largest != i) {
        swap(arr[i], arr[largest]);
        heapify(arr, n, largest);
    }
}

void heapSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    for (int i = n - 1; i > 0; i--) {
        swap(arr[0], arr[i]);
        heapify(arr, i, 0);
    }
}

int main() {
    vector<int> arr = {12, 11, 13, 5, 6, 7};
    heapSort(arr);
    cout << "Sorted array: ";
    for (int val : arr) {
        cout << val << " ";
    }
    cout << endl;
    return 0;
}

7. 桶排序 (Bucket Sort)

原理

桶排序将数组元素分到有限数量的桶里，每个桶内再进行排序，最后将桶内元素合并。适用于均匀分布的数据。

时间复杂度

• 最坏情况: O(n^2)
• 最好情况: O(n + k)
• 平均情况: O(n + k)

空间复杂度

• O(n + k)

C++代码

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void bucketSort(vector<float>& arr) {
    int n = arr.size();
    vector<float> b[n];

    for (int i = 0; i < n; i++) {
        int bi = n * arr[i];
        b[bi].push_back(arr[i]);
    }

    for (int i = 0; i < n; i++)
        sort(b[i].begin(), b[i].end());

    int index = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < b[i].size(); j++)
            arr[index++] = b[i][j];
}

int main() {
    vector<float> arr = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434};
    bucketSort(arr);
    cout << "Sorted array: ";
    for (float val : arr) {
        cout << val << " ";
    }
    cout << endl;
    return 0;
}

8. 基数排序 (Radix Sort)

原理

基数排序按照个位、十位、百位等顺序进行排序，利用稳定的排序算法（如计数排序）对每一位进行排序。适用于位数较少的数据。

时间复杂度

• 最坏情况: O(nk)
• 最好情况: O(nk)
• 平均情况: O(nk)

空间复杂度

• O(n + k)

C++代码

#include <iostream>
#include <vector>

using namespace std;

int getMax(const vector<int>& arr) {
    int mx = arr[0];
    for (int i = 1; i < arr.size(); i++)
        if (arr[i] > mx)
            mx = arr[i];
    return mx;
}

void countSort(vector<int>& arr, int exp) {
    int n = arr.size();
    vector<int> output(n);
    int count[10] = {0};

    for (int i = 0; i < n; i++)
        count[(arr[i] / exp) % 10]++;

    for (int i = 1; i < 10; i++)
        count[i] += count[i - 1];

    for (int i = n - 1; i >= 0; i--) {
        output[count[(arr[i] / exp) % 10] - 1] = arr[i];
        count[(arr[i] / exp) % 10]--;
    }

    for (int i = 0; i < n; i++)
        arr[i] = output[i];
}

void radixSort(vector<int>& arr) {
    int m = getMax(arr);
    for (int exp = 1; m / exp > 0; exp *= 10)
        countSort(arr, exp);
}

int main() {
    vector<int> arr = {170, 45, 75, 90, 802, 24, 2, 66};
    radixSort(arr);
    cout << "Sorted array: ";
    for (int val : arr) {
        cout << val << " ";
    }
    cout << endl;
    return 0;
}

9. 计数排序 (Counting Sort)

原理

计数排序通过计算每个元素的出现次数，利用这些计数来确定每个元素在排序后的数组中的位置。适用于范围较小的整数排序。

时间复杂度

• 最坏情况: O(n + k)
• 最好情况: O(n + k)
• 平均情况: O(n + k)

空间复杂度

• O(k)

C++代码

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void countingSort(vector<int>& arr) {
    int maxElem = *max_element(arr.begin(), arr.end());
    int minElem = *min_element(arr.begin(), arr.end());
    int range = maxElem - minElem + 1;

    vector<int> count(range), output(arr.size());
    for (int i = 0; i < arr.size(); i++)
        count[arr[i] - minElem]++;

    for (int i = 1; i < count.size(); i++)
        count[i] += count[i - 1];

    for (int i = arr.size() - 1; i >= 0; i--) {
        output[count[arr[i] - minElem] - 1] = arr[i];
        count[arr[i] - minElem]--;
    }

    for (int i = 0; i < arr.size(); i++)
        arr[i] = output[i];
}

int main() {
    vector<int> arr = {4, 2, 2, 8, 3, 3, 1};
    countingSort(arr);
    cout << "Sorted array: ";
    for (int val : arr) {
        cout << val << " ";
    }
    cout << endl;
    return 0;
}

10. 希尔排序 (Shell Sort)

原理

希尔排序是插入排序的一种改进版。它通过将数据集分成多个较小的子集来减少移动的次数，从而提高效率。希尔排序通过不断缩小间隔来逐步排序，最终使用插入排序完成排序过程。

时间复杂度

• 最坏情况: O(n^2)
• 最好情况: O(n log n)
• 平均情况: O(n log^2 n)

空间复杂度

• O(1)（原地排序）

C++代码

#include <iostream>
#include <vector>

using namespace std;

void shellSort(vector<int>& arr) {
    int n = arr.size();
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j;
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                arr[j] = arr[j - gap];
            }
            arr[j] = temp;
        }
    }
}

int main() {
    vector<int> arr = {12, 34, 54, 2, 3};
    shellSort(arr);
    cout << "Sorted array: ";
    for (int val : arr) {
        cout << val << " ";
    }
    cout << endl;
    return 0;
}

11. 梳排序 (Comb Sort)

原理

梳排序是一种改进的冒泡排序。它通过消除乌龟元素（靠近末尾的小元素）来减少排序的时间。梳排序使用一个递减的间隙来比较和交换元素，直到间隙收缩到1。

时间复杂度

• 最坏情况: O(n^2)
• 最好情况: O(n log n)
• 平均情况: O(n^2 / 2^p)

空间复杂度

• O(1)（原地排序）

C++代码

#include <iostream>
#include <vector>

using namespace std;

void combSort(vector<int>& arr) {
    int n = arr.size();
    int gap = n;
    bool swapped = true;

    while (gap != 1 || swapped) {
        gap = (gap * 10) / 13;
        if (gap < 1)
            gap = 1;

        swapped = false;
        for (int i = 0; i < n - gap; i++) {
            if (arr[i] > arr[i + gap]) {
                swap(arr[i], arr[i + gap]);
                swapped = true;
            }
        }
    }
}

int main() {
    vector<int> arr = {8, 4, 1, 56, 3, -44, 23, -6, 28, 0};
    combSort(arr);
    cout << "Sorted array: ";
    for (int val : arr) {
        cout << val << " ";
    }
    cout << endl;
    return 0;
}

总结

所有的排序算法中，从简单到复杂，从适用于小数据量到适用于大数据量，从稳定到不稳定，各有各的特点和应用场景。以下是总结所有介绍过的排序算法的复杂度和特点：

1. 冒泡排序: 简单，适用于小数据量，时间复杂度高，空间复杂度低。
2. 选择排序: 简单，适用于小数据量，时间复杂度高，空间复杂度低。
3. 插入排序: 简单，适用于近乎有序的小数据量，时间复杂度适中，空间复杂度低。
4. 归并排序: 稳定，高效，适用于大数据量，时间复杂度低，但空间复杂度高。
5. 快速排序: 高效，但在最坏情况下时间复杂度高，适用于大数据量，空间复杂度低。
6. 堆排序: 不稳定，适用于大数据量，时间复杂度低，空间复杂度低。
7. 桶排序: 稳定，适用于数据分布均匀且数据量大，时间复杂度低，但空间复杂度高。
8. 基数排序: 稳定，适用于特定范围内的整数排序，时间复杂度低，但空间复杂度高。
9. 计数排序: 稳定，适用于范围较小的整数排序，时间复杂度低，但空间复杂度高。
10. 希尔排序: 插入排序的改进版，适用于中等数据量，时间复杂度适中，空间复杂度低。
11. 梳排序: 冒泡排序的改进版，适用于中等数据量，时间复杂度适中，空间复杂度低。

每种排序算法都有其特定的优势和劣势。选择适当的排序算法需要根据具体的数据特性和应用场景进行权衡。希望这些详细的解释和代码实现能帮助你更好地理解各种排序算法及其应用。