c语言1.编程实现直接插入排序、希尔排序、冒泡排序、快速排序、选择排序和堆排序。要求：设计菜单界面、每个排序算法通过选菜单实现，同时要求界面有退出菜单。

好的，以下是 C 语言实现直接插入排序、希尔排序、冒泡排序、快速排序、选择排序和堆排序的代码，同时包含菜单界面和退出菜单的实现。

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

#define MAX_SIZE 100

void printArray(int arr[], int len) {
    for (int i = 0; i < len; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 直接插入排序
void insertionSort(int arr[], int len) {
    for (int i = 1; i < len; i++) {
        int j = i - 1;
        int temp = arr[i];
        while (j >= 0 && arr[j] > temp) {
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = temp;
    }
}

// 希尔排序
void shellSort(int arr[], int len) {
    int gap = len / 2;
    while (gap > 0) {
        for (int i = gap; i < len; i++) {
            int temp = arr[i];
            int j = i - gap;
            while (j >= 0 && arr[j] > temp) {
                arr[j+gap] = arr[j];
                j -= gap;
            }
            arr[j+gap] = temp;
        }
        gap /= 2;
    }
}

// 冒泡排序
void bubbleSort(int arr[], int len) {
    for (int i = 0; i < len-1; i++) {
        for (int j = 0; j < len-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                swap(&arr[j], &arr[j+1]);
            }
        }
    }
}

// 快速排序
int partition(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(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);
    }
}

// 选择排序
void selectionSort(int arr[], int len) {
    for (int i = 0; i < len-1; i++) {
        int minIndex = i;
        for (int j = i+1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        swap(&arr[i], &arr[minIndex]);
    }
}

// 堆排序
void heapify(int arr[], int len, int i) {
    int largest = i;
    int left = 2*i + 1;
    int right = 2*i + 2;
    if (left < len && arr[left] > arr[largest]) {
        largest = left;
    }
    if (right < len && arr[right] > arr[largest]) {
        largest = right;
    }
    if (largest != i) {
        swap(&arr[i], &arr[largest]);
        heapify(arr, len, largest);
    }
}

void heapSort(int arr[], int len) {
    for (int i = len/2 - 1; i >= 0; i--) {
        heapify(arr, len, i);
    }
    for (int i = len-1; i >= 0; i--) {
        swap(&arr[0], &arr[i]);
        heapify(arr, i, 0);
    }
}

int main() {
    int arr[MAX_SIZE];
    int len = 0;

    int choice = 0;
    do {
        printf("\n");
        printf("1. 输入数组\n");
        printf("2. 直接插入排序\n");
        printf("3. 希尔排序\n");
        printf("4. 冒泡排序\n");
        printf("5. 快速排序\n");
        printf("6. 选择排序\n");
        printf("7. 堆排序\n");
        printf("8. 退出菜单\n");
        printf("请选择操作：");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                printf("请输入数组元素个数：");
                scanf("%d", &len);
                printf("请输入数组元素：");
                for (int i = 0; i < len; i++) {
                    scanf("%d", &arr[i]);
                }
                break;
            case 2:
                insertionSort(arr, len);
                printf("直接插入排序结果：");
                printArray(arr, len);
                break;
            case 3:
                shellSort(arr, len);
                printf("希尔排序结果：");
                printArray(arr, len);
                break;
            case 4:
                bubbleSort(arr, len);
                printf("冒泡排序结果：");
                printArray(arr, len);
                break;
            case 5:
                quickSort(arr, 0, len-1);
                printf("快速排序结果：");
                printArray(arr, len);
                break;
            case 6:
                selectionSort(arr, len);
                printf("选择排序结果：");
                printArray(arr, len);
                break;
            case 7:
                heapSort(arr, len);
                printf("堆排序结果：");
                printArray(arr, len);
                break;
            case 8:
                printf("退出菜单\n");
                break;
            default:
                printf("无效的选择，请重新输入\n");
        }
    } while (choice != 8);

    return 0;
}

以上代码可以在 CSDN开发的ChitGPT 中执行，通过菜单选择可以执行相应的排序算法。