C语言编程实现对一组无序的整型数，本别采用直接插入排序、简单选择排序、堆排序算法从小到大排序，并在屏幕上显示排序结果

以下是C语言实现的三种排序算法，可以对一组无序的整型数进行从小到大排序，并在屏幕上显示排序结果。

#include <stdio.h>

// 直接插入排序
void insertionSort(int arr[], int n) {
    int i, j, key;
    for (i = 1; i < n; i++) {
        key = arr[i];
        j = i - 1;

        // 将比 key 大的数向后移
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }

        // 将 key 插入到正确的位置
        arr[j + 1] = key;
    }
}

// 简单选择排序
void selectionSort(int arr[], int n) {
    int i, j, minIndex, tmp;
    for (i = 0; i < n - 1; i++) {
        minIndex = i;

        // 找到最小元素的下标
        for (j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }

        // 将最小元素放到数组开头
        tmp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = tmp;
    }
}

// 堆排序
void heapSort(int arr[], int n) {
    int i, tmp;

    // 构建堆
    for (i = n / 2 - 1; i >= 0; i--) {
        heapify(arr, n, i);
    }

    // 依次取出堆顶元素并调整堆
    for (i = n - 1; i >= 0; i--) {
        tmp = arr[0];
        arr[0] = arr[i];
        arr[i] = tmp;

        heapify(arr, i, 0);
    }
}

// 调整堆，使其成为大根堆
void heapify(int arr[], int n, int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    int tmp;

    // 找到最大元素的下标
    if (left < n && arr[left] > arr[largest]) {
        largest = left;
    }
    if (right < n && arr[right] > arr[largest]) {
        largest = right;
    }

    // 如果最大元素不是当前节点，就交换它们并递归调整
    if (largest != i) {
        tmp = arr[i];
        arr[i] = arr[largest];
        arr[largest] = tmp;

        heapify(arr, n, largest);
    }
}

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

    printf("原始数组：");
    for (i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    insertionSort(arr, n);
    printf("\n直接插入排序后的数组：");
    for (i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    selectionSort(arr, n);
    printf("\n简单选择排序后的数组：");
    for (i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    heapSort(arr, n);
    printf("\n堆排序后的数组：");
    for (i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    return 0;
}

输出结果为：

原始数组：5 3 8 4 2 1 9 7 6 
直接插入排序后的数组：1 2 3 4 5 6 7 8 9 
简单选择排序后的数组：1 2 3 4 5 6 7 8 9 
堆排序后的数组：1 2 3 4 5 6 7 8 9