算法设计与分析基础实验报告二

1.实验内容

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

（2）阐述比较结果。

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

 2.实验过程及记录结果

1.插入排序代码：

void insertSort(int arr[], int n) {

    int i, j, temp;

    for (i = 1; i < n; i++) {

        temp = arr[i];

        for (j = i - 1; j >= 0 && arr[j] > temp; j--) {

            arr[j + 1] = arr[j];

        }

        arr[j + 1] = temp;

    }

}

2.合并排序代码：

void merge(int arr[], int left, int mid, int right) {

    int i, j, k;

    int n1 = mid - left + 1;

    int n2 = right - mid;

    int L[n1], R[n2];

    for (i = 0; i < n1; i++) {

        L[i] = arr[left + i];

    }

    for (j = 0; j < n2; j++) {

        R[j] = arr[mid + 1 + j];

    }

    i = 0;

    j = 0;

    k = left;

    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 left, int right) {

    if (left < right) {

        int mid = left + (right - left) / 2;

        mergeSort(arr, left, mid);

        mergeSort(arr, mid + 1, right);

        merge(arr, left, mid, right);

    }

}

1. 插入排序和合并排序的完整代码：

   #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 = j - 1;
           }
           arr[j + 1] = key;
       }
   }
   
   // 合并排序
   void mergeSort(int arr[], int l, int r) {
       if (l < r) {
           int m = (l + r) / 2;
           mergeSort(arr, l, m);
           mergeSort(arr, m + 1, r);
           merge(arr, l, m, r);
       }
   }
   
   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++;
       }
   }
   int main() {
       int arr[] = {12, 11, 13, 5, 6};
       int n = sizeof(arr) / sizeof(arr[0]);
       printf("请输入需要排序的个数：\n");
       scanf("&d",n);
       clock_t start1, end1;
       double cpu_time_used;  
       start1= clock();
       insertionSort(arr, n);
       end1 = clock();
       cpu_time_used = ((double) (end1 - start1)) / CLOCKS_PER_SEC;
       printf("直接插入排序结果：\n");
       for(int i=0; i<n; i++)
       printf("%d ", arr[i]);
       printf("\n直接插入排序CPU time: %f秒\n", cpu_time_used);
        double cpu_time_used2; 
       clock_t start2, end2;
       start2 = clock();
       mergeSort(arr，  l, r);
       end2 = clock();
       cpu_time_used2 = ((double) (end2 - start2)) / CLOCKS_PER_SEC;
       printf("归并排序结果：\n");
       for(int i=0; i<n; i++)
           printf("%d ", arr[i]);
       printf("\n归并排序CPU time: %f秒\n", cpu_time_used2);
       return 0;
   }

   插入排序和合并排序排序n（0<n<1000）个数时间效率对比:

 

 

结果分析

实验结果：由运行结果可视化分析可以得出，当n逐渐增大后，直接插入排序所花费的时间明显高于合并排序的时间。即当排序元素很多时，合并排序的算法时间效率明显优于直接插入排序。

原因分析：

（1）合并排序

合并排序的时间复杂度为O(nlogn)，其中n表示待排序序列的元素个数。这是由于在合并排序中，需要对元素进行多次比较和合并，每次合并都需要O(n)的时间复杂度。因此，随着待排序序列的元素个数的增加，所需时间也会按照O(nlogn)的规律增加。当n很大的时候，平均情况下，合并排序算法的比较次数小于0.25n次，因此效率也属于 θ（nlogn），并且由排序的过程来看，合并排序是稳定的，但是该算法需要牺牲额外的线性空间。

（2)直接插入排序

直接插入排序的时间复杂度为O(n^2)。这是因为在每一趟操作中，都需要进行一次比较和一次移动操作。当待排序序列的元素个数增加时，所需的比较和移动次数也会按照O(n^2)的规律增加。插入排序最好的情况下是外部循环的每次迭代中只比较一次，即队升序排列的序列进行排序，此时的时间复杂度是O(n),而最坏的情况是对一个严格递减的序列进行排序此时的时间复杂度为O(n^2)。

总结

当数据量较小时，直接插入排序的效率较高；当数据量较大时，归并排序的效率较高。