该博客介绍了简单排序算法选择器，用户可选择直接插入排序、冒泡排序、快速排序、简单选择排序对数据进行排序，还能查看每趟排序结果，且需要不同的排序方法函数。
简单排序算法选择器
由用户选择对该组数据进行排序的方法：直接插入排序、冒泡排序、快速排序、简单选择排序。并可以查看每趟排序的结果。
需要不同的排序方法函数
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<math.h>
#include<time.h>
void swap(int *a,int *b)
{
int temp =*a;
*a=*b;
*b=temp;
}
void PrintArray(int* a,int n)
{
int i=0;
for(;i<n-1;++i)
{
printf("%d",a[i]);
}
printf("%d\n",a[i]);
}
//从小到大
void InsertSort (int* a,int n)//直接插入
{
assert(a);
int i,j;
for(i=1;i<n;i++)
{
if(a[i]<a[i-1])
{
int temp=a[i];
for(j=i-1;j>=0&&a[j]>temp;j--)
{
a[j+1]=a[j];
}
a[j+1]=temp;
}
printf("第%2d趟:",i);
PrintArray(a,n);
}
}
void shellInsert(int array[],int n)// Hibbard增量 希尔排序
{
int t = (int)(log(n+1)/log(2));
//t为排序趟数，排序趟数应为log2(n+1)的整数部分
int i,dk;
for(i=1;i<=t;i++)
{
dk=(int)(pow(2,t-i+1)-1);//计算Hibbard增量
//根据当前增量进行插入排序
int k,j,temp;
for(k=dk;k<n;k++)
{
temp=array[k];
for(j=k-dk;(j>=k%dk)&&array[j]>temp;j-=dk)
//比较与记录后移 同时进行
array[j+dk]=array[j];
if(j!=k-dk)
array[j+dk]=temp;//插入
}
}
}
void ShellSort(int *a,int n)//希尔排序
{
assert(a);
int gap=n;
int i,j,k=1;
while(gap/=2)
{
for(i=gap;i<n;i++)
{
int temp=a[i];
for(j=i-gap;j>=0&&a[j]>temp;j-=gap)
{
a[j+gap]=a[j];
}
a[j+gap]=temp;
}
printf("第%2d趟：",k++);
PrintArray(a,n);
}
}
void BubbleSort(int* a, int n)//冒泡排序
{
assert(a);
int i, j = n, k = 1;
int flag = 1;
while (flag)
{
flag = 0;
for (i = 1; i < j; i++)
{
if (a[i] < a[i - 1])
{
swap(&a[i], &a[i - 1]);
flag = 1;
}
}
j--;
if (flag)
{
printf("第%02d趟：", k++);
PrintArray(a, n);
}
}
}
void SelectionSort(int* a, int n)//直接选择
{
assert(a);
int min, i, j;
for (i = 0; i < n; i++)
{
min = i;
for (j = i; j < n; j++)
{
if (a[j] < a[min])
min = j;
}
swap(&a[i], &a[min]);
printf("第%02d趟：", i+1);
PrintArray(a, n);
}
}
void QuickSort(int* a, int left, int right, int n)//快速排序
{
assert(a);
if (left < right)
{
static int k = 1;
int i = left, j = right, x = a[left];
while (i < j)
{
while (i < j && a[j] >= x) // 从右向左找第一个小于x的数
j--;
if (i < j)
a[i++] = a[j];
while (i < j && a[i] < x) // 从左向右找第一个大于等于x的数
i++;
if (i < j)
a[j--] = a[i];
}
a[i] = x;
printf("第%02d趟：", k++);
PrintArray(a, n);
QuickSort(a, left, i - 1, n);
QuickSort(a, i + 1, right, n);// 递归调用
}
}
void MergeSort(int*a, int left, int right, int* temp)//归并排序
{
if (left >= right)
return;
int mid = (left + right) / 2;//left + ((right - left) >> 1);
int begin1, begin2, end1, end2;
int i = 0;
MergeSort(a, left, mid, temp);
MergeSort(a, mid + 1, right, temp);
begin1 = left;
end1 = mid;
begin2 = mid + 1;
end2 = right;
i = left;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] > a[begin2])
{
temp[i++] = a[begin2++];
}
else
{
temp[i++] = a[begin1++];
}
}
while (begin1 <= end1)
{
temp[i++] = a[begin1++];
}
while (begin2 <= end2)
{
temp[i++] = a[begin2++];
}
//memcpy(a + left, temp + left, end1-left);
for (i--; i >= left; i--)
{
a[i] = temp[i];
}
}
void table()
{
printf("请选择对该组数据进行排序的方法:\n");
printf("1.直接插入排序\n");
printf("2.希尔排序\n");
printf("3.冒泡排序\n");
printf("4.快速排序排序\n");
printf("5.简单选择排序\n");
printf("6.归并排序\n");
printf("0.退出\n");
}
int main()
{
//int a[10] = { 9,4,3,2,5,6,1,7,0,8 };
srand((unsigned)time(NULL));
int a[10];
for (int i = 0; i < 10; i++)
a[i] = rand() % 100;//生成随机数组
int n = sizeof(a) / sizeof(a[0]);
int* temp = (int*)malloc(sizeof(int)*n);
int x = 0;
printf("排序前数组：");
PrintArray(a, n);
table();
scanf("%d", &x);
printf("第00趟：");
PrintArray(a, n);
switch (x)
{
case 1:
InsertSort(a, n);//直接插入
break;
case 2:
//shellInsert(a, n);//Hibbard增量 希尔
ShellSort(a, n);//希尔插入
break;
case 3:
BubbleSort(a, n);//冒泡排序
break;
case 4:
QuickSort(a, 0, n - 1, n);//快速排序
break;
case 5:
SelectionSort(a, n);//直接选择
break;
case 6:
MergeSort(a, 0, n-1, temp);//归并排序
break;
case 0:
break;
}
printf("排序后数组：");
PrintArray(a, n);
system("pause");
return 0;
}
排序前数组：31 77 84 39 4 64 20 66 87 60
请选择对该组数据进行排序的方法:
1.直接插入排序
2.希尔排序
3.冒泡排序
4.快速排序排序
5.简单选择排序
6.归并排序
0.退出
1
第00趟：31 77 84 39 4 64 20 66 87 60
第01趟：31 77 84 39 4 64 20 66 87 60
第02趟：31 77 84 39 4 64 20 66 87 60
第03趟：31 39 77 84 4 64 20 66 87 60
第04趟：4 31 39 77 84 64 20 66 87 60
第05趟：4 31 39 64 77 84 20 66 87 60
第06趟：4 20 31 39 64 77 84 66 87 60
第07趟：4 20 31 39 64 66 77 84 87 60
第08趟：4 20 31 39 64 66 77 84 87 60
第09趟：4 20 31 39 60 64 66 77 84 87
排序后数组：4 20 31 39 60 64 66 77 84 87
请按任意键继续. . .
排序前数组：39 26 78 96 5 74 27 2 81 82
请选择对该组数据进行排序的方法:
1.直接插入排序
2.希尔排序
3.冒泡排序
4.快速排序排序
5.简单选择排序
6.归并排序
0.退出
2
第00趟：39 26 78 96 5 74 27 2 81 82
第01趟：39 26 2 81 5 74 27 78 96 82
第02趟：2 26 5 74 27 78 39 81 96 82
第03趟：2 5 26 27 39 74 78 81 82 96
排序后数组：2 5 26 27 39 74 78 81 82 96
请按任意键继续. . .
排序前数组：30 70 55 41 1 51 72 43 54 76
请选择对该组数据进行排序的方法:
1.直接插入排序
2.希尔排序
3.冒泡排序
4.快速排序排序
5.简单选择排序
6.归并排序
0.退出
3
第00趟：30 70 55 41 1 51 72 43 54 76
第01趟：30 55 41 1 51 70 43 54 72 76
第02趟：30 41 1 51 55 43 54 70 72 76
第03趟：30 1 41 51 43 54 55 70 72 76
第04趟：1 30 41 43 51 54 55 70 72 76
排序后数组：1 30 41 43 51 54 55 70 72 76
请按任意键继续. . .
排序前数组：8 87 43 5 75 88 35 24 48 62
请选择对该组数据进行排序的方法:
1.直接插入排序
2.希尔排序
3.冒泡排序
4.快速排序排序
5.简单选择排序
6.归并排序
0.退出
4
第00趟：8 87 43 5 75 88 35 24 48 62
第01趟：5 8 43 87 75 88 35 24 48 62
第02趟：5 8 24 35 43 88 75 87 48 62
第03趟：5 8 24 35 43 88 75 87 48 62
第04趟：5 8 24 35 43 62 75 87 48 88
第05趟：5 8 24 35 43 48 62 87 75 88
第06趟：5 8 24 35 43 48 62 75 87 88
排序后数组：5 8 24 35 43 48 62 75 87 88
请按任意键继续. . .
排序前数组：3 11 84 13 86 60 92 37 32 8
请选择对该组数据进行排序的方法:
1.直接插入排序
2.希尔排序
3.冒泡排序
4.快速排序排序
5.简单选择排序
6.归并排序
0.退出
5
第00趟：3 11 84 13 86 60 92 37 32 8
第01趟：3 11 84 13 86 60 92 37 32 8
第02趟：3 8 84 13 86 60 92 37 32 11
第03趟：3 8 11 13 86 60 92 37 32 84
第04趟：3 8 11 13 86 60 92 37 32 84
第05趟：3 8 11 13 32 60 92 37 86 84
第06趟：3 8 11 13 32 37 92 60 86 84
第07趟：3 8 11 13 32 37 60 92 86 84
第08趟：3 8 11 13 32 37 60 84 86 92
第09趟：3 8 11 13 32 37 60 84 86 92
第10趟：3 8 11 13 32 37 60 84 86 92
排序后数组：3 8 11 13 32 37 60 84 86 92
请按任意键继续. . .
排序前数组：65 23 55 64 54 31 92 87 72 67
请选择对该组数据进行排序的方法:
1.直接插入排序
2.希尔排序
3.冒泡排序
4.快速排序排序
5.简单选择排序
6.归并排序
0.退出
6
第00趟：65 23 55 64 54 31 92 87 72 67
排序后数组：23 31 54 55 64 65 67 72 87 92
请按任意键继续. .
扫一扫
562
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
