【数据结构】排序下

除了冒泡排序、插入排序、选择排序和快速排序之外，还有许多其他排序算法。这里，我将简要介绍两种常见的排序算法：归并排序（Merge Sort）和堆排序（Heap Sort），并提供它们的C语言实现。

1. 归并排序（Merge Sort）

原理：归并排序是一种分治算法。它将数组分成两半，对每半部分递归地进行归并排序，然后将排序好的两半合并在一起。

C语言实现：

#include <stdio.h>
#include <stdlib.h>

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];
            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(int arr[], int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;

        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);

        merge(arr, left, mid, right);
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6, 7};
    int n = sizeof(arr) / sizeof(arr[0]);

    mergeSort(arr, 0, n - 1);

    printf("Sorted array: \n");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");

    return 0;
}

2. 堆排序（Heap Sort）

原理：堆排序是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。

C语言实现（最大堆排序）：

#include <stdio.h>  
#include <stdlib.h>  
  
// 函数用于交换数组中的两个元素  
void swap(int *a, int *b) {  
    int temp = *a;  
    *a = *b;  
    *b = temp;  
}  
  
// 堆化函数，确保以i为根的子树满足最大堆的性质  
void heapify(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(int arr[], int n) {  
    // 构建最大堆  
    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(int arr[], int size) {  
    for (int i = 0; i < size; i++)  
        printf("%d ", arr[i]);  
    printf("\n");  
}  
  
// 主函数来测试堆排序  
int main() {  
    int arr[] = {12, 11, 13, 5, 6, 7};  
    int n = sizeof(arr) / sizeof(arr[0]);  
  
    heapSort(arr, n);  
  
    printf("Sorted array is \n");  
    printArray(arr, n);  
  
    return 0;  
}

3.希尔排序

希尔排序（Shell Sort）是插入排序的一种更高效的改进版本，也称为缩小增量排序。它通过将原来要排序的数组元素按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的元素越来越多，当增量减至1时，整个文件恰被分成一组，算法终止。

希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。

下面是希尔排序的C语言实现：

#include <stdio.h>

// 交换函数
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 希尔排序函数
void shellSort(int arr[], int n) {
    for (int gap = n / 2; gap > 0; gap /= 2) {
        // 对每个分组进行插入排序
        for (int i = gap; i < n; i += 1) {
            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;
        }
    }
}

// 打印数组函数
void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++)
        printf("%d ", arr[i]);
    printf("\n");
}

// 主函数
int main() {
    int arr[] = {12, 34, 54, 2, 3};
    int n = sizeof(arr) / sizeof(arr[0]);

    printf("Original array: \n");
    printArray(arr, n);

    shellSort(arr, n);

    printf("Sorted array: \n");
    printArray(arr, n);

    return 0;
}

在上面的代码中，shellSort函数接受一个整数数组arr和数组的长度n作为参数。它首先设置初始的增量gap为数组长度的一半，然后在每次循环中减小这个增量（通常是减半），直到增量为1。在每次内部循环中，它将数组元素分成gap个组，并对每个组应用插入排序的逻辑。这个过程逐渐使得整个数组变得有序。

希尔排序的时间复杂度依赖于增量的选择，最好情况下的时间复杂度可以达到O(nlogn)，但在最坏情况下，其时间复杂度可能退化到O(n^2)，尽管在实践中这种情况很少见。选择好的增量序列可以大大改善希尔排序的性能。