排序（改进算法C++）

按照算法复杂程度，将排序算法分为两类。这里介绍的是改进算法，包括希尔排序、堆排序、归并排序和快速排序。

一、希尔排序

希尔排序是一种基于插入排序的排序算法，也称为缩小增量排序。它是将整个数组分成若干个子序列，对每个子序列进行插入排序，通过逐步缩小子序列的步长，最终使整个数组有序。

希尔排序的基本思想是将待排序的元素分成若干个子序列，分别进行插入排序，待整个序列中的元素基本有序时，再对全体元素进行一次插入排序。具体实现中，先将整个待排序的数组按照步长 gap 进行分组，对每组数据进行插入排序，然后逐步减小步长继续进行分组排序，直到步长为 1 时，进行最后一次插入排序。其中，初始步长的选择可以影响到排序算法的时间复杂度。

希尔排序的优点是比直接插入排序有较高的效率，时间复杂度为O(nlogn)。但是其实现过程比较复杂，因为需要按照步长进行分组，并且最后一次需要进行直接插入排序，这使得代码较难理解。

#include <iostream>
using namespace std;

void shellSort(int arr[], int n) {
    // 定义增量序列
    int gap = n / 2;
    while (gap > 0) {
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j = i;
            while (j >= gap && arr[j - gap] > temp) {
                arr[j] = arr[j - gap];
                j -= gap;
            }
            arr[j] = temp;
        }
        gap /= 2;  // 减小增量序列
    }
}

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

    shellSort(arr, n);

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

    return 0;
}

二、堆排序

堆排序的原理是：将待排序的序列构建成一个大根堆（或小根堆），此时整个序列的最大值（或最小值）就是堆顶的根节点。将其与末尾元素进行交换，此时末尾元素就是最大值（或最小值），然后将剩余的n-1个元素重新构建成一个堆，重复这个过程，直到整个序列有序。具体实现中，先构建初始堆，然后将堆顶元素与末尾元素交换，堆的大小减1，重新堆化，直到堆的大小为1。堆排序的时间复杂度为O(nlogn)，空间复杂度为O(1)。

不理解可以看B站：排序算法：堆排序【图解+代码】_哔哩哔哩_bilibili

#include <iostream>
using namespace std;

void heapify(int arr[], int n, int i) {
    int largest = i;  // 假设最大元素为根节点
    int l = 2 * i + 1;  // 左子节点的下标
    int r = 2 * i + 2;  // 右子节点的下标

    // 如果左子节点比根节点大，将最大元素改为左子节点
    if (l < n && arr[l] > arr[largest]) {
        largest = l;
    }

    // 如果右子节点比根节点大，将最大元素改为右子节点
    if (r < n && arr[r] > arr[largest]) {
        largest = r;
    }

    // 如果最大元素不是根节点，将最大元素与根节点交换，并递归堆化
    if (largest != i) {
        swap(arr[i], arr[largest]);  //使得最大值在根节点处
        heapify(arr, n, largest);  //递归检查交换后下面有没有影响
    }
}

void heapSort(int arr[], int n) {
    // 建立初始堆
    //根节点为(i-1)/2；(n-1-1)/2=n/2-1
    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() {
    int arr[] = { 5, 2, 9, 3, 1, 7, 6, 8, 4 };
    int n = sizeof(arr) / sizeof(arr[0]);

    heapSort(arr, n);

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

    return 0;
}

三、归并排序

归并排序的原理是：将待排序的序列分成两个长度相等的子序列，然后对这两个子序列分别进行排序，最后将两个已排序的子序列合并成一个有序的序列。具体实现中，采用分治的思想，递归地将序列划分为较小的子序列，然后不断地合并相邻的两个子序列，直到合并成一个完整的有序序列。归并排序的时间复杂度为O(nlogn)，空间复杂度为O(n)。

不理解可以看B站：排序算法：归并排序【图解+代码】_哔哩哔哩_bilibili

#include <iostream>
using namespace std;

// 合并
void merge(int arr[], int tempArr[], int left, int mid, int right)
{
    // 标记左半区第一个未排序的元素
    int l_pos = left;
    // 标记右半区第一个未排序的元素
    int r_pos = mid + 1;
    // 临时数组元素的下标
    int pos = left;

    // 合并
    while (l_pos <= mid && r_pos <= right)
    {
        if (arr[l_pos] < arr[r_pos])  // 左半区第一个剩余元素更小
            tempArr[pos++] = arr[l_pos++];
        else  // 右半区第一个剩余元素更小
            tempArr[pos++] = arr[r_pos++];
    }

    // 合并左半区剩余的元素
    while (l_pos <= mid)
        tempArr[pos++] = arr[l_pos++];

    // 合并右半区剩余的元素
    while (r_pos <= right)
        tempArr[pos++] = arr[r_pos++];

    // 把临时数组中合并后的元素复制回原来的数组
    while (left <= right)
    {
        arr[left] = tempArr[left];
        left++;
    }
}

// 归并排序
void msort(int arr[], int tempArr[], int left, int right)
{
    // 如果只有一个元素，那么不需要继续划分
    // 只有一个元素的区域，本生就是有序的，只需要被归并即可
    if (left < right)
    {
        // 找中间点
        int mid = (left + right) / 2;
        // 递归划分左半区
        msort(arr, tempArr, left, mid);
        // 递归划分右半区
        msort(arr, tempArr, mid + 1, right);
        // 合并已经排序的部分
        merge(arr, tempArr, left, mid, right);
    }
}

// 归并排序入口
void merge_sort(int arr[], int n)
{
    // 分配一个辅助数组
    int tempArr[n];
    // 调用实际的归并排序
    msort(arr, tempArr, 0, n - 1);
}

int main(int argc, char const *argv[])
{
    test(&merge_sort);
    return 0;
}

非递归

void mergeSort(int arr[], int n) 
{ 
   int curr_size;  // 当前子数组的大小，子数组大小： 1 到 n/2 
   int left_start;  // 左子数组的开始下标
  
   // 自底向上归并.  首先归并大小为1的数组形成大小为2的有序子数组, 
   // 接着归并大小为2的数组，形成大小为4的有序子数组 
   for (curr_size=1; curr_size<=n-1; curr_size = 2*curr_size) 
   { 
       // 根据子数组大小调整左子数组起始下标 
       for (left_start=0; left_start<n-1; left_start += 2*curr_size) 
       { 
           // min函数是为了防止下标越界
           // 找出左子数组结尾下标
           int mid = min(left_start + curr_size - 1, n-1); 
           // 找出右子数组结尾下标
           int right_end = min(left_start + 2*curr_size - 1, n-1); 
  
           // 归并子数组 arr【left_start...mid】 & arr【mid+1...right_end】 ，和递归的相同
           merge(arr, left_start, mid, right_end); 
       } 
   } 
}

四、快速排序

基本思想是选择一个基准元素（这里取最后一个），通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字都比基准元素小，另一部分记录的关键字都比基准元素大，然后分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

快速排序的时间复杂度为 O(nlogn)，其中 n 表示待排序数组的长度。它是一种原地排序算法，不需要额外的存储空间，因此空间复杂度为 O(1)。快速排序是一种不稳定的排序算法，也就是说它可能改变相等元素之间的相对顺序。

具体可参考：排序算法：快速排序【图解+代码】_哔哩哔哩_bilibili

#include <iostream>
using namespace std;
/**
 * @brief 快速排序
 *        大体思想：把比pivot小的换到前面
 *
 * @param arr 数组
 * @param low 最左边索引
 * @param high 最右边索引
 * @return int 划分位置
 */
int partition(int arr[], int low, int high)
{
    int pivot = arr[high];
    int i = low - 1;

    for (int j = low; j < high; j++)
    {
        // 比pivot小的，全部换到前面去
        if (arr[j] <= pivot)
            swap(&arr[j], &arr[++i]);
    }
    // 此时，i指向的元素一定大于等于pivot
    swap(&arr[high], &arr[i+1]);
    return i+1;
}

/**
 * @brief 递归划分
 *
 * @param arr 数字
 * @param low 左边界下标
 * @param high 右边界下标
 */
void qsort(int arr[], int low, int high)
{
    if (low < high)
    {
        int mid = partition(arr, low, high);
        qsort(arr, low, mid - 1);
        qsort(arr, mid + 1, high);
    }
}

/**
 * @brief 快速排序入口
 *
 * @param arr 数组
 * @param len 长度
 */
void quick_sort(int arr[], int len)
{
    qsort(arr, 0, len - 1);
}

int main(int argc, char const *argv[])
{
    test(&quick_sort);
    return 0;
}

总结

以上为排序的改进算法，本人小白，主要用来记录，如有错误，欢迎大佬们指点出来。