九种排序，冒泡，插入，折半插入，希尔，选择，鸡尾酒，堆，快速，计数

#include
#include
#include
#include

void swap(int* arr,int* buf)
{
int temp = *arr;
*arr = *buf;
*buf = temp;
}

void show(int* arr,int len)
{
int i=0;
for(i=0;i<10;i++)
{
printf("%d “,arr[i]);
}
printf(”\n");
}

void order_sort(int* arr,int len)
{
size_t i=0,j=0;
for(i=len;i>0;i–)
{
bool exchange = false;
for(j=0;j {
if(arr[j]>arr[j+1])
{
swap(&arr[j],&arr[j+1]);
exchange = true;
}
}
if(exchange == false)
return;
}
}

//冒泡：通过前后交换，使得最大数在队列中浮到最后，接着掐掉头，重复上述操作，直到冒泡不在发生或掐到头为止。

void insert_sort(int* arr,int len)
{
int i=0,j=0;
for(i=1;i {
size_t key = arr[i];
if(key >= arr[i-1]){}
else
{
for(j=i-1;(j>=0)&&(arr[j]>key);j–)
{
arr[j+1] = arr[j];
}
arr[j+1] = key;
show(arr,len);
}
}
}
//插入排序：如果冒泡是从大到小，那么插入就是从小到大，因为插入的条件是顺序，唯有从小到大才能维持顺序的情况。

void bin_insert(int *arr,int len)
{
int i,j;
for(i=1;i {
int left = 0;
int right = i-1;
int key = arr[i];
while(left <= right)
{
int mid = (right+left)/2;
if(key >= arr[mid])
{
left = mid+1;
}
else
{
right = mid-1;
}
printf("%d\n",left);
}
for(j=i-1;j>=left;j–)
{
arr[j+1] = arr[j];
}
arr[left] = key;
show(arr,10);
}
}
//折半插入：在插入排序的基础上，将顺序比较换成二分查找

void shell_sort(int* arr,int len)
{
int step,i,j;
for(step = len/2;step>0;step = step/2)
{
for(i=step;i {
int key = arr[i];
for(j=i-step;(j>=0)&&(key {
arr[j+step] = arr[j];
}
arr[j+step] = key;
}
}
}
//希尔排序,又称分组增量排序，其原理是不断对数组进行拆分接着在组内以插入排序的形式比较大小，其排序时应注意其组内位置的分布。对于以顺序为主的数组，效率最高，O 1.3到2次

void select_sort(int* arr,int len)
{
size_t i,j;
for(i=len-1;i>0;i–)
{
int max = arr[i];
for(j=0;j {
if(arr[j]>max)
{
swap(&arr[j],&arr[i]);
max = arr[j];
}
}
}
}

//选择排序：选择最大的数与最后的数进行交换。

void cook_tail_sort(int* arr,int n)
{
size_t i,j;
for(i=0;i {
size_t max = n-i-1,min = i;
for(j=i;j<=n-i-1;j++)
{
if(arr[j]>arr[max])
{
max = j;
}
if(arr[j] {
min = j;
}
}
swap(&arr[max],&arr[n-i-1]);
swap(&arr[min],&arr[i]);
show(arr,n);
}
}

//鸡尾酒排序:选择排序的变种，挑选最大与最小分别与最前与最后交换。

void root_sort(int* arr,int len)
{
int i,l,index,child;
for(i=len/2;i>=0;i–)
{
index = i;
child = 2*index+1;
if(child < len)
{
if(child+1 < len)
{
if(arr[child] < arr[child+1])
{
child++;
}
}
if(arr[index] < arr[child] )
{
swap(&arr[index],&arr[child]);
}
}
}
}

void heap_sort(int* arr,int len)
{
int i;
for(i = len-1;i>=0;i–)
{
root_sort(arr,i+1);
swap(&arr[0],&arr[i]);
}
}
//堆排序:以一个树的形式，将底层的数不断给置顶，然后将顶部的最大数填入的准备排好的数组中。的时间复杂度n*logn 空间复杂度是1、

void qurt_sort(int* arr,int left,int right)
{
if(left >= right)
{
return;
}
int l = left;
int r = right;
int key = arr[left];
while(l < r)
{
while(l {
r–;
}
arr[l] = arr[r];
while(l= arr[l])
{
l++;
}
arr[r] = arr[l];
}
arr[l] = key;
if(l-left >= 2)
{
qurt_sort(arr,left,l-1);
}
if(right-l >= 2)
{
qurt_sort(arr,l+1,right);
}

}
//快速排序：从第一个数开始，为每一个数字去寻找合适的位子，即前面的数都比其小，后面的数字都比其大。利用二分，递归的思想，前后分开进行，时间复杂度为O（n×logn）到 n，空间复杂度为O(log n).

void cout_sort(intarr,int len)
{
int max = arr[0];
int min = arr[0];
int i;
for(i=0;i {
if(max < arr[i])
max = arr[i];
if(min > arr[i])
min = arr[i];
}
int num = max-min+1;
int cnt = malloc(sizeof(arr[0])*(num));
int j;
for(j=0;j {
cnt[arr[j]-min]++;
}
int n;
int k = 0;
for(n=0;n {
if(cnt[n] > 0)
{
arr[k++] = n+min;
cnt[n]–;
}
}
}
//计数排序，适用于小范围，高密度的数组排序，经过建立一个所有从最小数到最大数的统计型数组进行统计，最后根据统计数组的下标，其值即数量，加入到原本的数组中，时间复杂度是 最大数与最小数的差+n 空间复杂度 最大数与最小树。

void merger_arr(int* arr,int left,int right)
{
int mid = (left+right)/2;
int len = mid-left+1;
int* buf = malloc(sizeof(arr[0])len);
int i;
for(i=0;i {
buf[i] = arr[left+i];
}
int k = left;
int j = 0;
int l = mid+1;
while(l <= right&&j < len)
{
if(arr[l] > buf[j])
{
arr[k++] = buf[j++];
}
else
{
arr[k++] = arr[l++];
}
}
if(j < len)
{
arr[k++] = buf[j++];
}
if(l <= right)
{
arr[k++] = arr[l++];
}
free(buf);
}
void merger(int arr,int left,int right)
{
if(left >= right)
return;
int mid = (left+right)/2;
merger(arr,left,mid);
merger(arr,mid+1,right);
merger_arr(arr,left,right);
}

//归并排序：利用递归以二分的形式，划分到单个数字，归纳函数，将两个数组合并成一个有序数组，数组大小以一，二，四，八,合并到合理的数组。时间复杂读 n*logn 复杂度 n

int main()
{
srand(time(NULL));
int arr[10] = {};
int i=0;
for(i=0;i<10;i++)
{
arr[i] = rand() % 100;
}
show(arr,10);
cout_sort(arr,10);
show(arr,10);
}