数据结构 排序算法 （插入、快速、Shell、堆、合并）

#include "stdio.h"
#include "time.h"
#include "stdlib.h"

#define MAX 10
#define SWAP(x,y){int t=x;x=y;y=t;}


void RandNumber(int []);//产生随机数
void PrintNumber(int []);//打印
void InsertSort(int []);//插入排序
void BInsertSort(int []);//折半排序（插入升级版）
void ShellSort(int []);//Shell排序(插入升级版)

//快速排序
/*
平均时间 O(nlogn)  最坏情况 O(n2)   辅助空间O(logn)
*/
void QuickSort(int []);
void QSort(int [],int low,int high);
int Partition1(int [],int low,int high);//算法1
int Partition2(int [],int low,int high);//算法2

//合并排序
/*
平均时间 O(nlogn)  最坏情况 O(nlogn)   辅助空间O(n)
*/
void MergeSort(int []);
void MSort(int [],int [],int ,int );
void Merge(int [],int [],int ,int ,int);

//选择排序
void SelectSort(int []);
int SelectMinKey(int [],int);

//堆排序
void HeapSort(int []);
void HeapAdjust(int [],int,int);
void main()
{
	int number[MAX];
	
	InsertSort(number);

	BInsertSort(number);

	ShellSort(number);
	
	QuickSort(number);

	MergeSort(number);
	
	SelectSort(number);
	
	HeapSort(number);
	

}
void RandNumber(int number[])
{
	int i;
	srand(time(NULL));
	printf("排序前：");
	for(i=0;i<MAX;++i)
	{
		number[i] = rand()%100;
		printf("%d ",number[i]);

	}
	printf("\n");
}
void PrintNumber(int number[])
{
	int i;
	printf("排序后：");
	for(i=0;i<MAX;++i)
	{
		printf("%d ",number[i]);
	}
	printf("\n");
}

void InsertSort(int number[])
{
	int i,j,temp;
	printf("-------------插入排序---------------\n");
	RandNumber(number);
	for(i=1;i<MAX;++i)
	{
		temp = number[i];
		for(j=i-1;temp <number[j]&&j>-1;--j)
		{
			number[j+1] = number[j];
		}
		number[j+1] = temp;
	}
	PrintNumber(number);
}
void BInsertSort(int number[])
{
	int i, j, temp;
	int low, high ,mid;
	printf("-------------折半排序---------------\n");
	RandNumber(number);
	for(i=1;i<MAX;++i)
	{
		temp = number[i];
		low = 0;
		high = i-1;
		while(low <= high)
		{
			mid = (low+high)/2;
			if(temp < number[mid])
				high = mid -1;
			else
				low = mid +1;
		}
		for(j=i-1;j>high;--j)
			number[j+1] = number[j];

		number[j+1]= temp;
	}
	PrintNumber(number);

}
void ShellSort(int number[])
{
	int i,j,k,gap;
	int temp;
	printf("-------------Shell排序---------------\n");
	RandNumber(number);
	for(gap=MAX/2;gap>0;gap=gap/2)
	{
		for(k=0;k<gap;++k)
		{
			for(i=k+gap;i<MAX;++i)
			{
				temp = number[i];
				for(j=i-gap;temp<number[j]&&j>=k;j-=gap)
				{
					number[j+gap] = number[j];
				}
				number[j+gap] = temp;
			}
		}
	}
	PrintNumber(number);
}
void QuickSort(int number[])
{
	printf("------------快速排序---------------\n");
	RandNumber(number);
	QSort(number,0,MAX-1);
	PrintNumber(number);
}
void QSort(int number[],int low,int high)
{
	if(low<high)
	{
		int prvotloc = Partition1(number,low,high);
		QSort(number,low,prvotloc-1);
		QSort(number,prvotloc+1,high);
	}
}
int Partition1(int number[],int low,int high)
{
	int temp = number[low];
	while(low<high)
	{
		while(low<high&&temp<=number[high])
			--high;
		SWAP(number[low],number[high]);
		while(low<high&&temp>=number[low])
			++low;
		SWAP(number[low],number[high]);
	}
	return low;
}
int Partition2(int number[],int low,int high)
{
	int l = low;

	while(low<high)
	{
		if(number[high]>=number[low])
		{
			SWAP(number[l],number[low]);
			++l;
		}
		++low;
	}
	SWAP(number[l],number[high]);
	return l;
}

void MergeSort(int number[])
{
	printf("------------合并排序---------------\n");
	RandNumber(number);
	MSort(number,number,0,MAX-1);
	PrintNumber(number);
}
void MSort(int sr[],int number[],int s,int t)
{
	if(s==t)
		number[s]=sr[s];
	else
	{
		int tr[MAX];
		int m = (s+t)/2;
		MSort(sr,tr,s,m);
		MSort(sr,tr,m+1,t);
		Merge(tr,number,s,m,t);
	}
}
/**
合并
讲tr[s...m]和tr[m+1...t]合并到number[s.....t]
*/
void Merge(int tr[],int number[],int s,int m,int t)
{
	int k;
	int i = m+1;
	for(k=s;k<=t;++k)
	{
		if(s<=m&&i<=t)
		{
			if(tr[s]>tr[i]) number[k]=tr[i++];	
			else number[k]=tr[s++];	
		}
		else
		{
			if(s<=m)
				number[k]=tr[s++];
			
			 if(i<=t)
				number[k]=tr[i++];
		}
	}
}
void SelectSort(int number[])
{
	int i;
	int j;
	printf("------------选择排序---------------\n");
	RandNumber(number);
	for(i=0;i<MAX;++i)
	{
		j = SelectMinKey(number,i);
		if(i!=j)
			SWAP(number[i],number[j]);
	}
	PrintNumber(number);
}
int SelectMinKey(int number[],int i)
{
	int min;
	int j;
	min = i;
	for(j=i;j<MAX;++j)
	{
		if(number[min]>number[j])
			min = j;
	}
	return min;

}
void HeapSort(int number[])
{
	printf("-------------堆排序----------------\n");
	RandNumber(number);
	int i;
	for(i=MAX/2-1;i>=0;--i)
		HeapAdjust(number,i,MAX-1);
	for(i=MAX-1;i>0;--i)
	{
		SWAP(number[0],number[i]);
		HeapAdjust(number,0,i);
	}
	PrintNumber(number);
}
void HeapAdjust(int number[],int i,int nLength)
{
	int nChild;
	for(;2*i+1<nLength;i=nChild)
	{
		nChild = 2*i+1;
		if(nChild<nLength-1&&number[nChild+1]>number[nChild])
			++nChild;
		if(number[nChild]>number[i])
		{
			SWAP(number[i],number[nChild]);
		}
		else
			break;
	}
}