写一个c程序，对以下5个常用的内部排序算法进行比较：冒泡排序、直接插入排序、快速排序、希尔排序、堆排序。排序表长为1000，测试数据由伪随机数产生器生成，统计每一种排序在正序、逆序及乱序时所花费的时间，对结果作简要分析。

好的，以下是C语言程序实现五种排序算法并进行比较的示例代码：

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

#define MAX_LENGTH 1000

// 交换两个元素的值
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 冒泡排序
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]);
            }
        }
    }
}

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

// 快速排序
void quickSort(int arr[], int left, int right) {
    if (left >= right) {
        return;
    }
    int pivot = arr[left];
    int i = left;
    int j = right;
    while (i < j) {
        while (i < j && arr[j] >= pivot) {
            j--;
        }
        arr[i] = arr[j];
        while (i < j && arr[i] <= pivot) {
            i++;
        }
        arr[j] = arr[i];
    }
    arr[i] = pivot;
    quickSort(arr, left, i - 1);
    quickSort(arr, i + 1, right);
}

// 希尔排序
void shellSort(int arr[], int len) {
    for (int gap = len / 2; gap > 0; gap /= 2) {
        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;
        }
    }
}

// 堆排序
void maxHeapify(int arr[], int start, int end) {
    int dad = start;
    int son = dad * 2 + 1;
    while (son <= end) {
        if (son + 1 <= end && arr[son] < arr[son+1]) {
            son++;
        }
        if (arr[dad] > arr[son]) {
            return;
        } else {
            swap(&arr[dad], &arr[son]);
            dad = son;
            son = dad * 2 + 1;
        }
    }
}
void heapSort(int arr[], int len) {
    for (int i = len / 2 - 1; i >= 0; i--) {
        maxHeapify(arr, i, len - 1);
    }
    for (int i = len - 1; i > 0; i--) {
        swap(&arr[0], &arr[i]);
        maxHeapify(arr, 0, i - 1);
    }
}

// 生成随机数
void generateRandomNumbers(int arr[], int len) {
    srand(time(NULL));
    for (int i = 0; i < len; i++) {
        arr[i] = rand() % 10000;
    }
}

// 生成正序数
void generateOrderedNumbers(int arr[], int len) {
    for (int i = 0; i < len; i++) {
        arr[i] = i;
    }
}

// 生成逆序数
void generateReversedNumbers(int arr[], int len) {
    for (int i = 0; i < len; i++) {
        arr[i] = len - i - 1;
    }
}

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

// 测试排序算法
void testSorting(int arr[], int len) {
    clock_t start, end;

    printf("Bubble Sort:\n");
    generateOrderedNumbers(arr, len);
    start = clock();
    bubbleSort(arr, len);
    end = clock();
    printf("    Ordered: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);

    generateReversedNumbers(arr, len);
    start = clock();
    bubbleSort(arr, len);
    end = clock();
    printf("    Reversed: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);

    generateRandomNumbers(arr, len);
    start = clock();
    bubbleSort(arr, len);
    end = clock();
    printf("    Random: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);

    printf("Insertion Sort:\n");
    generateOrderedNumbers(arr, len);
    start = clock();
    insertionSort(arr, len);
    end = clock();
    printf("    Ordered: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);

    generateReversedNumbers(arr, len);
    start = clock();
    insertionSort(arr, len);
    end = clock();
    printf("    Reversed: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);

    generateRandomNumbers(arr, len);
    start = clock();
    insertionSort(arr, len);
    end = clock();
    printf("    Random: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);

    printf("Quick Sort:\n");
    generateOrderedNumbers(arr, len);
    start = clock();
    quickSort(arr, 0, len - 1);
    end = clock();
    printf("    Ordered: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);

    generateReversedNumbers(arr, len);
    start = clock();
    quickSort(arr, 0, len - 1);
    end = clock();
    printf("    Reversed: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);

    generateRandomNumbers(arr, len);
    start = clock();
    quickSort(arr, 0, len - 1);
    end = clock();
    printf("    Random: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);

    printf("Shell Sort:\n");
    generateOrderedNumbers(arr, len);
    start = clock();
    shellSort(arr, len);
    end = clock();
    printf("    Ordered: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);

    generateReversedNumbers(arr, len);
    start = clock();
    shellSort(arr, len);
    end = clock();
    printf("    Reversed: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);

    generateRandomNumbers(arr, len);
    start = clock();
    shellSort(arr, len);
    end = clock();
    printf("    Random: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);

    printf("Heap Sort:\n");
    generateOrderedNumbers(arr, len);
    start = clock();
    heapSort(arr, len);
    end = clock();
    printf("    Ordered: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);

    generateReversedNumbers(arr, len);
    start = clock();
    heapSort(arr, len);
    end = clock();
    printf("    Reversed: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);

    generateRandomNumbers(arr, len);
    start = clock();
    heapSort(arr, len);
    end = clock();
    printf("    Random: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);
}

int main() {
    int arr[MAX_LENGTH];
    testSorting(arr, MAX_LENGTH);
    return 0;
}

这个程序实现了五种排序算法，并对每种算法在正序、逆序和乱序情况下的时间进行了测试和比较。这里的测试数据长度为1000，可以根据需要进行调整。程序运行后会输出每种算法在不同情况下的运行时间，可以根据输出结果来分析每种算法的优缺点。

需要注意的是，程序中使用的随机数生成器是伪随机数生成器，因此生成的随机数序列并不是完全随机的，可能会对排序算法的测试结果产生一定的影响。如果需要更加准确的测试结果，可以使用真正的随机数生成器或者其他更为复杂的数据生成方法。