/* 1.
****************************************
堆排序算法,复杂度O(nlgn) 渐近最优算法
#define PARENT(i) i/2-1
#define LEFT(i) 2*i+1
#define RIGHT(i) 2*i+2
int largest;
int heap_size;
void max_heapify(int A[],int i){ //维持最大堆的性质
int l,r;
int temp,largest;
l=LEFT(i);
r=RIGHT(i);
if(l<heap_size&&A[l]>A[i]){
largest=l;
}
else
largest=i;
if(r<heap_size&&A[r]>A[largest]){
largest=r;
}
if(largest!=i){
temp=A[i];
A[i]=A[largest];
A[largest]=temp;
max_heapify(A,largest);
}
}
void build_max_heap(int A[]){ //开始建堆
int i;
for(i=(heap_size-2)/2;i>=0;i--)
max_heapify(A,i); //从倒数第二层开始建堆
}
void heap_sort(int A[]){ //进行堆排
int temp;
int i;
build_max_heap(A);
for(i=heap_size-1;i>=1;i--){
temp=A[0];
A[0]=A[i];
A[i]=temp;
heap_size--; //减少一个
max_heapify(A,0);
}
}
**************************
*/
/* 2.
**************************
插入排序 复杂度O(n2)
void insertion_sort(int a[],int n){ //插入排序算法
int j,key;
int k;
for(j=1;j<n;j++){
key=a[j];
for(k=j-1;k>=0&&a[k]>key;k--){
a[k+1]=a[k];
}
a[k+1]=key;
}
}
********************
*/
/* 3.
合并排序 时间复杂度为O(nlgn)
********************
#include<stdlib.h>
#define NIF 1000000 //哨兵
void merge(int a[],int p,int q,int r){ //合并排序算法
int n1=q-p+1;
int n2=r-q;
int i,j,k;
int *L,*R;
L=(int *)malloc((n1+1)*sizeof(int));
R=(int *)malloc((n2+1)*sizeof(int));
for(i=0;i<n1;i++)
L[i]=a[p+i];
for(j=0;j<n2;j++)
R[j]=a[q+j+1];
L[n1]=NIF;
R[n2]=NIF;
i=0;j=0;
for(k=p;k<=r;k++){
if(L[i]<R[j]){
a[k]=L[i];
i++;
}
else{
a[k]=R[j];
j++;
}
}
}
void merge_sort(int a[],int p,int r){ //将a从p到r排序
int j;
if(p<r){
j=(r+p)/2;
merge_sort(a,p,j);
merge_sort(a,j+1,r); //分治排序
merge(a,p,j,r); //合并起来
}
}
*****************************
*/
/* 4.
*****************************
冒泡排序 时间复杂度为O(n2)
void buddle_sort(int a[],int n){ //冒泡排序
int i,j;
int temp;
for(i=0;i<n;i++){
for(j=n-1;j>i;j--){
if(a[j]<a[j-1]){
temp=a[j-1];
a[j-1]=a[j];
a[j]=temp;
}
}
}
}
***************************
*/
/* 5.
***************************
快速排序算法 采用随机算法时 时间复杂度O(nlgn)
int partition(int a[],int p,int r){ //快排关键算法
int key=a[r];
int i,j,temp;
i=p-1;
for(j=p;j<=r-1;j++){
if(a[j]<key){
i++;
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
temp=a[i+1];
a[i+1]=key;
a[r]=temp;
return i+1;
}
void quick_sort(int a[],int p,int r){ //快排
int q;
if(p<r){
q=partition(a,p,r);
quick_sort(a,p,q-1);
quick_sort(a,q+1,r);
}
}
**********************
*/
/* 6.
**********************
位于0到k之间的数，当k不太时采用计数排序
线性复杂时间度O(n)
#include<stdlib.h>
void counting_sort(int a[],int b[],int k,int n){ //a是要排数组，b是排好的数组,k是最大数,待排个数
int *c;
int i,j;
c=(int *)malloc(sizeof(int)*k);
for(i=0;i<k;i++)
c[i]=0; //初始化数组c...记录a中等于i等元素个数
for(j=0;j<n;j++)
c[a[j]]++;
for(j=1;j<=k;j++)
c[j]=c[j]+c[j-1];
for(j=n-1;j>=0;j--){
b[c[a[j]]-1]=a[j];
c[a[j]]--;
}
}
***********************
*/
/*选择第i小的元素
***********************
int partition(int a[],int p,int r){ //快排关键算法
int key=a[r];
int i,j,temp;
i=p-1;
for(j=p;j<=r-1;j++){
if(a[j]<key){
i++;
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
temp=a[i+1];
a[i+1]=key;
a[r]=temp;
return i+1;
}
int select(int a[],int p,int r,int i){
int q,k;
if(p==r)
return a[p];
q=partition(a,p,r); //采用部分快排算法
k=q-p+1;
if(k==i)
return a[q];
else{
if(i<k)
select(a,p,q-1,i);
else
select(a,q+1,r,i-k);
}
}
*********************
*/
/*#include <stdio.h>
#include <stdlib.h>
int main(){
int data[10]={73,22,93,43,55,14,28,65,39,81};
int temp[10][10]={0};
int order[10]={0};
int i,j,k,n,lsd;
k=0;n=1;
printf("\n排序前: ");
for (i=0;i<10;i++) printf("%d ",data[i]);
putchar('\n');
while (n<=10){
for (i=0;i<10;i++){
lsd=((data[i]/n)%10);
temp[lsd][order[lsd]]=data[i];
order[lsd]++;
}
printf("\n重新排列: ");
for (i=0;i<10;i++){
if(order[i]!=0)
for (j=0;j<order[i];j++){
data[k]=temp[i][j];
printf("%d ",data[k]);
k++;
}
order[i]=0;
}
n*=10;
k=0;
}
putchar('\n');
printf("\n排序后: ");
for (i=0;i<10;i++) printf("%d ",data[i]);
system("pause");
return 0;
}*/
/*以lsd排序 以左边最低位排序
*******************************
void radix_sort_low(int a[],int keysize,int array_size){
int n,k,i,j,l,lsd; //lsd记录基数
int temp[10][10000]; //行记录基数是多少，列记录此基数有多少个
int order[10]={0};
n=1;
for(l=1;l<=keysize;l++,n*=10){
k=0;
for(i=0;i<array_size;i++){
lsd=(a[i]/n)%10;
temp[lsd][order[lsd]]=a[i];
order[lsd]++;
}
printf("重新排列: ");
for(i=0;i<10;i++){
if(order[i]!=0){
for(j=0;j<order[i];j++){
a[k]=temp[i][j];
printf("%d ",a[k]);
k++;
}
}
order[i]=0; //重新置为0
}
printf("\n");
}
}
******************************
*/
/*
希尔排序，迅速减少大量无序情况
******************************
void shell_sort(int a[],int n){
int i,j,gap;
int temp;
for(gap=n/2;gap>0;gap/=2)
for(i=gap;i<n;i++)
for(j=i-gap;j>=0&&a[j]>a[j+gap];j=j-gap){
temp=a[j];
a[j]=a[j+gap];
a[j+gap]=temp;
}
}
*****************************
*/
/*
插入排序算法
*********************
void select(int a[],int n){
int i,k,j,temp;
int key;
for(i=0;i<n;i++){
key=a[i];
temp=i;
for(j=i+1;j<n;j++){
if(a[j]<key){
key=a[j];
temp=j;
}
}
k=a[i];
a[i]=a[temp];
a[temp]=k;
}
}
***************************
*/
