在 C 语言中，可以通过嵌套循环和比较运算符来实现常见的排序算法，比如冒泡排序、选择排序或插入排序

目录

基础算法：

1.冒泡排序（Bubble Sort）

2.选择排序（Selection Sort）

3.插入排序（Insertion Sort）

高级算法：

1. 快速排序（Quick Sort）

2. 归并排序（Merge Sort）

3. 堆排序（Heap Sort）

基础算法（简单易实现）：冒泡排序、选择排序、插入排序

高级算法（性能更优）：快速排序、归并排序、堆排序

基础算法：

1. 冒泡排序（Bubble Sort）

冒泡排序是简单直观的排序方法，通过多次比较相邻元素并交换位置来排序。

#include <stdio.h>

void bubbleSort(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (arr[j] > arr[j + 1]) { // 如果当前元素大于后一个元素，则交换
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {5, 2, 8, 3, 7};
    int size = sizeof(arr) / sizeof(arr[0]);

    printf("排序前: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    bubbleSort(arr, size);

    printf("排序后: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

备注说明：这里在内循环，j<size-i-1的目的是：因为每进行一次外层循环，数组末尾的一个最大元素会被排序好，因此后续的内层循环会减少比较的次数。

2.选择排序（Selection Sort）

选择排序通过在未排序部分找到最小（最大）元素，然后将其与未排序部分的第一个元素交换位置。

#include <stdio.h>

void selectionSort(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        int minIndex = i; // 假设当前元素是最小值
        for (int j = i + 1; j < size; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j; // 找到更小的元素
            }
        }
        // 交换最小值和当前位置
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

int main() {
    int arr[] = {5, 2, 8, 3, 7};
    int size = sizeof(arr) / sizeof(arr[0]);

    printf("排序前: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    selectionSort(arr, size);

    printf("排序后: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

备注说明：

3.插入排序（Insertion Sort）

插入排序通过逐步将未排序部分的元素插入到已排序部分的正确位置来排序。

#include <stdio.h>

void insertionSort(int arr[], int size) {
    for (int i = 1; i < size; 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;
    }
}

int main() {
    int arr[] = {5, 2, 8, 3, 7};
    int size = sizeof(arr) / sizeof(arr[0]);

    printf("排序前: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    insertionSort(arr, size);

    printf("排序后: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

高级算法：

1. 快速排序（Quick Sort）

快速排序是一种分治算法，通过选定一个“基准”（pivot），将数组分为两部分，递归排序子数组。

#include <stdio.h>

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pivot = arr[low]; // 基准
        int i = low, j = high;
        
        while (i < j) {
            while (i < j && arr[j] >= pivot) j--; // 从右向左找小于基准的
            if (i < j) arr[i++] = arr[j];        // 放到左边
            
            while (i < j && arr[i] <= pivot) i++; // 从左向右找大于基准的
            if (i < j) arr[j--] = arr[i];        // 放到右边
        }
        arr[i] = pivot; // 基准放在最终位置
        
        quickSort(arr, low, i - 1); // 排序左边部分
        quickSort(arr, i + 1, high); // 排序右边部分
    }
}

int main() {
    int arr[] = {5, 2, 8, 3, 7};
    int size = sizeof(arr) / sizeof(arr[0]);

    printf("排序前: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    quickSort(arr, 0, size - 1);

    printf("排序后: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

2. 归并排序（Merge Sort）

归并排序也是一种分治算法，分为两部分分别排序，再合并为有序数组。

#include <stdio.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 i = 0; i < n2; i++) R[i] = arr[mid + 1 + i];

    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) {
        int mid = left + (right - left) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}

int main() {
    int arr[] = {5, 2, 8, 3, 7};
    int size = sizeof(arr) / sizeof(arr[0]);

    printf("排序前: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    mergeSort(arr, 0, size - 1);

    printf("排序后: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

3. 堆排序（Heap Sort）

堆排序通过构造一个堆（最大堆或最小堆）来实现排序。

#include <stdio.h>

void heapify(int arr[], int size, int root) {
    int largest = root;
    int left = 2 * root + 1;
    int right = 2 * root + 2;

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

    if (largest != root) {
        int temp = arr[root];
        arr[root] = arr[largest];
        arr[largest] = temp;
        heapify(arr, size, largest);
    }
}

void heapSort(int arr[], int size) {
    // 构建最大堆
    for (int i = size / 2 - 1; i >= 0; i--) {
        heapify(arr, size, i);
    }
    // 逐步将堆顶元素交换到数组末尾，并调整堆
    for (int i = size - 1; i > 0; i--) {
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        heapify(arr, i, 0);
    }
}

int main() {
    int arr[] = {5, 2, 8, 3, 7};
    int size = sizeof(arr) / sizeof(arr[0]);

    printf("排序前: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    heapSort(arr, size);

    printf("排序后: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}