给定n个数值，从小到大排序。 1.输入随机生成0≦x≦109数组，长度分别为5、10、100； 2.采用三种排序（快速排序、归并排序、自选一类排序算法）输出每次执行的排序结果; 3.时间复杂度、空间复杂度、实际执行时间、实际占用内存空间？给出完整c代码

给你一个大致的C语言代码示例，展示了如何对给定的整数数组进行排序以及分析三种排序算法的时间复杂度、空间复杂度和性能：

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

// 1. 随机生成整数数组
int* generate_random_array(int n, int max_val) {
    int *arr = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; ++i) {
        arr[i] = rand() % (max_val + 1);
    }
    return arr;
}

// 2. 快速排序函数
void quick_sort(int *arr, int low, int high) {
    // 时间复杂度：平均O(n log n)，最坏O(n^2)
    // 空间复杂度：O(log n) (递归栈)
    if (low < high) {
        int pivot_index = partition(arr, low, high);
        quick_sort(arr, low, pivot_index - 1);
        quick_sort(arr, pivot_index + 1, high);
    }
}

// 归并排序函数
void merge_sort(int *arr, int low, int high) {
    // 时间复杂度：O(n log n)，始终稳定
    // 空间复杂度：O(n)
    if (low < high) {
        int mid = (low + high) / 2;
        merge_sort(arr, low, mid);
        merge_sort(arr, mid + 1, high);
        merge(arr, low, mid, high);
    }
}

// 自选排序算法 (这里假设选择插入排序作为代表)
void insertion_sort(int *arr, int n) {
    // 时间复杂度：最好O(n), 最差O(n^2)，平均O(n^2)
    // 空间复杂度：O(1)
    for (int i = 1; i < n; ++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 partition(int *arr, int low, int high) {
    //...
}

// 合并函数 (归并排序)
void merge(int *arr, int low, int mid, int high) {
    //...
}

// 测试排序算法
int main() {
    srand(time(0)); // 设置随机种子
    int sizes[] = {5, 10, 100};
    const int max_val = 1e9;

    for (int size : sizes) {
        int *array = generate_random_array(size, max_val);
        
        clock_t start_time = clock();
        quick_sort(array, 0, size - 1);
        clock_t quick_sort_time = clock() - start_time;
        printf("Quick Sort:\n");
        print_sorted_array(array, size);
        
        start_time = clock();
        merge_sort(array, 0, size - 1);
        clock_t merge_sort_time = clock() - start_time;
        printf("Merge Sort:\n");
        print_sorted_array(array, size);

        start_time = clock();
        insertion_sort(array, size);
        clock_t insertion_sort_time = clock() - start_time;
        printf("Insertion Sort:\n");
        print_sorted_array(array, size);

        free(array); // 释放内存

        // 计算时间和空间消耗并打印
        double avg_quick_sort_time = ((double)quick_sort_time) / CLOCKS_PER_SEC;
        double avg_merge_sort_time = ((double)merge_sort_time) / CLOCKS_PER_SEC;
        double avg_insertion_sort_time = ((double)insertion_sort_time) / CLOCKS_PER_SEC;
        printf("\nTime complexities and performance metrics:\n");
        printf("Quick Sort: Time = %.2f sec, Space = O(log n)\n", avg_quick_sort_time);
        printf("Merge Sort: Time = %.2f sec, Space = O(n)\n", avg_merge_sort_time);
        printf("Insertion Sort: Time = %.2f sec, Space = O(1)\n", avg_insertion_sort_time);

        printf("\nMemory usage: Unspecified, depends on your system\n");
    }

    return 0;
}

// 打印排序后的数组
void print_sorted_array(int *arr, int n) {
    for (int i = 0; i < n; ++i) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

这个代码只是一个基本的框架，你需要填充`partition()`和`merge()`函数的具体实现。此外，对于空间占用的测量，上面的代码并没有精确计算，因为C标准库函数`malloc()`和`free()`的内存管理并不提供准确的空间分配和回收信息。实际运行时，你可以考虑使用操作系统提供的工具或第三方库来跟踪内存使用情况。