数据结构与算法分析10(排序-插入、冒泡、希尔、堆、归并)

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

#define  Heap_LeftChild(i) (2*i+1)

void sort_insert(int [],int);
void sort_bulb(int [],int);
void sort_Shell(int [],int);
void sort_Heap(int [],int);//Delete操作进行排序
void Heap_PrecDown(int [],int,int);//把当前数组的元素构成一个堆
void sort_Merge(int [],int);//归并排序主体程序
void Msort(int[],int [],int ,int );//递归调用Merge完成排序
void Merge(int [],int [],int ,int ,int);//合并
int main()
{
	int a[]={2,558,4,468,7,6,9,1564,275,5,33,44,88,41,75,171,827,255,548,448};
	int N=sizeof(a)/sizeof(int);

	sort_insert(a,N);
	sort_bulb(a,N);
	sort_Shell(a,N);
	sort_Heap(a,N);
	sort_Merge(a,N);

	getchar();
}
void sort_insert(int Origin[],int N)
{
	int i,j,MAX=N,tmp;
	int *a;
	a=(int *) malloc(N*sizeof(int));
	memcpy(a,Origin,N*sizeof(int));
	
	for (i=1;i<MAX;i++)
	{
		tmp=a[i];

		for(j=i;j>0&&tmp<a[j-1];j--)
			a[j]=a[j-1];
		a[j]=tmp;
	}

	printf("sort_insert\n");
	for(i=0;i<MAX;i++)
	{
		if (i%5==0)
		{
			printf("\n");
		}
		printf("%7d",a[i]);
	}
}

void sort_bulb(int Origin[],int N)
{
	int i,j,MAX=N,tmp;
	int *a=(int *) malloc(N*sizeof(int));
	memcpy(a,Origin,N*sizeof(int));

	for(i=0;i<MAX-1;i++)
		for(j=0;j<MAX-i-1;j++)
			if(a[j+1]<a[j])
			{
				tmp=a[j+1];
				a[j+1]=a[j];
				a[j]=tmp;
			}

	printf("\nsort_bulb\n");
	for(i=0;i<MAX;i++)
	{
		if (i%5==0)
		{
			printf("\n");
		}
		printf("%7d",a[i]);
	}
}
void sort_Shell(int Origin[],int N)
{
	int i,j,Increment,tmp;
	int *a=(int *) malloc(N*sizeof(int));
	memcpy(a,Origin,N*sizeof(int));

	for(Increment=N/2;Increment>0;Increment/=2)
		for(i=Increment;i<N;i+=1)
		{
			tmp=a[i];
			for(j=i;j>=Increment&&tmp<a[j-Increment];j-=Increment)
				a[j]=a[j-Increment];//每次只换i-k*Increment位置的元素，而且如果tmp<a[j-Increment]不成立，默认不处理前面的元素
			a[j]=tmp;
		}

		printf("\nsort_Shell\n");
		for(i=0;i<N;i++)
		{
			if (i%5==0)
			{
				printf("\n");
			}
			printf("%7d",a[i]);
		}
}
//对于堆排序，堆的实现就是靠数组。所以，堆排序是对已经存在的数组里的所有元素用上滤或者下虑构成堆
//然后，用同一个堆，进行一个Delete的操作，取出的数放在数组的被腾出来的位置，这样最后没有用额外的存储空间也实现了堆排序
void sort_Heap(int Origin[],int N)
{
	int i,tmp;

	for (i=N/2;i>=0;i--)
		Heap_PrecDown(Origin,i,N);

	for (i=N-1;i>0;i--)//操作到i=1就可以
	{
		tmp=Origin[i];
		Origin[i]=Origin[0];
		Origin[0]=tmp;//相当于完成了一个Delete操作，至于互换元素后的堆构成，由下面的Heap_PrecDown完成
		Heap_PrecDown(Origin,0,i);
	}

	printf("\nsort_Heap\n");
	for(i=0;i<N;i++)
	{
		if (i%5==0)
		{
			printf("\n");
		}
		printf("%7d",Origin[i]);
	}
}
void Heap_PrecDown(int A[],int i,int N)
{
	int tmp,Child;
	
	for (tmp=A[i];Heap_LeftChild(i)<N;i=Child)//i的作用是仅对当前子树所在路径的所有元素进行堆操作。其他的子树，由调用程序中的i--完成
	{
		Child=Heap_LeftChild(i);
		if(Child!=N-1)//N-1是堆数组的最大坐标，有可能在满足i左儿子<N情况下 Child=N-1，即只有左儿子，就不需要两个儿子比大小。单独列出不写为&&是防止A[i+1]的乱访问
			if (A[Child]<A[Child+1])
				Child++;//找到元素值最大的儿子，这里和下面的tmp<A[Child]决定最后的输出是升序还是降序
		if (tmp<A[Child])
			A[i]=A[Child];
		else
			break;
	}

	A[i]=tmp;
}
/************************************************************************/
/*                       归并排序                                        */
/************************************************************************/
void sort_Merge(int A[],int N)
{
	int *TmpArray;

	TmpArray=(int *)malloc(N*sizeof(int));
	if (TmpArray!=NULL)
	{
		Msort(A,TmpArray,0,N-1);
		free(TmpArray);
	}
	

	printf("\nsort_Merge\n");
	for(int i=0;i<N;i++)
	{
		if (i%5==0)
		{
			printf("\n");
		}
		printf("%7d",A[i]);
	}
}
void Msort(int A[],int TmpArray[],int Left,int Right)
{
	int Center;

	if (Left<Right)
	{
		Center=(Left+Right)/2;
		Msort(A,TmpArray,Left,Center);
		Msort(A,TmpArray,Center+1,Right);
		Merge(A,TmpArray,Left,Center+1,Right);
	}
}

void Merge(int A[],int TmpArray[],int Left,int R_Start,int R_End)
{
	int L_End=R_Start-1;
	int i,num=R_End-Left+1;
	int TmpL=Left,TmpR=R_Start;

	while (TmpL<=L_End&&TmpR<=R_End)
		if (A[TmpL]<A[TmpR])
			TmpArray[i++]=A[TmpL++];
		else
			TmpArray[i++]=A[TmpR++];

	while (TmpL<=L_End)
		TmpArray[i++]=A[TmpL++];
	while (TmpR<=R_End)
		TmpArray[i++]=A[TmpR++];
	//这时候，TmpArray已经得到了排序后的数组，但是要移动到A中，因为TmpArray是一个临时分配的内存，需要释放
	//这里，看好怎么对A进行赋值：范围是从Left_S~R_End，所以这两个数要保持不变；方法是同时在同样的范围进行赋值，从R_End开始自减
	//是因为这个算法默认Left_S这个值已经被破坏。注意，因为是递归调用，赋值范围可能是数组中的一小段，所以i只做计数用，不能作为坐标
	for(i=0;i<num;i++,R_End--)
		A[R_End]=TmpArray[R_End];
}