排序（c++）

1. 快速排序（Quick Sort）

• 快速排序是一种基于分治思想的排序算法。
• 它选择一个基准元素，将数组分为两部分：小于基准的元素和大于基准的元素。
• 然后递归地对这两部分进行排序。
• 快速排序的时间复杂度平均为O(n log n)，是一种效率较高的排序算法。

代码示例

#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 = {12, 9, 7, 15, 10, 23};
    int n = arr.size();

    quickSort(arr, 0, n - 1);

    cout << "Sorted array: ";
    for (int num : arr) {
        cout << num << " ";
    }
    cout << endl;

    return 0;
}

2. 冒泡排序（Bubble Sort）

• 冒泡排序是一种简单直观的比较排序算法。
• 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序错误则交换。
• 每次遍历都会将当前未排序部分的最大元素“冒泡”到最后。
• 冒泡排序的时间复杂度为O(n^2)，效率相对较低，不适合大规模数据。

#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, 25, 12, 22, 11};
    int n = arr.size();

    bubbleSort(arr);

    cout << "Sorted array: ";
    for (int num : arr) {
        cout << num << " ";
    }
    cout << endl;

    return 0;
}

3. 归并排序（Merge Sort）

• 归并排序是一种稳定的排序算法，基于分治和递归的思想。
• 将数组分成两半，分别对左右两部分递归地进行排序。
• 然后合并两个已排序的子数组，得到完全排序的数组。
• 归并排序的时间复杂度为O(n log n)，适用于大规模数据和外部排序。

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

// 合并两个已排序数组的函数
void merge(vector<int>& arr, int low, int mid, int high) {
    int n1 = mid - low + 1;
    int n2 = high - mid;

    vector<int> left(n1), right(n2);

    for (int i = 0; i < n1; ++i)
        left[i] = arr[low + i];
    for (int j = 0; j < n2; ++j)
        right[j] = arr[mid + 1 + j];

    int i = 0, j = 0, k = low;

    while (i < n1 && j < n2) {
        if (left[i] <= right[j]) {
            arr[k++] = left[i++];
        } else {
            arr[k++] = right[j++];
        }
    }

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

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

// 归并排序算法
void mergeSort(vector<int>& arr, int low, int high) {
    if (low < high) {
        int mid = low + (high - low) / 2;

        mergeSort(arr, low, mid);
        mergeSort(arr, mid + 1, high);

        merge(arr, low, mid, high);
    }
}

int main() {
    vector<int> arr = {12, 11, 13, 5, 6, 7};
    int n = arr.size();

    mergeSort(arr, 0, n - 1);

    cout << "Sorted array: ";
    for (int num : arr) {
        cout << num << " ";
    }
    cout << endl;

    return 0;
}

4. 直接插入排序（Insertion Sort）

• 直接插入排序是一种简单直观的排序算法。
• 将数组分为已排序区间和未排序区间，初始已排序区间只有一个元素。
• 每次从未排序区间取出一个元素，插入到已排序区间的正确位置，使得插入后仍然有序。
• 直接插入排序的时间复杂度为O(n^2)，但在数据已经基本有序的情况下表现较好。

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

        // 将大于key的元素都向后移动一个位置
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            --j;
        }
        arr[j + 1] = key;
    }
}

int main() {
    vector<int> arr = {12, 11, 13, 5, 6};
    int n = arr.size();

    insertionSort(arr);

    cout << "Sorted array: ";
    for (int num : arr) {
        cout << num << " ";
    }
    cout << endl;

    return 0;
}

5. 堆排序（Heap Sort）

• 堆排序利用堆这种数据结构的性质进行排序。
• 将待排序的序列构建成一个最大堆（或最小堆）。
• 依次将堆顶元素（最大值或最小值）与堆的最后一个元素交换，并重新调整堆，使得剩余元素仍保持堆的性质。
• 堆排序的时间复杂度为O(n log n)，且具有原地排序的特点，适合大规模数据。

#include <iostream>
#include <vector>

using namespace std;

// 调整堆，将以root为根的子树调整为最大堆
void heapify(vector<int>& arr, int n, int root) {
    int largest = root; // 初始化根节点为最大值
    int left = 2 * root + 1; // 左子节点索引
    int right = 2 * root + 2; // 右子节点索引

    // 找出根节点、左子节点和右子节点中的最大值
    if (left < n && arr[left] > arr[largest])
        largest = left;
    if (right < n && arr[right] > arr[largest])
        largest = right;

    // 如果最大值不是根节点，交换根节点与最大值节点，并递归调整子树
    if (largest != root) {
        swap(arr[root], 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); // 调整剩余元素为最大堆
    }
}

// 输出数组元素
void printArray(vector<int>& arr) {
    for (int i = 0; i < arr.size(); ++i)
        cout << arr[i] << " ";
    cout << endl;
}

int main() {
    vector<int> arr = {12, 11, 13, 5, 6, 7};
    
    cout << "原始数组: ";
    printArray(arr);

    heapSort(arr);

    cout << "排序后数组: ";
    printArray(arr);

    return 0;
}