排序

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

//快速排序
int po(int num[],int s,int t){
	int le=s,re=t;
	int c=num[s];
	while(le<re){
		while(le<re&&num[re]<=c)
			re--;
		num[le]=num[re];
		while(le<re&&num[le]>=c)
			le++;
		num[re]=num[le];
	}
	num[le]=c;
	return le;
}

void sort(int num[],int s,int t)
{
	int i;
	if(s<t){
		i=po(num,s,t);
		sort(num,s,i-1);
		sort(num,i+1,t);
	}
}



//插入排序
void insertsort(int num[],int n)
{
	int i,j,tmp;
	for(i=1;i<n;i++){
		tmp=num[i];
		j=i-1;
		while(j>=0&&num[j]>tmp){
			num[j+1]=num[j];
			j--;
		}
		num[j+1]=tmp;
	}
}


//折半插入排序
void binsort(int num[],int n){
	int i,j,low,high,mid;
	int tmp;
	for(i=1;i<n;i++){
		if(num[i]<num[i-1]){
			tmp=num[i];
			low=0;high=i-1;
			while(low<=high){//二分法查找插入的位置
				mid=(low+high)/2;
				if(tmp<num[mid])high=mid-1;
				else low=mid+1;
			}
			for(j=i;j>low;j--)
				num[j]=num[j-1];
			num[low]=tmp;
		}
	}
}

//希尔排序
void shell(int v[],int n){
    int gap,i,j,temp;
    for (gap = n/2; gap > 0; gap /= 2)
    {
        for(i = gap; i < n; i++)
			for(j = i-gap; j>=0 && v[j]>v[j+gap]; j -= gap)
            {
                temp = v[j];
                v[j] = v[j+gap];
                v[j+gap] = temp;
            }
    }
}

//简单选择排序
void select(int num[],int n)
{
	int i,j;
	for(i=0;i<n;i++){
		int k=i;
		for(j=i;j<n;j++){
			if(num[j]<num[k])k=j;
		}//寻找最小元素的下标
		//交换
		int c;
		c=num[i];
		num[i]=num[k];
		num[k]=c;
	}
}



/*void merge(int num[],int low,int mid,int high,int temp[])
{
	int i=low,j=mid-1;
	int m=mid,n=high;
	int k=0;
	while(i<=j&&m<=n){
		if(num[i]<num[j])temp[k++]=num[i++];
		else temp[k++]=num[m++];
	}
	while(i<=j)temp[k++]=num[i++];
	while(m<=n)temp[k++]=num[m++];
	for(int i=0;i<k;i++)num[low+i]=temp[i];
}
void mergesort(int a[], int first, int last, int temp[])  
{  
    if (first < last)  
    {  
        int mid = (first + last) / 2;  
        mergesort(a, first, mid, temp);    //左边有序
        mergesort(a, mid + 1, last, temp); //右边有序
        merge(a, first, mid, last, temp); //再将二个有序数列合并  
    }  
}*/
void mergearray(int a[], int first, int mid, int last, int temp[])  
{  
    int i = first, j = mid + 1;  
    int m = mid,   n = last;  
    int k = 0;  
      
    while (i <= m && j <= n)  
    {  
        if (a[i] <= a[j])  
            temp[k++] = a[i++];  
        else  
            temp[k++] = a[j++];  
    }  
      
    while (i <= m)  
        temp[k++] = a[i++];  
      
    while (j <= n)  
        temp[k++] = a[j++];  
      
    for (i = 0; i < k; i++)  
        a[first + i] = temp[i];  
}  
void mergesort(int a[], int first, int last, int temp[])  
{  
    if (first < last)  
    {  
        int mid = (first + last) / 2;  
        mergesort(a, first, mid, temp);    //左边有序  
        mergesort(a, mid + 1, last, temp); //右边有序  
        mergearray(a, first, mid, last, temp); //再将二个有序数列合并  
    }  
}


//堆排序
//堆调整，构建大顶堆，arr[]是待调整的数组，i是待调整的数组元素的位置，length是数组的长度  
void HeapAdjust(int arr[], int i, int length)  
{  
    int Child;  
    int temp;  
    for(;2 * i + 1 < length; i = Child)  
    {  
        //子节点的位置 = 2 * (parent(父结点)) + 1  
        Child = 2 * i + 1;  
        //得到子结点中较大的结点  
        if(Child < length - 1 && arr[Child + 1] > arr[Child])  
                ++Child;  
        //如果较大的子结点大于父结点那么把较大的子结点往上移动 替换它的父结点  
        if(arr[i] < arr[Child])  
        {  
            temp = arr[i];  
            arr[i] = arr[Child];  
            arr[Child] = temp;  
        }  
        else break;  
    }  
}  
//堆排序算法  
void HeapSort(int arr[], int length)  
{  
    int i;  
    //调整序列的前半部分元素，调整完之后第一个元素  
    //是序列的最大元素，length/2-1是最后一个非叶子结点  
    for(i = length/2 - 1; i >= 0; --i)  
            HeapAdjust(arr, i, length);  
    //从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素  
    //循环里是把第一个元素和当前的最后一个元素交换 保证当前的最后一个位置的元素是现在这个序列的最大的  
    //不断的缩小调整heap的范围，每一次调整完毕保证第一个元素是当前序列的最大的元素  
    for(i = length - 1; i > 0; --i)  
    {  
        arr[i] = arr[0]^arr[i];  
        arr[0] = arr[0]^arr[i];  
        arr[i] = arr[0]^arr[i];  
        HeapAdjust(arr, 0, i);  //递归调整  
    }  
}  


//基数排序
int maxbit(int data[], int n) //辅助函数，求数据的最大位数
{
    int d = 1; //保存最大的位数
    int p = 10;
    for(int i = 0; i < n; ++i) {
        while(data[i] >= p) {
            p *= 10;
            ++d;
        }
    }
    return d;
}
void radixsort(int data[], int n)   //基数排序
{
    int d = maxbit(data, n);   //数组中的元素的最大位数
    int *tmp = (int *)malloc(n * sizeof(int));
    int *count = (int *)malloc(10 * sizeof(int));   //计数器
    int i, j, k;
    int radix = 1;
    for(i = 1; i <= d; i++) {   //进行d次排序
        for(j = 0; j < 10; j++)
            count[j] = 0;    //每次分配前清空计数器
        for(j = 0; j < n; j++) {
            k = (data[j] / radix) % 10;   //计算每次循环某一位的数字
            count[k]++;    //统计每个桶中的记录数
        }
        for(j = 1; j < 10; j++)
            count[j] = count[j - 1] + count[j];   //第j个桶以及之前所有桶中元素的总数
        for(j = n - 1; j >= 0; j--) {    //将所有桶中记录依次收集到tmp中
            k = (data[j] / radix) % 10;
            tmp[count[k] - 1] = data[j];
            count[k]--;
        }
        for(j = 0; j < n; j++)   //将临时数组的内容复制到data中
            data[j] = tmp[j];
        radix = radix * 10;
    }
    free(tmp);
    free(count);
}



int main()
{
	int num[100]={2,3,4,1,5},n=5;
	//sort(num,0,n-1);//参数为起始元素下标
	//insertsort(num,n);//参数为数组元素个数
	//binsort(num,n);
	//shell(num,n);
	//select(num,n);
	//int temp[100];mergesort(num,0,n-1,temp);
	//HeapSort(num,n);
	//radixsort(num,n);
	for(int i=0;i<n;i++)printf("%d ",num[i]);
	getch();
}