C语言-算法分析与设计-实现插入排序的递归与非递归算法

实验内容

1. 用程序实现插入排序的递归与非递归算法
2. 分别画出程序运行时间t与元素个数n的曲线图
3. 实验中是否遇到相关问题，并分析出现该问题的原因

递归算法

void recursiveInsertionSort(int arr[], int n)
{
    if (n <= 1)
        return;
    recursiveInsertionSort(arr, n - 1);
    int key = arr[n - 1];
    int j = n - 2;

    while (j >= 0 && arr[j] > key)
    {
        arr[j + 1] = arr[j];
        j--;
    }
    arr[j + 1] = key;
}

非递归算法

void insertionSort(int arr[], int n)
{
    int i, key, j;
    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;
    }
}

递归算法耗时

非递归算法耗时

时间曲线图

递归算法

非递归算法

实验结果

        随机生成3000个数字,根据可视化分析得：递归算法进行排序与非递归算法花费时间相差不大；两者的斜率相同，说明两种算法时间复杂度相同，但是非递归算法要比递归算法快一点。

原因分析

       对于插入排序的递归和非递归实现，其时间复杂度通常都是O(n^2)，其中n是要排序的数的数量。这是因为插入排序每次只能将一个数插入到已排序的部分中，需要对所有数进行一次遍历，而每次插入都需要进行比较和移动操作，因此总的时间复杂度是O(n^2)。

       在实践中，由于递归需要额外的函数调用开销，因此非递归实现的效率通常比递归实现要高。

遇到的问题

       函数执行时间的测量，time.time()获取的是当前的系统时间，而并非程序执行的CPU时间。由于系统时间包括其他进程的时间消耗，因此可能会导致你的测量结果比实际执行时间要长。

       其次，在绘制曲线图时，对执行时间的估计方式是不准确的。i / 100 和 i / 10 这样的估计方式并不能准确地反映出程序的执行时间，因为程序的执行时间并不是简单地与输入数据的大小成线性关系。

解决方法

       解决这个问题的一种更准确的方法是使用timeit模块来测量函数的执行时间。timeit模块可以提供一个更精确的时间测量，并且可以自动地处理一些系统开销和其他进程对时间测量的影响。

源码

递归

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

void recursiveInsertionSort(int arr[], int n);
void printArray(int arr[], int n);

int main()
{
    int arr[3000];
    int n = sizeof(arr) / sizeof(arr[0]);

    // 生成3000个随机数字
    srand(time(0));
    printf("生成的随机数字：\n");
    for (int i = 0; i < n; i++)
    {
        arr[i] = rand() % 3000;  // 生成0到3000的随机数字
        printf("%d ", arr[i]);
    }
    printf("\n\n");

    clock_t start, end;
    double cpu_time_used;

    start = clock();
    recursiveInsertionSort(arr, n);
    end = clock();
    cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;

    printf("递归插入排序后的数字：\n");
    printArray(arr, n);
    printf("\n递归 插入排序 运行时间：%f 秒\n", cpu_time_used);

    return 0;
}

void recursiveInsertionSort(int arr[], int n)
{
    if (n <= 1)
        return;

    recursiveInsertionSort(arr, n - 1);

    int key = arr[n - 1];
    int j = n - 2;

    while (j >= 0 && arr[j] > key)
    {
        arr[j + 1] = arr[j];
        j--;
    }

    arr[j + 1] = key;
}

void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
}

非递归

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

void insertionSort(int arr[], int n);
void printArray(int arr[], int n);

int main()
{
    int arr[3000];
    int n = sizeof(arr) / sizeof(arr[0]);

    // 生成3000个随机数字  
    srand(time(0));
    printf("生成的随机数字：\n");
    for (int i = 0; i < n; i++)
    {
        arr[i] = rand() % 3000;  // 生成0到3000的随机数字  
        printf("%d ", arr[i]);
    }
    printf("\n\n");

    clock_t start, end;
    double cpu_time_used;

    start = clock();
    insertionSort(arr, n);
    end = clock();
    cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;

    printf("插入排序后的数字：\n");
    printArray(arr, n);
    printf("\n非递归 插入排序 运行时间：%f 秒\n", cpu_time_used);

    return 0;
}

void insertionSort(int arr[], int n)
{
    int i, key, j;
    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 printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
}