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

以下是基于C语言的六种排序算法的实现，同时加入了菜单选项和退出选项。

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

#define MAX_SIZE 100

void menu(); // 菜单函数声明
void print(int arr[], int n); // 打印函数声明
void direct_insert_sort(int arr[], int n); // 直接插入排序函数声明
void shell_sort(int arr[], int n); // 希尔排序函数声明
void bubble_sort(int arr[], int n); // 冒泡排序函数声明
void quick_sort(int arr[], int left, int right); // 快速排序函数声明
void select_sort(int arr[], int n); // 选择排序函数声明
void heap_sort(int arr[], int n); // 堆排序函数声明
void swap(int *a, int *b); // 交换函数声明
void adjust_heap(int arr[], int i, int n); // 调整堆函数声明

int main()
{
    int arr[MAX_SIZE], n, i, choice;
    while(1)
    {
        menu(); // 显示菜单
        printf("请输入菜单编号：");
        scanf("%d", &choice);
        switch(choice)
        {
            case 1:
                printf("请输入要排序的元素个数：");
                scanf("%d", &n);
                printf("请输入要排序的元素：\n");
                for(i=0; i<n; i++)
                {
                    scanf("%d", &arr[i]);
                }
                direct_insert_sort(arr, n);
                print(arr, n);
                break;
            case 2:
                printf("请输入要排序的元素个数：");
                scanf("%d", &n);
                printf("请输入要排序的元素：\n");
                for(i=0; i<n; i++)
                {
                    scanf("%d", &arr[i]);
                }
                shell_sort(arr, n);
                print(arr, n);
                break;
            case 3:
                printf("请输入要排序的元素个数：");
                scanf("%d", &n);
                printf("请输入要排序的元素：\n");
                for(i=0; i<n; i++)
                {
                    scanf("%d", &arr[i]);
                }
                bubble_sort(arr, n);
                print(arr, n);
                break;
            case 4:
                printf("请输入要排序的元素个数：");
                scanf("%d", &n);
                printf("请输入要排序的元素：\n");
                for(i=0; i<n; i++)
                {
                    scanf("%d", &arr[i]);
                }
                quick_sort(arr, 0, n-1);
                print(arr, n);
                break;
            case 5:
                printf("请输入要排序的元素个数：");
                scanf("%d", &n);
                printf("请输入要排序的元素：\n");
                for(i=0; i<n; i++)
                {
                    scanf("%d", &arr[i]);
                }
                select_sort(arr, n);
                print(arr, n);
                break;
            case 6:
                printf("请输入要排序的元素个数：");
                scanf("%d", &n);
                printf("请输入要排序的元素：\n");
                for(i=0; i<n; i++)
                {
                    scanf("%d", &arr[i]);
                }
                heap_sort(arr, n);
                print(arr, n);
                break;
            case 7:
                exit(0); // 退出程序
                break;
            default:
                printf("请输入正确的菜单编号！\n");
                break;
        }
    }
    return 0;
}

// 菜单函数实现
void menu()
{
    printf("\n");
    printf("**********************\n");
    printf("*     排序算法菜单     *\n");
    printf("**********************\n");
    printf("*    1. 直接插入排序   *\n");
    printf("*    2. 希尔排序      *\n");
    printf("*    3. 冒泡排序      *\n");
    printf("*    4. 快速排序      *\n");
    printf("*    5. 选择排序      *\n");
    printf("*    6. 堆排序        *\n");
    printf("*    7. 退出          *\n");
    printf("**********************\n");
}

// 打印函数实现
void print(int arr[], int n)
{
    int i;
    printf("排序后的结果为：\n");
    for(i=0; i<n; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

// 直接插入排序函数实现
void direct_insert_sort(int arr[], int n)
{
    int i, j, temp;
    for(i=1; i<n; i++)
    {
        if(arr[i] < arr[i-1])
        {
            temp = arr[i];
            for(j=i-1; j>=0 && arr[j]>temp; j--)
            {
                arr[j+1] = arr[j];
            }
            arr[j+1] = temp;
        }
    }
}

// 希尔排序函数实现
void shell_sort(int arr[], int n)
{
    int gap, i, j, temp;
    for(gap=n/2; gap>0; gap/=2)
    {
        for(i=gap; i<n; i++)
        {
            if(arr[i] < arr[i-gap])
            {
                temp = arr[i];
                for(j=i-gap; j>=0 && arr[j]>temp; j-=gap)
                {
                    arr[j+gap] = arr[j];
                }
                arr[j+gap] = temp;
            }
        }
    }
}

// 冒泡排序函数实现
void bubble_sort(int arr[], int n)
{
    int i, j, flag=1;
    for(i=0; i<n-1 && flag; i++)
    {
        flag = 0;
        for(j=0; j<n-i-1; j++)
        {
            if(arr[j] > arr[j+1])
            {
                swap(&arr[j], &arr[j+1]);
                flag = 1;
            }
        }
    }
}

// 快速排序函数实现
void quick_sort(int arr[], int left, int right)
{
    int i, j, pivot;
    if(left < right)
    {
        i = left;
        j = right;
        pivot = arr[left];
        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;
        quick_sort(arr, left, i-1);
        quick_sort(arr, i+1, right);
    }
}

// 选择排序函数实现
void select_sort(int arr[], int n)
{
    int i, j, min;
    for(i=0; i<n-1; i++)
    {
        min = i;
        for(j=i+1; j<n; j++)
        {
            if(arr[j] < arr[min])
            {
                min = j;
            }
        }
        if(min != i)
        {
            swap(&arr[i], &arr[min]);
        }
    }
}

// 堆排序函数实现
void heap_sort(int arr[], int n)
{
    int i;
    for(i=(n-2)/2; i>=0; i--)
    {
        adjust_heap(arr, i, n);
    }
    for(i=n-1; i>=1; i--)
    {
        swap(&arr[i], &arr[0]);
        adjust_heap(arr, 0, i);
    }
}

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

// 调整堆函数实现
void adjust_heap(int arr[], int i, int n)
{
    int j, temp;
    temp = arr[i];
    j = 2*i + 1;
    while(j<n)
    {
        if(j+1<n && arr[j+1]>arr[j])
        {
            j++;
        }
        if(arr[j] > temp)
        {
            arr[i] = arr[j];
            i = j;
            j = 2*i+1;
        }
        else
        {
            break;
        }
    }
    arr[i] = temp;
}

以上是基于C语言的六种排序算法的实现，同时加入了菜单选项和退出选项。