#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<stdbool.h>
#include<time.h>
#include<math.h>
typedef struct node {
int data;
char sort_name[50];
}compare;
compare compare_num[8];//存储排序名称和排序的趟数
void swap(int* a, int* b) {
int t = *a;
*a = *b;
*b = t;
}
void bubble_sort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
swap(&arr[j], &arr[j + 1]);
}
}
compare_num[0].data++;
}
}
void insrt_sort(int arr[], int n) {
for (int i = 1; i < n; i++) {
int key = arr[i];//待排序的那一个元素位置相当于空出来了
int j = i - 1;//从排好序的最后一个开始比较
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
compare_num[1].data++;
}
}
int pivot_index(int arr[], int left, int right) {
int pivot = arr[left];
int i = left + 1;
int j = right;
while (i <= j) {//即使i和j的停止条件是相悖的也要写=，因为只有两个元素的时候i和j相等，仍然需要排序
while (arr[i] <= pivot && i <= right) {//找打比基准元素大的就停下来（需要写<=，来避免重复元素导致的无限循环）
i++;
}
while (arr[j] >= pivot && j >= left + 1) {//找到比基准元素小的就停下来
j--;
}
if (i < j) {//当i和j交叉时不要交换
swap(&arr[i], &arr[j]);
}
}
swap(&arr[left], &arr[j]);//j必然指向最后一个小于pivot的元素，前面的if语句会确保
compare_num[2].data++;
return j;
}
void quick_sort(int arr[], int left, int right) {
if (right - left <= 0) return;//只有一个元素的时候不需要排序直接返回;
int pivot = pivot_index(arr, left, right);
quick_sort(arr, left, pivot - 1);
quick_sort(arr, pivot + 1, right);
}
void selection_sort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
int min_index = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[min_index]) {
min_index = j;
}
}
swap(&arr[i], &arr[min_index]);
compare_num[3].data++;
}
}
void heapify(int arr[], int n, int i) {
int largest_index = i;
int left_index = i * 2 + 1;
int right_index = i * 2 + 2;
if (arr[left_index] > arr[largest_index] && left_index < n) {
largest_index = left_index;
}
if (arr[right_index] > arr[largest_index] && right_index < n) {
largest_index = right_index;
}
if (largest_index != i) {
swap(&arr[i], &arr[largest_index]);
heapify(arr, n, largest_index);
}
}
void heap_sort(int arr[], int n) {
for (int i = n / 2 - 1; i >= 0; i--) {//n/2-1是最后一个非叶子节点，因为叶子节点没有子节点，不需要heapify
heapify(arr, n, i);
}
for (int i = n - 1; i >= 0; i--) {
swap(&arr[0], &arr[i]);
heapify(arr, i, 0);
compare_num[4].data++;
}
}
void merge(int arr[], int l, int m, int r) {
int n1 = m - l + 1;
int n2 = r - m;
int i, j, k;
int* L = (int*)malloc(sizeof(int) * n1);
int* R = (int*)malloc(sizeof(int) * 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;//k一定要从l开始，不是从0开始，如果从0开始会导致递归合并的时候覆盖错误
while (i < n1 && j < n2) {
if (L[i] < R[j]) {
arr[k++] = L[i++];
}
else {
arr[k++] = R[j++];
}
}
while (i < n1) {
arr[k++] = L[i++];
}
while (j < n2) {
arr[k++] = R[j++];
}
compare_num[5].data++;
}
void merge_sort(int arr[], int l, int r) {
if (r - l <= 0) return;//当只有一个元素的时候则返回，不需要合并
int mid = (l + r) / 2;
merge_sort(arr, l, mid);
merge_sort(arr, mid + 1, r);
merge(arr, l, mid, r);
}
int get_max(int arr[], int n) {
int max = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] > max) max = arr[i];
}
return max;
}
void radix_sort(int arr[], int l, int r) {
int max_val = get_max(arr, r - l + 1);
int count = 0;
while (max_val != 0) {
max_val /= 10;
count++;
}
int** buckets = (int**)malloc(sizeof(int*) * 10);//根据位数数字0-9，创建10个桶
int* buckets_size = (int*)malloc(sizeof(int) * 10);//记录每个桶的元素个数来方便赋值到原数组进行排序
for (int i = 0; i < 10; i++) {
buckets[i] = (int*)malloc(sizeof(int) * (r - l + 1));
buckets_size[i] = 0;
}
for (int i = 0; i < count; i++) {
for (int j = l; j <= r; j++) {
int temp = arr[j];
temp = temp / (int)pow(10, i);
int digit = temp % 10;
buckets[digit][buckets_size[digit]++] = arr[j];
}
int index = l;
for (int k = 0; k < 10; k++) {
for (int m = 0; m < buckets_size[k]; m++) {//根据每个桶的元素个数来进行赋值
arr[index++] = buckets[k][m];
}
buckets_size[k] = 0;//只需要情况每个桶的元素个数，不需要清空桶内元素
}
compare_num[6].data++;
}
}
void shell_sort(int arr[], int n) {
int gap;
for (gap = n / 2; gap > 0; gap /= 2) {
for (int i = gap; i < n; i++) {//i从gap开始，从第一组开始（插入排序假定第一个数字有序）
int key = arr[i];
int j = i - gap;
while (j >= 0 && arr[j] > key) {
arr[j + gap] = arr[j];
j -= gap;//保证了每一个数组都和它那一组的数组进行插入排序，即间隔为gap
}
arr[j + gap] = key;
}
compare_num[7].data++;
}
}//希尔排序
void print_arr(int arr[], int l, int r) {
for (int i = l; i <= r; i++) {
printf("%d ", arr[i]);
}
}
void copy_arr(int arr[], int temp[], int n) {
for (int i = 0; i < n; i++) {
temp[i] = arr[i];
}
}
int compare_arrays(int arr1[], int arr2[], int n) {
for (int i = 0; i < n; i++) {
if (arr1[i] != arr2[i]) {
printf("排序错误\n\n");
return 0;
}
}
printf("排序正确\n\n");
return 1;
}
int main() {
int n = 10;//排序的元素数量
int counts = 5;//测试的回数
srand(time(NULL));
int** test_arr = (int**)malloc(sizeof(int*) * 8);
for (int i = 0; i < 8; i++) {
test_arr[i] = (int*)malloc(sizeof(int) * n);
}//初始化测试数组,,选项1中每一次测试前进行了重置
int* arr = (int*)malloc(sizeof(int) * n);//初始被测试数组,选项1中每一次测试前进行了初始化
double time[8];//排序时间数组，选项1中每一次测试前进行了初始化
double start_time = 0;//排序开始时间
double end_time = 0;//排序结束时间
int total_compare_num[8];//五次排序的比较次数总和数组
int average_compare_num[8];//平均比较次数数组
double total_time[8];//五次排序的时间总和数组
double average_time[8];//平均时间数组
for (int i = 0; i < 8; i++) {
total_compare_num[i] = 0;//初始化比较次数为0
average_compare_num[i] = 0;//初始化平均比较次数为0
total_time[i] = 0;//初始化总时间为0
average_time[i] = 0;//初始化平均时间为0
}
int** every_compare_num;//每一次测试的每一个排序算法的趟数数组
every_compare_num = (int**)malloc(sizeof(int*) * counts);
double** every_time_num;//每一次测试的每一个排序算法的时间数组
every_time_num = (double**)malloc(sizeof(double*) * counts);
for (int i = 0; i < counts; i++) {
every_compare_num[i] = (int*)malloc(sizeof(int) * 8);
every_time_num[i] = (double*)malloc(sizeof(double) * 8);
}
//初始化compare_num结构体数组
for (int i = 0; i < 8; i++) {
compare_num[i].data = 0;//初始化比较次数为0
}
strcpy(compare_num[0].sort_name, "冒泡排序");
strcpy(compare_num[1].sort_name, "插入排序");
strcpy(compare_num[2].sort_name, "快速排序");
strcpy(compare_num[3].sort_name, "选择排序");
strcpy(compare_num[4].sort_name, "堆排序");
strcpy(compare_num[5].sort_name, "归并排序");
strcpy(compare_num[6].sort_name, "基数排序");
strcpy(compare_num[7].sort_name, "希尔排序");
int choice;
int flag = 0;
do {
printf("\n\n排序算法测试系统\n\n");
printf("【1】调用八种排序算法进行排序\n");
printf("【2】获取每一轮测试的八种排序算法的排序次数和时间\n");
printf("【3】获取八种排序算法的平均排序次数和时间\n");
printf("【0】退出系统\n");
printf("请输入选项：");
scanf("%d", &choice);
printf("\n");
if (choice == 1) {
flag = 1;
for (int count = 0; count < counts; count++) {
for (int i = 0; i < 8; i++) {
time[i] = 0;
}//重置时间数组，防止影响下一次排序的时间计算结果
for (int i = 0; i < 8; i++) {
compare_num[i].data = 0;
}//重置比较次数为0
for (int i = 0; i < 8; i++) {
for (int j = 0; j < n; j++) {
test_arr[i][j] = 0;
}
}//重置测试数组，防止影响下一次排序的结果
for (int i = 0; i < n; i++) {
arr[i] = rand();
}//初始化原始待排序数组
for (int i = 0; i < 8; i++) {
copy_arr(arr, test_arr[i], n);
}//初始化测试数组，防止影响下一次排序的结果
printf("冒泡排序：\n");
start_time = clock();
bubble_sort(test_arr[0], n);
end_time = clock();
time[0] = (end_time - start_time) / CLOCKS_PER_SEC;
print_arr(test_arr[0], 0, n - 1); printf("\n");
if (compare_arrays(test_arr[0], test_arr[0], n) == 0) {
system("pause");
return 0;//如果排序错误，则停止程序
}
printf("插入排序：\n");
start_time = clock();
insrt_sort(test_arr[1], n);
end_time = clock();
time[1] = (end_time - start_time) / CLOCKS_PER_SEC;
print_arr(test_arr[1], 0, n - 1); printf("\n");
if (compare_arrays(test_arr[1], test_arr[0], n) == 0) {
system("pause");
return 0;//如果排序错误，则停止程序
}
printf("快速排序：\n");
start_time = clock();
quick_sort(test_arr[2], 0, n - 1);
end_time = clock();
time[2] = (end_time - start_time) / CLOCKS_PER_SEC;
print_arr(test_arr[2], 0, n - 1); printf("\n");
if (compare_arrays(test_arr[2], test_arr[0], n) == 0) {
system("pause");
return 0;//如果排序错误，则停止程序
}
printf("选择排序：\n");
start_time = clock();
selection_sort(test_arr[3], n);//排序
end_time = clock();
time[3] = (end_time - start_time) / CLOCKS_PER_SEC;
print_arr(test_arr[3], 0, n - 1); printf("\n");//输出排序后的结果
if (compare_arrays(test_arr[3], test_arr[0], n) == 0) {
system("pause");
return 0;//如果排序错误，则停止程序
}
printf("堆排序：\n");
start_time = clock();
heap_sort(test_arr[4], n);
end_time = clock();
time[4] = (end_time - start_time) / CLOCKS_PER_SEC;
print_arr(test_arr[4], 0, n - 1); printf("\n");
if (compare_arrays(test_arr[4], test_arr[0], n) == 0) {
system("pause");
return 0;//如果排序错误，则停止程序
}
printf("归并排序：\n");
start_time = clock();
merge_sort(test_arr[5], 0, n - 1);
end_time = clock();
time[5] = (end_time - start_time) / CLOCKS_PER_SEC;
print_arr(test_arr[5], 0, n - 1); printf("\n");
if (compare_arrays(test_arr[5], test_arr[0], n) == 0) {
system("pause");
return 0;//如果排序错误，则停止程序
}
printf("基数排序：\n");
start_time = clock();
radix_sort(test_arr[6], 0, n - 1);
end_time = clock();
time[6] = (end_time - start_time) / CLOCKS_PER_SEC;
print_arr(test_arr[6], 0, n - 1); printf("\n");
if (compare_arrays(test_arr[6], test_arr[0], n) == 0) {
system("pause");
return 0;//如果排序错误，则停止程序
}
printf("希尔排序：\n");
start_time = clock();
shell_sort(test_arr[7], n);
end_time = clock();
time[7] = (end_time - start_time) / CLOCKS_PER_SEC;
print_arr(test_arr[7], 0, n - 1); printf("\n");
if (compare_arrays(test_arr[7], test_arr[0], n) == 0) {
system("pause");
return 0;//如果排序错误，则停止程序
}
for (int i = 0; i < 8; i++) {
total_time[i] += time[i];
total_compare_num[i] += compare_num[i].data;
}//统计每种排序算法的总时间、总比较次数
printf("\n\n");
for (int i = 0; i < 8; i++) {
printf("%s：%d趟 用时：%.2lf微秒\n", compare_num[i].sort_name, compare_num[i].data, time[i] * 1000000);
every_compare_num[count][i] = compare_num[i].data;//存储每一次测试的每一个排序算法排序次数
every_time_num[count][i] = time[i] * 1000000;//存储每一次测试的每一个排序算法时间
}
}
}
if (choice == 2) {
if (flag == 0) {
printf("请先进行排序测试！\n\n\n");
continue;
}
for (int i = 0; i < counts; i++) {
printf("第%d次测试结果：\n", i + 1);
for (int j = 0; j < 8; j++) {
printf("%s：%d趟 用时：%.2lf微秒\n", compare_num[j].sort_name, every_compare_num[i][j], every_time_num[i][j]);
}
printf("\n\n\n");
}
}
if (choice == 3) {
if (flag == 0) {
printf("请先进行排序测试！\n\n\n");
continue;
}
for (int i = 0; i < 8; i++) {
average_time[i] = total_time[i] / counts * 1.0;
average_compare_num[i] = total_compare_num[i] / counts * 1.0;
printf("%s：平均%d趟 平均用时：%.2lf微秒\n", compare_num[i].sort_name, average_compare_num[i], average_time[i] * 1000000);
}
}
if (choice == 0) {
printf("感谢使用！\n");
return 0;
}
} while (choice != 0);
return 0;
}
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<stdbool.h>
#include<time.h>
#include<math.h>
typedef struct node {
int data;
char sort_name[50];
}compare;
compare compare_num[8];//存储排序名称和排序的趟数
void swap(int* a, int* b) {
int t = *a;
*a = *b;
*b = t;
}
int is_sorted(int arr[], int l, int r) {
for (int i = l; i <= r - 1; i++) {
if (arr[i] > arr[i + 1]) {
return 0; // 如果存在逆序对，则未排好序
}
}
return 1; // 如果不存在逆序对，则已排好序
}
void bubble_sort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
swap(&arr[j], &arr[j + 1]);
compare_num[0].data++;
if (is_sorted(arr, 0, n - 1)) {
return;
}
}
}
}
}
void insrt_sort(int arr[], int n) {
for (int i = 1; i < n; i++) {
int key = arr[i];//待排序的那一个元素位置相当于空出来了
int j = i - 1;//从排好序的最后一个开始比较
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
compare_num[1].data++;
if (is_sorted(arr, 0,n-1)) {
return;
}
}
}
int pivot_index(int arr[], int left, int right) {
int pivot = arr[left];
int i = left + 1;
int j = right;
while (i <= j) {//即使i和j的停止条件是相悖的也要写=，因为只有两个元素的时候i和j相等，仍然需要排序
while (arr[i] <= pivot && i <= right) {//找打比基准元素大的就停下来（需要写<=，来避免重复元素导致的无限循环）
i++;
}
while (arr[j] >= pivot && j >= left + 1) {//找到比基准元素小的就停下来
j--;
}
if (i < j) {//当i和j交叉时不要交换
swap(&arr[i], &arr[j]);
}
}
swap(&arr[left], &arr[j]);//j必然指向最后一个小于pivot的元素，前面的if语句会确保
return j;
}
void quick_sort(int arr[], int left, int right) {
compare_num[2].data++;
if (right - left <= 0) return;//只有一个元素的时候不需要排序直接返回;
int pivot = pivot_index(arr, left, right);
quick_sort(arr, left, pivot - 1);
quick_sort(arr, pivot + 1, right);
}
void selection_sort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
int min_index = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[min_index]) {
min_index = j;
}
}
swap(&arr[i], &arr[min_index]);
compare_num[3].data++;
if (is_sorted(arr, 0,n-1)) {
return;
}
}
}
void heapify(int arr[], int n, int i) {
int largest_index = i;
int left_index = i * 2 + 1;
int right_index = i * 2 + 2;
if (arr[left_index] > arr[largest_index] && left_index < n) {
largest_index = left_index;
}
if (arr[right_index] > arr[largest_index] && right_index < n) {
largest_index = right_index;
}
if (largest_index != i) {
swap(&arr[i], &arr[largest_index]);
heapify(arr, n, largest_index);
}
}
void heap_sort(int arr[], int n) {
for (int i = n / 2 - 1; i >= 0; i--) {//n/2-1是最后一个非叶子节点，因为叶子节点没有子节点，不需要heapify
heapify(arr, n, i);
}
for (int i = n - 1; i >= 0; i--) {
if (is_sorted(arr, 0, n - 1)) {
return;
}
swap(&arr[0], &arr[i]);
compare_num[4].data++;
heapify(arr, i, 0);
}
}
void merge(int arr[], int l, int m, int r) {
int n1 = m - l + 1;
int n2 = r - m;
int i, j, k;
int* L = (int*)malloc(sizeof(int) * n1);
int* R = (int*)malloc(sizeof(int) * 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;//k一定要从l开始，不是从0开始，如果从0开始会导致递归合并的时候覆盖错误
while (i < n1 && j < n2) {
if (L[i] < R[j]) {
arr[k++] = L[i++];
}
else {
arr[k++] = R[j++];
}
}
while (i < n1) {
arr[k++] = L[i++];
}
while (j < n2) {
arr[k++] = R[j++];
}
}
void merge_sort(int arr[], int l, int r) {
compare_num[5].data++;
if (r - l <= 0) return;//当只有一个元素的时候则返回，不需要合并
int mid = (l + r) / 2;
merge_sort(arr, l, mid);
merge_sort(arr, mid + 1, r);
merge(arr, l, mid, r);
}
int get_max(int arr[], int n) {
int max = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] > max) max = arr[i];
}
return max;
}
void radix_sort(int arr[], int l, int r) {
int max_val = get_max(arr, r - l + 1);
int count = 0;
while (max_val != 0) {
max_val /= 10;
count++;
}
int** buckets = (int**)malloc(sizeof(int*) * 10);//根据位数数字0-9，创建10个桶
int* buckets_size = (int*)malloc(sizeof(int) * 10);//记录每个桶的元素个数来方便赋值到原数组进行排序
for (int i = 0; i < 10; i++) {
buckets[i] = (int*)malloc(sizeof(int) * (r - l + 1));
buckets_size[i] = 0;
}
for (int i = 0; i < count; i++) {
for (int j = l; j <= r; j++) {
int temp = arr[j];
temp = temp / (int)pow(10, i);
int digit = temp % 10;
buckets[digit][buckets_size[digit]++] = arr[j];
}
int index = l;
for (int k = 0; k < 10; k++) {
for (int m = 0; m < buckets_size[k]; m++) {//根据每个桶的元素个数来进行赋值
arr[index++] = buckets[k][m];
}
buckets_size[k] = 0;//只需要情况每个桶的元素个数，不需要清空桶内元素
}
if (is_sorted(arr, l,r)) {
return;
}
compare_num[6].data++;
}
}
void shell_sort(int arr[], int n) {
int gap;
for (gap = n / 2; gap > 0; gap /= 2) {
for (int i = gap; i < n; i++) {//i从gap开始，从第一组开始（插入排序假定第一个数字有序）
int key = arr[i];
int j = i - gap;
while (j >= 0 && arr[j] > key) {
arr[j + gap] = arr[j];
j -= gap;//保证了每一个数组都和它那一组的数组进行插入排序，即间隔为gap
}
arr[j + gap] = key;//插入
compare_num[7].data++;
if (is_sorted(arr, 0,n-1)) {
return;
}
}
}
}//希尔排序
void print_arr(int arr[], int l, int r) {
for (int i = l; i <= r; i++) {
printf("%d ", arr[i]);
}
}
void copy_arr(int arr[], int temp[], int n) {
for (int i = 0; i < n; i++) {
temp[i] = arr[i];
}
}
int compare_arrays(int arr1[], int arr2[], int n) {
for (int i = 0; i < n; i++) {
if (arr1[i] != arr2[i]) {
printf("排序错误\n\n");
return 0;
}
}
printf("排序正确\n\n");
return 1;
}
int main() {
int n = 10000;//排序的元素数量
int counts = 5;//测试的回数
srand(time(NULL));
int** test_arr = (int**)malloc(sizeof(int*) * 8);
for (int i = 0; i < 8; i++) {
test_arr[i] = (int*)malloc(sizeof(int) * n);
}//初始化测试数组,,选项1中每一次测试前进行了重置
int* arr = (int*)malloc(sizeof(int) * n);//初始被测试数组,选项1中每一次测试前进行了初始化
double time[8];//排序时间数组，选项1中每一次测试前进行了初始化
double start_time = 0;//排序开始时间
double end_time = 0;//排序结束时间
int total_compare_num[8];//五次排序的比较次数总和数组
int average_compare_num[8];//平均比较次数数组
double total_time[8];//五次排序的时间总和数组
double average_time[8];//平均时间数组
for (int i = 0; i < 8; i++) {
total_compare_num[i] = 0;//初始化比较次数为0
average_compare_num[i] = 0;//初始化平均比较次数为0
total_time[i] = 0;//初始化总时间为0
average_time[i] = 0;//初始化平均时间为0
}
int** every_compare_num;//每一次测试的每一个排序算法的趟数数组
every_compare_num = (int**)malloc(sizeof(int*) * counts);
double** every_time_num;//每一次测试的每一个排序算法的时间数组
every_time_num = (double**)malloc(sizeof(double*) * counts);
for (int i = 0; i < counts; i++) {
every_compare_num[i] = (int*)malloc(sizeof(int) * 8);
every_time_num[i] = (double*)malloc(sizeof(double) * 8);
}
//初始化compare_num结构体数组
for (int i = 0; i < 8; i++) {
compare_num[i].data = 0;//初始化比较次数为0
}
strcpy(compare_num[0].sort_name, "冒泡排序：交换次数");
strcpy(compare_num[1].sort_name, "插入排序：插入次数");
strcpy(compare_num[2].sort_name, "快速排序：递归排序次数");
strcpy(compare_num[3].sort_name, "选择排序：交换次数");
strcpy(compare_num[4].sort_name, "堆排序： 交换次数");
strcpy(compare_num[5].sort_name, "归并排序：递归排序次数");
strcpy(compare_num[6].sort_name, "基数排序：分桶排序次数");
strcpy(compare_num[7].sort_name, "希尔排序：插入次数");
int choice;
int flag = 0;
do {
printf("\n\n排序算法测试系统\n\n");
printf("【1】调用八种排序算法进行排序\n");
printf("【2】获取每一轮测试的八种排序算法的排序次数和时间\n");
printf("【3】获取八种排序算法的平均排序次数和时间\n");
printf("【0】退出系统\n");
printf("请输入选项：");
scanf("%d", &choice);
printf("\n");
if (choice == 1) {
flag = 1;
for (int count = 0; count < counts; count++) {
for (int i = 0; i < 8; i++) {
time[i] = 0;
}//重置时间数组，防止影响下一次排序的时间计算结果
for (int i = 0; i < 8; i++) {
compare_num[i].data = 0;
}//重置比较次数为0
for (int i = 0; i < 8; i++) {
for (int j = 0; j < n; j++) {
test_arr[i][j] = 0;
}
}//重置测试数组，防止影响下一次排序的结果
for (int i = 0; i < n; i++) {
arr[i] = rand();
}//初始化原始待排序数组
print_arr(arr, 0, n - 1); printf("\n\n\n");
for (int i = 0; i < 8; i++) {
copy_arr(arr, test_arr[i], n);
}//初始化测试数组，防止影响下一次排序的结果
printf("冒泡排序：\n");
start_time = clock();
bubble_sort(test_arr[0], n);
end_time = clock();
time[0] = (end_time - start_time) / CLOCKS_PER_SEC;
print_arr(test_arr[0], 0, n - 1); printf("\n");
printf("%d\n", is_sorted(test_arr[0], 0, n - 1));
if (!is_sorted(test_arr[0] , 0, n-1)) {
system("pause");
return 0;//如果排序错误，则停止程序
}
printf("插入排序：\n");
start_time = clock();
insrt_sort(test_arr[1], n);
end_time = clock();
time[1] = (end_time - start_time) / CLOCKS_PER_SEC;
print_arr(test_arr[1], 0, n - 1); printf("\n");
if (!is_sorted(test_arr[1], 0, n - 1)) {
system("pause");
return 0;//如果排序错误，则停止程序
}
printf("快速排序：\n");
start_time = clock();
quick_sort(test_arr[2], 0, n - 1);
end_time = clock();
time[2] = (end_time - start_time) / CLOCKS_PER_SEC;
print_arr(test_arr[2], 0, n - 1); printf("\n");
if (!is_sorted(test_arr[2], 0, n - 1)) {
system("pause");
return 0;//如果排序错误，则停止程序
}
printf("选择排序：\n");
start_time = clock();
selection_sort(test_arr[3], n);//排序
end_time = clock();
time[3] = (end_time - start_time) / CLOCKS_PER_SEC;
print_arr(test_arr[3], 0, n - 1); printf("\n");//输出排序后的结果
if (!is_sorted(test_arr[3], 0, n - 1)) {
system("pause");
return 0;//如果排序错误，则停止程序
}
printf("堆排序：\n");
start_time = clock();
heap_sort(test_arr[4], n);
end_time = clock();
time[4] = (end_time - start_time) / CLOCKS_PER_SEC;
print_arr(test_arr[4], 0, n - 1); printf("\n");
if (!is_sorted(test_arr[4], 0, n - 1)) {
system("pause");
return 0;//如果排序错误，则停止程序
}
printf("归并排序：\n");
start_time = clock();
merge_sort(test_arr[5], 0, n - 1);
end_time = clock();
time[5] = (end_time - start_time) / CLOCKS_PER_SEC;
print_arr(test_arr[5], 0, n - 1); printf("\n");
if (!is_sorted(test_arr[5], 0, n - 1)) {
system("pause");
return 0;//如果排序错误，则停止程序
}
printf("基数排序：\n");
start_time = clock();
radix_sort(test_arr[6], 0, n - 1);
end_time = clock();
time[6] = (end_time - start_time) / CLOCKS_PER_SEC;
print_arr(test_arr[6], 0, n - 1); printf("\n");
if (!is_sorted(test_arr[6], 0, n - 1)) {
system("pause");
return 0;//如果排序错误，则停止程序
}
printf("希尔排序：\n");
start_time = clock();
shell_sort(test_arr[7], n);
end_time = clock();
time[7] = (end_time - start_time) / CLOCKS_PER_SEC;
print_arr(test_arr[7], 0, n - 1); printf("\n");
if (!is_sorted(test_arr[7], 0, n - 1)) {
system("pause");
return 0;//如果排序错误，则停止程序
}
for (int i = 0; i < 8; i++) {
total_time[i] += time[i];
total_compare_num[i] += compare_num[i].data;
}//统计每种排序算法的总时间、总比较次数
printf("\n\n");
for (int i = 0; i < 8; i++) {
printf("%s%d 用时：%.3lfms\n", compare_num[i].sort_name, compare_num[i].data, time[i] * 1000.0);
every_compare_num[count][i] = compare_num[i].data;//存储每一次测试的每一个排序算法排序次数
every_time_num[count][i] = time[i] * 1000.0;//存储每一次测试的每一个排序算法时间
}
}
}
if (choice == 2) {
if (flag == 0) {
printf("请先进行排序测试！\n\n\n");
continue;
}
for (int i = 0; i < counts; i++) {
printf("排序元素个数为%d\n", n);
printf("第%d次测试结果：\n", i + 1);
for (int j = 0; j < 8; j++) {
printf("%s%d 用时：%.3lfms\n", compare_num[j].sort_name, every_compare_num[i][j], every_time_num[i][j]);
}
printf("\n\n\n");
}
}
if (choice == 3) {
if (flag == 0) {
printf("请先进行排序测试！\n\n\n");
continue;
}
printf("排序元素个数为%d 测试次数为%d\n", n, counts);
for (int i = 0; i < 8; i++) {
average_time[i] = total_time[i] / counts * 1.0;
average_compare_num[i] = total_compare_num[i] / counts * 1.0;
printf("%s%d 平均用时：%.3lfms\n", compare_num[i].sort_name, average_compare_num[i], average_time[i] * 1000.0);
}
}
if (choice == 0) {
printf("感谢使用！\n");
return 0;
}
} while (choice != 0);
return 0;
}
8万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
