C语言-算法分析与设计-插入、合并、快速排序运行时间与排序元素个数的统计比较

实验内容

（1）插入排序、合并、快速排序运行时间与排序元素个数的统计比较。

（2）阐述比较结果。

（3）利用算法采用的设计方法，时间复杂度等分析得到该结果的原因。

算法

插入排序

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

合并排序

void merge(int arr[], int l, int m, int r) {
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;
    int L[n1], R[n2];
    for (i = 0; i < n1; i++) {
        L[i] = arr[l + i];
    }
    for (j = 0; j < n2; j++) {
       R[j] = arr[m + 1 + j];
    }
    i = 0;
    j = 0;
    k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        }
        else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}
void mergeSort(int arr[], int l, int r) {
    if (l >= r) {
        return;
    }
    int m = (l + r) / 2;
    mergeSort(arr, l, m);
    mergeSort(arr, m + 1, r);
    merge(arr, l, m, r);
}

快速排序

void quicksort(int arr[], int left, int right) {
    if (left >= right) {
        return;
    }
    int pivot = arr[left];
    int i = left + 1;
    int j = right;
    while (i <= j) {
        if (arr[i] < pivot && arr[j] > pivot) {
            int tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
            i++;
            j--;
        }
        else if (arr[i] >= pivot) {
            i++;
        }
        else if (arr[j] <= pivot) {
            j--;
        }
    }
    int tmp = arr[j];
    arr[j] = arr[left];
    arr[left] = tmp;
    quicksort(arr, left, j - 1);
    quicksort(arr, j + 1, right);
}

运行结果

时间复杂度

实验结果

       由可视化分析可以得出，当n比较小时，快速排序与合并排序用时几乎相同。当n逐渐增大到3000时，快速排序比合并排序略微快一点，插入排序用时显著增加。

原因分析

       插入排序：在平均情况下，插入排序的时间复杂度为O(n^2)。这是因为插入排序在每一步需要移动已排序元素来为新元素腾出空间。然而，如果输入数组已经部分排序，那么插入排序的性能会优于其他算法。

       合并排序：该算法的运行时间主要取决于归并过程，其时间复杂度为O(nlogn)。这是因为每次归并操作都会将两个有序子序列合并成一个更大的有序子序列。

       快速排序：在平均情况下，快速排序的时间复杂度为O(nlogn)。这是因为在每次递归中，算法都可以将问题划分为两个等大的子问题。

遇到的问题

       使用C语言进行编程时遇到了一个错误：C2131，这个错误通常表示在声明一个数组时，使用了一个非常大的数值作为其大小，而这个值并不是一个编译时常量。

解决方法

       C语言的标准规定，数组的大小在编译时就需要已知，它不能是一个运行时才能确定的变量。在你的代码中，你试图使用一个运行时确定的变量n来声明一个数组arr，这是不合法的。因此，你需要将数组大小更改为一个常量。

源码

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

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

// 合并排序
void merge(int arr[], int l, int m, int r) {
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;
    int L[n1], R[n2];
    for (i = 0; i < n1; i++) {
        L[i] = arr[l + i];
    }
    for (j = 0; j < n2; j++) {
       R[j] = arr[m + 1 + j];
    }
    i = 0;
    j = 0;
    k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        }
        else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}
void mergeSort(int arr[], int l, int r) {
    if (l >= r) {
        return;
    }
    int m = (l + r) / 2;
    mergeSort(arr, l, m);
    mergeSort(arr, m + 1, r);
    merge(arr, l, m, r);
}

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

int main() {
    int n =3000; // 排序元素个数（可调整）  
    int arr[n]; // 排序数组（可调整）  
    clock_t start, end; // 计时变量（可调整）  
    double cpu_time_used; // CPU时间差（可安排）  
    srand((unsigned int)time(NULL)); // 初始化随机数种子（可调整）  

    // 非递归直接插入排序运行时间统计和排序元素个数统计比较  
    start = clock(); // 记录开始时间（可调整）  
    insertionSort(arr, n); // 非递归直接插入排序（可调整）  
    end = clock(); // 记录结束时间（可调整）  
    cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC; // 计算CPU时间差（可调整）  
    printf("排序元素个数：%d\n", n); // 输出排序元素个数（可调整）  
    printf("插入排序时间：%.6f秒\n", cpu_time_used); // 输出排序时间（可调整）  

    //快速排序运行时间统计和排序元素个数统计比较  
for (int i = 0; i < n; i++) {  
        arr[i] = rand() % 3000; // 生成随机数并存储到数组中  
    }  
start = clock(); // 记录开始时间（可调整）  
    quicksort(arr, 0, n - 1); // 对数组进行快速排序  
  end = clock(); // 记录结束时间（可调整）  
    cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC; // 计算CPU时间差（可调整）  
  //  printf("排序元素个数：%d\n", n); // 输出排序元素个数（可调整）  
    printf("快速排序时间：%.6f秒\n", cpu_time_used); // 输出排序时间（可调整）


    // 递归合并排序运行时间统计和排序元素个数统计比较  
    start = clock(); // 记录开始时间（可调整）  
    mergeSort(arr, 0, n - 1); // 递归合并排序（可调整）  
    end = clock(); // 记录结束时间（可调整）  
    cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC; // 计算CPU时间差（可调整）  
    //printf("排序元素个数：%d\n", n); // 输出排序元素个数（可调整）  
    printf("合并排序时间：%.6f秒\n", cpu_time_used); // 输出排序时间（可调整）  

    return 0;
}