几种常见的排序算法的代码实现
以下是我用代码实现几种排序算法的过程，其中注释标注一些我觉得值得注意的地方做个分享
#include
#include
#include
#include
#define MAX 10
//获得系统时间
long getSystemTime()
{
struct timeb tb;
ftime(&tb);
return tb.time*1000+tb.millitm;
}
void output(int a[],int length)
{
int i;
for(i=0;i
printf("%d",a[i]);
}
}
void Bubble(int a[],int length)
{
//升序
int i,j;
for(i = 0;i
for(j=length-1;j>i;j–)
{
if(a[j-1]>a[j])
{
int temp = a[j-1];
a[j-1] = a[j];
a[j] = temp;
}
}
}
}
//选择排序
void select_sort(int a[],int length)
{
//选择排序减少了交换次数,效率O（n*n)
//思路认为当前值为最小值，从剩下的元素中寻找比当前值更小的元素，交换其位置
//外循环从位置0开始
int i,j;
for(i=0;i
int min = i;
for(j = i+1;j
if(a[min]>a[j])
{
min = j;
}
}
if(min!=i)
{
int temp = a[min];
a[min] = a[i];
a[i] = temp;
}
}
}
//插入排序
void Insert_sort(int arr[],int length)
{
int i,j;
//首先默认第0个元素是已经排序好的遍历之后未排序的数组元素,所以从第一个元素开始遍历
for(i=1;i=0&&temp }
//希尔排序：
//先进行分组，再分别进行插入排序
//分组间隔依据是长度/3+1
void shell_sort(int a[],int length)
{
int i,j,k;
//分组的间隔
int gap = length;
do
{
gap = gap/3+1;
//先找出每组的第一个元素
for(i=0;i=0&&a[k]>temp;k-=gap)
{
a[k+gap] = a[k];
}
a[k+gap] = temp;
}
}
}
}
while(gap>1);
}
//快速排序
//从小到大排序，从右往左找到一个比基准值小的值，，从左往后找比基准值大的值
void Quick_Sort(int a[],int start,int end)
{
//一个指向开始，一个指向末尾
int i = start;
int j = end;
int temp = a[start];
//进入循环的条件
if(ii;j--)
{
if(a[j]temp)
{
a[j] = a[i];
j--;
break;
}
}
}
//循环结束当前位置放基准值
a[i] = temp;
//递归
Quick_Sort(a,start,i-1);
Quick_Sort(a,i+1,end);
}
}
void merge(int a[],int start,int end,int mid,int *temp)
{
//合并,同时对两个分组进行循环，将小的存放在前面
int i_start = start;
int i_end = mid;
int j_start = mid+1;
int j_end = end;
//表示辅助空间中的元素个数
int count = 0;
while(i_start<=i_end&&j_start<=j_end)
{
if(a[i_start]}
//交换函数
void Swap(int arr[],int a,int b)
{
int temp =arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
//index:待调整的节点的下标//
void HeapAdjust(int a[],int index,int length)
{
//首先记录当前节点的位置
int max = index;
//左孩子的下标
int leftchild = 2*index+1;
//右孩子的下标
int rightchild = 2*index+2;
//调整当前的堆,如果其左右孩子的下标已经超出当前堆的长度，则循环结束
if(leftchilda[max])
{
//记录最大的下标
max = leftchild;
}
if(rightchilda[max])
{
max = rightchild;
}
if(max!=index)
{
//交换值
Swap(a,index,max);
//递归调用,调整交换完但是不满足的堆，当该max对应的位置的左右孩子超出length时，就不会再递归了
HeapAdjust(a,max,length);
}
}
//堆排序（最大堆）
//堆排序是一种选择排序，步骤是：首先是初始化堆，将最大的元素放到堆顶，接着将堆顶元素和最后一个元素进行交换
//最后一个元素不参与排序，剩下的元素再次组成一个最大堆
void HeapSort(int a[],int length)
{
//首先初始化堆，找到最后一个非叶子节点
int i;
for(i=length/2-1;i>=0;i–)
{
//调整堆，只需要调整叶子节点
HeapAdjust(a,i,length);
}
//交换第一个节点和最后一个节点的位置
int j;
for(j=length-1;j>=0;j--)
{
Swap(a,0,j);
//继续调整,从上往下调整
HeapAdjust(a,0,j);
}
}
//归并排序，将已经排序好的小的部分合并成一个整体
void Merge_Sort(int a[],int start,int end,int *temp) //temp是用来暂时存放排序好的小的组
{
//退出条件
if(start>=end)
{
return;
}
//递归分组
int mid = (start+end)/2;
//左半边
Merge_Sort(a,start,mid,temp);
//右半边
Merge_Sort(a,mid+1,end,temp);
//合并
merge(a,start,end,mid,temp);
}
int main()
{
int i;
int arr[MAX];
int arr1[MAX] = {3,5,4,2,1,0,6,8,9,7};
srand((unsigned int)time(NULL)); //随机数种子,播种子
for(i=0;i
arr[i] = rand()%MAX;
}
output(arr1,MAX);
// 申请一个数组空间
int *temp = (int *)malloc(sizeof(int)*MAX);
long start = getSystemTime();
printf("\n");
printf("开始时间:%ld\n",start);
//int length = sizeof(arr)/sizeof(int);
//int arr1[MAX] = {1,2,0,3,6,7,5,4,9,8};
// output(arr,MAX);
// 冒泡排序
//Bubble(arr,MAX);
//选择排序
//select_sort(arr,MAX);
//插入排序
//Insert_sort(arr,MAX);
//希尔排序
// shell_sort(arr,MAX);
//快速排序
//Quick_Sort(arr,0,length-1);
//归并排序
//Merge_Sort(arr1,0,MAX-1,temp);
//堆排序
HeapSort(arr1,MAX);
printf("\n");
output(arr1,MAX);
printf("\n");
long end = getSystemTime();
printf("结束时间%ld\n",end);
long time = end-start;
printf("\n");
printf("耗时%ld毫秒\n",time);
free(temp);
return 0;
}
最后附上一张算法的时间空间复杂度和稳定性的比较
