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);
}

运行时间比较

时间复杂度

插入排序

合并排序

实验结果

由可视化分析可以得出，当n逐渐增大后，合并排序用时比直接插入用时少。

原因分析

直接插入排序和归并排序的效率取决于多个因素，包括数据量、数据分布、内存使用和计算机性能等。在一般情况下，归并排序的效率更高，因为它的时间复杂度为O(nlogn)，而直接插入排序的时间复杂度为O(n^2)。

但是，对于较小的数据集，直接插入排序可能会更快，因为它的常数因子较小。此外，对于特定的数据集和特定的计算机环境，两种算法的效率也可能会发生变化。因此，在选择使用哪种算法时，需要根据具体情况进行评估和测试。

问题

非递归直接插入排序（insertionSort）和递归归并排序（mergeSort）的执行时间在处理3000个随机整数时，应该都是随着元素数量的增加而增加的。然而，由于代码中，插入排序和归并排序函数处理的是同一个列表（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);
}



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); // 输出排序时间（可调整）  

    
    // 合并排序运行时间统计和排序元素个数统计比较  
    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;
}