c语言数据结构课设排序算法比较
此段代码针对冒泡排序，选择排序，希尔排序，插入排序，快速排序，基数排序，堆排序进行比较
#include
#include
#include
#include
#define M 10 //排序多少条，可自行改变
#define WIDTH 5 //被排序元素的最大位数，可以排100000以内的
#define MAXK 10 //位数划分基于的基数，10表示为10进制划分
typedef int ElementType;
void SetFigure(int *arr, int len)
{
FILE *fp=fopen(“rand.txt”,“w”); //生成随机数，并写入文件
int i;
srand(time(NULL));
for (i = 0; i
arr[i]=rand();
fprintf(fp,"%d ",arr[i]);
}
fclose(fp);
}
void GetFigure(int *arr, int len) //读出随机数，写入arr[]
{
FILE *fp=fopen(“rand.txt”,“r”);
int i;
for (i = 0; i < len; i++)
{
fscanf(fp,"%d ",arr + i);
}
fclose(fp);
}
void Print(int *arr,int len) //输出排完的数据
{
int i;
for(i=0;i
printf(" %d ",arr[i]);
}
}
void swap01(int *arr, int i, int j) //交换两个变量的值
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
void Bubbling(int *arr, int len) //冒泡排序
{
int i;
int j;
int temp;
for(i = 0; i < len - 1; i++)
{
for(j = 0; j < len - 1 - i; j++)
{
if(arr[j] > arr[j + 1])
{
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
void SelectionSort(int arr, int len) // O(nn) 选择排序
{
int i = 0;
int j = 0;
int k = -1;
for(i=0; i}
void InertionSort(int arr, int len) // O(nn) 直接插入排序
{
int i = 0;
int j = 0;
int k = -1;
int temp = -1;
for(i=1; i=0) && (arr[j]>temp); j--)
{
arr[j+1] = arr[j]; //元素后移
k = j; //k需要插入的位置
}
arr[k] = temp;//元素插入
}
}
void ShellSort(int *arr, int len) //希尔排序
{
int i = 0;
int j = 0;
int k = -1;
int temp = -1;
int gap = len;
do
{
gap = gap / 3 + 1; //O（n 1.3）
for(i=gap; i=0) && (arr[j]>temp); j-=gap)
{
arr[j+gap] = arr[j];
k = j;
}
arr[k] = temp;
}
}while( gap > 1 );
}
void swap1(int *arr, int i, int j)
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//划分过程 第一个元素当枢轴，分成2个有效子序列
int partition(int *arr, int low, int high)
{
int pv = arr[low];
while( low < high )
{
while( (low < high) && (arr[high] >= pv) )
{
high--; //比基准大，本来就在右边，所以high前移动
}
swap1(arr, low, high);
while( (low < high) && (arr[low] <= pv) )
{
low++;
}
swap1(arr, low, high);
}
//返回枢轴的位置。。。重要
return low;
}
//让n个元素 依此减少 减少到1个元素的时候，因为1个元素可以看成一个有序的序列
void QSort2(int *arr, int low, int high)
{
if( low < high )
{
int pivot = partition(arr, low, high);
//对子序列1排序
QSort2(arr, low, pivot-1);
//对子序列2排序
QSort2(arr, pivot+1, high);
}
}
void QSort(int *arr, int low, int high)
{
if( low < high )
{
int pivot = partition(arr, low, high);
//对子序列1排序
QSort2(arr, low, pivot-1);
//对子序列2排序
QSort2(arr, pivot+1, high);
}
}
void QuickSort(int arr, int len) // O(nlogn)
{
QSort(arr, 0, len-1);
}
void PercDown(int *arr, int i, int N)
{
int child;
ElementType Tmp;
for (Tmp = arr[i]; 2*i+1 < N; i = child){
child = 2*i+1; //注意数组下标是从0开始的，所以左孩子的求发不是2*i
if (child != N - 1 && arr[child + 1] > arr[child])
++child; //找到最大的儿子节点
if (Tmp < arr[child])
arr[i] = arr[child];
else
break;
}
arr[i] = Tmp;
}
void HeapSort(int *arr, int N)
{
int i;
for (i = N / 2; i >= 0; --i)
PercDown(arr, i, N); //构造堆
for(i=N-1;i>0;–i)
{
swap1(arr,0,i); //将最大元素（根）与数组末尾元素交换，从而删除最大元素，重新构造堆
PercDown(arr, 0, i);
}
}
void radixSort(int *arr, int len)
{
int i;
void innerCountingSort(int *arr, int len, int d);//内部的计数排序声明
for (i = 0; i < WIDTH; i++)
{
innerCountingSort(arr, len, i);//对于每个元素的每一位都调用一次内部计数排序
}
}
void innerCountingSort(int *arr, int len, int d) //根据第d位数对数组进行排序
{
int i, j,k[MAXK] = {0};//数组K用来统计某一个元素的个数，该元素是待排序数组中某一位的数值
int *ip = (int *)malloc(len * sizeof(int));//用来存储待排序数组的元素的某一位的数值
int *bp = (int *)malloc(len * sizeof(int));
int getDValue(int value, int d);//获取待排序数组元素的第d位的数值
for (i = 0; i < len; i++)
{
ip[i] = getDValue(arr[i], d);
k[ip[i]]++;
}
for (j = 1; j < MAXK; j++) //统计小于等于j的元素个数
{
k[j] = k[j] + k[j-1];
}
for (i = len - 1; i >= 0; i--)//按照第d位的大小，将数组元素放置到正确的位置
{
bp[k[ip[i]] - 1] = arr[i];
k[ip[i]]--;
}
for (i = 0; i < len; i++) //将按某一位排过序后的数组复制给原数组
{
arr[i] = bp[i];
}
free(ip);
free(bp);
}
int getDValue(int value, int d) //获取一个数第d位数的值，位数索引从0开始
{
for (;d > 0 && value > 0; d–)
{
value = value / MAXK;
}
return value % MAXK;
}
int main()
{
int *arr=(int *)malloc(sizeof(int)*M);
SetFigure(arr, M); //写入随机数，并存入文件中
GetFigure(arr, M);
clock_t beg = clock();
Bubbling(arr, M);//冒泡排序
clock_t end = clock();
printf(“冒泡排序所需时间为：%.2lfms\n”, (end - beg) * 1000.0 / CLOCKS_PER_SEC);
//Print(arr,M);
memset(arr, 0, sizeof(int)*M); //初始化数组
GetFigure(arr, M);
clock_t beg1 = clock();
SelectionSort(arr,M);//选择排序
clock_t end1 = clock();
printf(“选择排序所需时间为：%.2lfms\n”, (end1 - beg1) * 1000.0 / CLOCKS_PER_SEC);
//Print(arr,M);
memset(arr, 0, sizeof(int)*M); //初始化数组
GetFigure(arr, M);
clock_t beg2 = clock();
InertionSort(arr,M);//插入排序
clock_t end2 = clock();
printf(“直接插入排序所需时间为：%.2lfms\n”, (end2 - beg2) * 1000.0 / CLOCKS_PER_SEC);
//Print(arr,M);
memset(arr, 0, sizeof(int)*M); //初始化数组
GetFigure(arr, M);
clock_t beg3 = clock();
ShellSort(arr, M);//希尔排序
clock_t end3 = clock();
printf(“希尔排序所需时间为：%.2lfms\n”, (end3 - beg3) * 1000.0 / CLOCKS_PER_SEC);
//Print(arr,M);
memset(arr, 0, sizeof(int)*M); //初始化数组
GetFigure(arr, M);
clock_t beg4 = clock();
QuickSort(arr, M);//快速排序
clock_t end4 = clock();
printf(“快速排序所需时间为：%.2lfms\n”, (end4 - beg4) * 1000.0 / CLOCKS_PER_SEC);
//Print(arr,M);
memset(arr, 0, sizeof(int)*M); //初始化数组
GetFigure(arr, M);
clock_t beg5 = clock();
HeapSort(arr, M);//堆排序
clock_t end5 = clock();
printf(“堆排序所需时间为：%.2lfms\n”, (end5 - beg5) * 1000.0 / CLOCKS_PER_SEC);
//Print(arr,M);
memset(arr, 0, sizeof(int)*M); //初始化数组
GetFigure(arr, M);
clock_t beg6 = clock();
radixSort(arr, M);//基数排序
clock_t end6 = clock();
printf(“基数排序所需时间为：%.2lfms\n”, (end6 - beg6) * 1000.0 / CLOCKS_PER_SEC);
//Print(arr,M);
return 0;
}