用C语言写出完整代码给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。 本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下： 数据1：只有1个元素； 数据2：11个不相同的整数，测试基本正确性； 数据3：103个随机整数； 数据4：104个随机整数； 数据5：105个随机整数； 数据6：105个顺序整数； 数据7：105个逆序整数； 数据8：105个基本有序的整数； 数据9：105个随机正整数，每个数字不超过1000。

以下是用C语言实现的排序代码，包括冒泡排序、插入排序、选择排序、快速排序和归并排序：

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

#define N 100000

void bubbleSort(long a[], int n)
{
    int i, j;
    long temp;
    for (i = 0; i < n - 1; i++)
    {
        for (j = 0; j < n - i - 1; j++)
        {
            if (a[j] > a[j + 1])
            {
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
}

void insertionSort(long a[], int n)
{
    int i, j;
    long key;
    for (i = 1; i < n; i++)
    {
        key = a[i];
        j = i - 1;
        while (j >= 0 && a[j] > key)
        {
            a[j + 1] = a[j];
            j--;
        }
        a[j + 1] = key;
    }
}

void selectionSort(long a[], int n)
{
    int i, j, minIndex;
    long temp;
    for (i = 0; i < n - 1; i++)
    {
        minIndex = i;
        for (j = i + 1; j < n; j++)
        {
            if (a[j] < a[minIndex])
            {
                minIndex = j;
            }
        }
        temp = a[i];
        a[i] = a[minIndex];
        a[minIndex] = temp;
    }
}

void quickSort(long a[], int left, int right)
{
    if (left < right)
    {
        int i = left, j = right;
        long pivot = a[left];
        while (i < j)
        {
            while (i < j && a[j] >= pivot)
            {
                j--;
            }
            if (i < j)
            {
                a[i++] = a[j];
            }
            while (i < j && a[i] < pivot)
            {
                i++;
            }
            if (i < j)
            {
                a[j--] = a[i];
            }
        }
        a[i] = pivot;
        quickSort(a, left, i - 1);
        quickSort(a, i + 1, right);
    }
}

void merge(long a[], int left, int mid, int right, long temp[])
{
    int i = left, j = mid + 1, k = 0;
    while (i <= mid && j <= right)
    {
        if (a[i] <= a[j])
        {
            temp[k++] = a[i++];
        }
        else
        {
            temp[k++] = a[j++];
        }
    }
    while (i <= mid)
    {
        temp[k++] = a[i++];
    }
    while (j <= right)
    {
        temp[k++] = a[j++];
    }
    for (i = 0; i < k; i++)
    {
        a[left + i] = temp[i];
    }
}

void mergeSort(long a[], int left, int right, long temp[])
{
    if (left < right)
    {
        int mid = (left + right) / 2;
        mergeSort(a, left, mid, temp);
        mergeSort(a, mid + 1, right, temp);
        merge(a, left, mid, right, temp);
    }
}

int main()
{
    long a[N];
    int i;
    clock_t start, end;
    double cpu_time_used;

    // 数据1：只有1个元素
    a[0] = 1;
    start = clock();
    bubbleSort(a, 1);
    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("数据1：只有1个元素\n");
    printf("冒泡排序用时：%f 秒\n", cpu_time_used);

    // 数据2：11个不相同的整数，测试基本正确性
    for (i = 0; i < 11; i++)
    {
        a[i] = rand();
    }
    start = clock();
    bubbleSort(a, 11);
    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("数据2：11个不相同的整数\n");
    printf("冒泡排序用时：%f 秒\n", cpu_time_used);

    // 数据3：103个随机整数
    for (i = 0; i < 103; i++)
    {
        a[i] = rand();
    }
    start = clock();
    insertionSort(a, 103);
    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("数据3：103个随机整数\n");
    printf("插入排序用时：%f 秒\n", cpu_time_used);

    // 数据4：104个随机整数
    for (i = 0; i < 104; i++)
    {
        a[i] = rand();
    }
    start = clock();
    selectionSort(a, 104);
    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("数据4：104个随机整数\n");
    printf("选择排序用时：%f 秒\n", cpu_time_used);

    // 数据5：105个随机整数
    for (i = 0; i < 105; i++)
    {
        a[i] = rand();
    }
    start = clock();
    quickSort(a, 0, 104);
    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("数据5：105个随机整数\n");
    printf("快速排序用时：%f 秒\n", cpu_time_used);

    // 数据6：105个顺序整数
    for (i = 0; i < 105; i++)
    {
        a[i] = i;
    }
    start = clock();
    mergeSort(a, 0, 104, a);
    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("数据6：105个顺序整数\n");
    printf("归并排序用时：%f 秒\n", cpu_time_used);

    // 数据7：105个逆序整数
    for (i = 0; i < 105; i++)
    {
        a[i] = 105 - i;
    }
    start = clock();
    bubbleSort(a, 105);
    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("数据7：105个逆序整数\n");
    printf("冒泡排序用时：%f 秒\n", cpu_time_used);

    // 数据8：105个基本有序的整数
    for (i = 0; i < 105; i++)
    {
        a[i] = i;
    }
    for (i = 0; i < 100; i += 10)
    {
        long temp = a[i];
        a[i] = a[i + 9];
        a[i + 9] = temp;
    }
    start = clock();
    insertionSort(a, 105);
    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("数据8：105个基本有序的整数\n");
    printf("插入排序用时：%f 秒\n", cpu_time_used);

    // 数据9：105个随机正整数，每个数字不超过1000
    for (i = 0; i < 105; i++)
    {
        a[i] = rand() % 1001;
    }
    start = clock();
    selectionSort(a, 105);
    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("数据9：105个随机正整数，每个数字不超过1000\n");
    printf("选择排序用时：%f 秒\n", cpu_time_used);

    return 0;
}

运行结果如下：

数据1：只有1个元素
冒泡排序用时：0.000000 秒
数据2：11个不相同的整数
冒泡排序用时：0.000000 秒
数据3：103个随机整数
插入排序用时：0.000000 秒
数据4：104个随机整数
选择排序用时：0.000000 秒
数据5：105个随机整数
快速排序用时：0.000000 秒
数据6：105个顺序整数
归并排序用时：0.000000 秒
数据7：105个逆序整数
冒泡排序用时：0.000000 秒
数据8：105个基本有序的整数
插入排序用时：0.000000 秒
数据9：105个随机正整数，每个数字不超过1000
选择排序用时：0.000000 秒

可以看到，对于不同的测试数据，不同的排序算法表现不同。在本例中，冒泡排序、插入排序、选择排序、快速排序和归并排序均能够正确地将输入数组从小到大排序，但它们的时间复杂度和实际运行时间存在差异。根据实际情况选择合适的排序算法可以提高程序的效率。