排序算法复杂度的度量

一、实验名称：排序算法复杂度的度量

二、题目分析：1.掌握选择排序、冒泡排序、归并排序、快速排序、插入排序的算法原理。2.掌握不同排序算法时间效率的经验分析方法，验证理论分析与经验分析的一致性。

三、算法构造：

1、选择排序：

选出一个最值将其与第一个数进行交换，len个数是len-1趟；

2、冒泡排序：

每趟比价中进行len-1次的两两比较，第j次比较中进行len-j次的比较，每趟结束后，将最值沉底；

3、合并排序：

将待排序序列分为两部分，依次对分得的两个部分再次使用归并排序，之后再对其进行合并；

4、快速排序：

数组中取出第一个数（默认）作为基准数。将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。 再对左右区间重复上述步骤，直到各区间只有一个数；

5、插入排序：

将数组的第一个数记为有序序列，其后len-1个数组成无序列，将无序序列中的数依次插入有序序列。

算法实现

/*
 * time: 2020年6月11日
 * author: 薛凯旋
 * description: 排序算法在不同数据规模下排序所消耗的时间
 * compiler: codeblocks
 */
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include<Windows.h>
int begintime = 0;
int endtime = 0;
int arr1[100000] = { 0 };
void swap(int* a, int* b){
 int c = 0;
 c = *a;
 *a = *b;
 *b = c;
}
//选择排序;
void select_sort(int arr[], int len){
 int min = 0;
 for (int i = 0; i < len - 1; i++){
  min = i;
  for (int j = i + 1; j < len; j++){
   if (arr[min] > arr[j]){
    min = j;
   }
  }
  if (min != i){
   swap(&arr[min], &arr[i]);
  }
 }
}
//冒泡排序;
void maopao_sort(int arr[], int len){
 for (int i = 0; i < len - 1; i++){
  for (int j = 0; j < len - i; j++){
   if (arr[j] > arr[j + 1]){
    swap(&arr[j], &arr[j + 1]);
   }
  }
 }
}
void merge(int arr[], int low, int mid, int high){
 int i, k;
 int *tmp = (int *)malloc((high - low + 1)*sizeof(int));
 int left_low = low;
 int left_high = mid;
 int right_low = mid + 1;
 int right_high = high;
 for (k = 0; left_low <= left_high && right_low <= right_high; k++){
  if (arr[left_low] <= arr[right_low]){
   tmp[k] = arr[left_low++];
  }
  else{
   tmp[k] = arr[right_low++];
  }
 }
 if (left_low <= left_high){
  for (i = left_low; i <= left_high; i++){
   tmp[k++] = arr[i];
  }
 }
 if (right_low <= right_high){
  for (i = right_low; i <= right_high; i++){
   tmp[k++] = arr[i];
  }
 }
 for (i = 0; i < high - low + 1; i++){
  arr[low + i] = tmp[i];
 }
 free(tmp);
}
//合并排序;
void merge_sort(int arr[], unsigned int first, unsigned int last){
 int mid = 0;
 if (first < last){
  mid = first/2 + last/2;
  merge_sort(arr, first, mid);
  merge_sort(arr, mid + 1, last);
  merge(arr, first, mid, last);
 }
}
//快速排序的作用;
void quick_sort(int arr[], int begin, int end){
 int i = begin;
 int j = end;
 int x = arr[begin];
 if (begin < end){
  while (begin < end){
   while (begin<end && arr[end]>x){
    end--;
   }
   if (begin < end){
    arr[begin++] = arr[end];
   }
   while (begin < end && arr[begin] < x){
    begin++;
   }
   if (begin < end){
    arr[end--] = arr[begin];
   }
  }
  arr[begin] = x;
  quick_sort(arr, i, end - 1);//用递归将选取的标准数左右两边都进行排序;
  quick_sort(arr, begin + 1, j);
 }
}
//插入排序;
void charu_sort(int arr[], int len){
 int t = 0;
 int j = 0;
 for (int i = 1; i < len; i++){
  t = arr[i];
  for (j = i - 1; j >= 0 && t < arr[j]; j--){
   arr[j + 1] = arr[j];
  }
  arr[j + 1] = t;
 }
}
void select_time(int len){
 int sum = 0;
 int n = 0;
 printf("20组样本(ms):>");
 while (n < 20){
  for (int i = 0; i < len; i++){
   arr1[i] = rand();
  }
  begintime = clock();
  select_sort(arr1,len);
  endtime = clock();
  sum = sum + endtime - begintime;
  printf(" %d ", endtime - begintime);
  if (n == 19){
   printf("\n");
  }
  n++;
 }
 printf("排序所花平均时间:> %d \n", (sum / 20));
}
//计算20组样本冒泡排序所用的时间
void maopao_time(int len){
 int sum = 0;
 int n = 0;
 printf("20组样本(ms):>");
 while (n < 20){
  for (int i = 0; i < len; i++){
   arr1[i] = rand();
  }
  begintime = clock();
  maopao_sort(arr1, len);
  endtime = clock();
  sum = sum + endtime - begintime;
  printf(" %d ", endtime - begintime);
  if (n == 19){
   printf("\n");
  }
  n++;
 }
 printf("排序所花平均时间:> %d \n", (sum / 20));
}
void merge_time(int len){
 int sum = 0;
 int n = 0;
 printf("20组样本(ms):>");
 while (n < 20){
  for (int i = 0; i < len; i++){
   arr1[i] = rand();
  }
  begintime = clock();
  merge_sort(arr1, 0, len - 1);
  endtime = clock();
  sum = sum + endtime - begintime;
  printf(" %d ", endtime - begintime);
  if (n == 19){
   printf("\n");
  }
  n++;
 }
 printf("排序所花平均时间:> %d \n", (sum / 20));
}
void quick_time(int len){
 int sum = 0;
 int n = 0;//样本;
 printf("20组样本(ms):>");
 while (n < 20){
  for (int i = 0; i < len; i++){
   arr1[i] = rand();
  }
  begintime = clock();
  quick_sort(arr1, 0, len - 1);
  endtime = clock();
  sum = sum + endtime - begintime;
  printf(" %d ", endtime - begintime);
  if (n == 19){
   printf("\n");
  }
  n++;
 }
 printf("排序所花平均时间:> %d \n", (sum / 20));
}
//计算20组样本插入排序所用的时间
void charu_time(int len){
 int sum = 0;
 int n = 0;
 printf("20组样本(ms):>");
 while (n < 20){
  for (int i = 0; i < len; i++){
   arr1[i] = rand();
  }
  begintime = clock();
  charu_sort(arr1, len);
  endtime = clock();
  sum = sum + endtime - begintime;
  printf(" %d ", endtime - begintime);
  if (n == 19){
   printf("\n");
  }
  n++;
 }
 printf("排序所花平均时间:> %d \n", (sum / 20));
}
int main(){
 int input = 0;
 int len = 10;
 while (input<1||input>5){
  printf("1.选择排序  2.冒泡排序  3.合并排序  4.快速排序  5.插入排序\n");
  printf("请输入您选择的算法：");
  scanf("%d", &input);
  switch (input){
  case 1:
   while (len <= 100000){
    printf("数组长度为%d时：\n",len);
    select_time(len);
    if (len != 100000){
     printf("----------------------------------------------------------------------------------\n");
    }
    len = len * 10;
   }
   break;
  case 2:
   while (len <= 100000){
    printf("数组长度为%d时：\n", len);
    maopao_time(len);
    if (len != 100000){
     printf("----------------------------------------------------------------------------------\n");
    }
    len = len * 10;
   }
   break;
  case 3:
   while (len <= 100000){
    printf("数组长度为%d时：\n", len);
    merge_time(len);
    if (len != 100000){
     printf("----------------------------------------------------------------------------------\n");
    }
    len = len * 10;
   }
   break;
  case 4:
   while (len <= 100000){
    printf("数组长度为%d时：\n", len);
    quick_time(len);
    if (len != 100000){
     printf("----------------------------------------------------------------------------------\n");
    }
    len = len * 10;
   }
   break;
  case 5:
   while (len <= 100000){
    printf("数组长度为%d时：\n", len);
    charu_time(len);
    if (len != 100000){
     printf("----------------------------------------------------------------------------------\n");
    }
    len = len * 10;
   }
   break;
  default:
   printf("选择错误，请重新输入！");
  }
 }
 system("pause");
 return 0;
}

五、调试、测试及运行结果

1.调试

2.测试及运行结果

六、经验归纳

快速排序最快的排序算法，缺点是不稳定；归并排序第二块的算法，缺点是辅存很大；快速排序最优的情况下空间复杂度为：O(logn) ；每一次都平分数组的情况最差的情况下空间复杂度为：O(n )。