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

非递归插入排序代码：

void insertionSort1(int A[], int n) {
    for (int i = 1; i < n; i++) {
        int temp = A[i];
        int j = i - 1;
        while (j >= 0 && A[j] > temp) {
            A[j + 1] = A[j];
            j = j - 1;
        }
        A[j + 1] = temp;
    }
}

非递归插入排序结果：

递归插入排序代码：

void insertionSort2(int A[], int n) {
    for (int i = 1; i < n; i++) {
        if (i > 1) {
            insertionSort2(A, i - 1); // 递归调用，对 A[1..i-1] 进行排序
        }
        int x = A[i];
        int j = i - 1;
        while (j >= 0 && A[j] > x) {
            A[j + 1] = A[j];
            j = j - 1;
        }
        A[j + 1] = x;
    }
}

递归排序结果：

非递归插入排序和递归插入排序n（0<n<5000）个数时间效率对比:

实验结果：由运行结果可视化分析可以得出，随着元素个数n的增加，两种排序算法的运行时间均呈指数级增长。

原因分析：

1)非递归排序：

一般情况下，非递归插入排序的时间复杂度为O(n^2)，最坏情况下的时间复杂度是O(n^2)，平均时间复杂度也是O(n^2)。

2)递归插入排序：

在最坏情况下同样为O(n^2)，平均时间复杂度也是O(n^2)。实际应用中，非递归插入排序算法可能略微快于递归插入排序算法，因为递归调用会引入额外的开销，包括函数调用和堆栈空间。

总的来说，对于插入排序这类算法，递归和非递归的时间效率差别不大。

源码：

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

// 非递归实现插入排序
void insertionSort1(int A[], int n) {
    for (int i = 1; i < n; i++) {
        int temp = A[i];
        int j = i - 1;
        while (j >= 0 && A[j] > temp) {
            A[j + 1] = A[j];
            j = j - 1;
        }
        A[j + 1] = temp;
    }
}

// 递归实现插入排序
void insertionSort2(int A[], int n) {
    if (n <= 1) {
        return;
    }
    insertionSort2(A, n - 1);
    int x = A[n - 1];
    int j = n - 2;
    while (j >= 0 && A[j] > x) {
        A[j + 1] = A[j];
        j = j - 1;
    }
    A[j + 1] = x;
}

int main() {
    int size = 1000;
    int* A = (int*)malloc(size * sizeof(int));
    // 生成随机数组A
    for (int i = 0; i < size; i++) {
        A[i] = rand();
    }

    clock_t start, end;

    // 调用非递归插入排序算法
    printf("非递归插入排序结果: ");
    for (int i = 1; i <= size; i++) {
        int* tempA = (int*)malloc(i * sizeof(int));
        for (int j = 0; j < i; j++) {
            tempA[j] = A[j];
        }
        start = clock();
        insertionSort1(tempA, i);
        end = clock();
        printf("第%d个数执行时间：%f 秒\n", i, (double)(end - start) / CLOCKS_PER_SEC);
        free(tempA);
    }

    printf("\n");

    // 调用递归插入排序算法
    printf("递归插入排序结果:\n");
    for (int i = 1; i <= size; i++) {
        int* tempA = (int*)malloc(i * sizeof(int));
        for (int j = 0; j < i; j++) {
            tempA[j] = A[j];
        }
        start = clock();
        insertionSort2(tempA, i);
        end = clock();
        printf("第%d个数执行时间：%f 秒\n", i, (double)(end - start) / CLOCKS_PER_SEC);
        free(tempA);
    }

    free(A);

    return 0;
}