第六章堆排序之“Young氏矩阵（Young tableau）”（思考题6-3）

这个程序是利用Young氏矩阵为n*n的数组排序。

其中涉及到：插入法建立Young氏矩阵，然后再调用”去掉返回堆顶元素”的函数得到从小到大的排列。总的时间复杂度为O（n^3）。

其中向Young氏矩阵“插入一个元素”的时间复杂度为O（m+n），m为Young氏矩阵的行数，n为Young氏矩阵的列数，建立Young氏矩阵要插入n*n个元素则为O（（n^2）*2n）=O（n^3）。

“去掉返回堆顶元素”因为要借助“堆调整”函数保持Young氏矩阵的性质，所以时间复杂度为O（m+n）。

在排序函数YoungSort中还调用了查找函数YoungSearch，这个其实跟排序没有任何关系，因为排序前先建立Young氏矩阵，所以搭了个便车，建立了Young氏矩阵后立马调用YoungSearch查找了仨数。我知道这样写很容易产生误会，特此说明。这个查找函数YoungSearch（）的思想在函数定义中有详细说明。

详情请看下面代码：

#include <string.h>
#include <time.h>

#define BUFFER_SIZE 3

//Young氏矩阵调整 
void YoungMinHeapIfy(int (*a)[BUFFER_SIZE+1],int i,int j,int m,int n)
{
	int x=0;
	int y=0;
	int tmp=0;
	int min_i=0;
	int min_j=0;
	
	if(j+1<=n&&a[i][j]>a[i][j+1])
	{
		min_i=i;
		min_j=j+1;
	}
	else
	{
		min_i=i;
		min_j=j;
	}
	if(i+1<=m&&a[min_i][min_j]>a[i+1][j])
	{
		min_i=i+1;
		min_j=j;
	}
	if(min_i!=i||min_j!=j)
	{
		tmp=a[i][j];
		a[i][j]=a[min_i][min_j];
		a[min_i][min_j]=tmp;
		
		YoungMinHeapIfy(a,min_i,min_j,m,n);
	}
}
//去掉并返回堆顶元素 
int YoungHeapExtractMin(int (*a)[BUFFER_SIZE+1],int *m,int *n)
{
	int tmp=a[1][1];
	a[1][1]=a[*m][*n];
	if((*n)>1)
	{
		(*n)--;
	}
	else if((*n)==1)
	{
		(*m)--;
		(*n)=BUFFER_SIZE;
	}
	YoungMinHeapIfy(a,1,1,*m,*n);
	return tmp;
} 

//将Young氏矩阵中指定元素(i,j)的关键字减小到key，key要小于(i,j)元素原来的关键字 
void YoungHeapDecreaseKey(int (*a)[BUFFER_SIZE+1],int i,int j,int key)
{
	int min_i=0;
	int min_j=0;
	
	if(a[i][j]<=key)
	{
		return;
	}
	
	a[i][j]=key;
	
	if(j>1&&a[i][j]<a[i][j-1])
	{
		min_i=i;
		min_j=j-1;	
	}
	else
	{
		min_i=i;
		min_j=j;
	}
	if(i>1&&a[min_i][min_j]<a[i-1][j])
	{
		min_i=i-1;
		min_j=j; 
	}
	if(min_i!=i||min_j!=j)
	{
		a[i][j]=a[min_i][min_j];
		YoungHeapDecreaseKey(a,min_i,min_j,key);
	}
	
}

//将一个新元素x插入到Young氏矩阵中
void YoungMinHeapInsert(int (*a)[BUFFER_SIZE+1],int *m,int *n,int x)
{
	if((*n)<BUFFER_SIZE) 
	{
		(*n)++;
	}
	else if((*n)==BUFFER_SIZE)
	{
		(*m)++;
		(*n)=1;
	}
	a[*m][*n]=x+1;
	YoungHeapDecreaseKey(a,*m,*n,x);
}


//查找指定的某元素是否在Young氏矩阵中
void YoungSearch(int (*a)[BUFFER_SIZE+1],int m,int n,int i,int j,int key)
{
	if(i>m||i<1||j>n||j<1)
	{//要是下标超出范围，肯定不存在 
		printf("%d Not Exist!\n",key);
	}
	else if(a[i][j]==key)
	{//每次都先跟最右上角的元素比较，相等就找到了 
		printf("%d is a[%d][%d]!\n",key,i,j);
	}
	else if(a[i][j]>key)
	{//要是小于，就可以去掉最右边一列 
		YoungSearch(a,m,n,i,j-1,key);
	}
	else if(a[i][j]<key)
	{//要是大于就可以去掉最上面一行 
		YoungSearch(a,m,n,i+1,j,key);
	}
	
	//这个查找还有另外一个思路，就是YoungMinHeapInsert的变形，因为里面涉及到比较了，复杂度也是O（m+n） 
}

//用Young氏矩阵对n*n个元素排序
void YoungSort(int (*a)[BUFFER_SIZE+1],int (*b)[BUFFER_SIZE+1],int *c)
{
	int m=1;//此处m要从1开始，因为Young矩阵的第0行第0列我都未用 
	int n=0;
	int i=0;
	int j=0;
	
	for(i=1;i<=BUFFER_SIZE;i++)
	{
		for(j=1;j<=BUFFER_SIZE;j++)
		{//先用插入法建堆 
			YoungMinHeapInsert(a,&m,&n,b[i][j]);
		}
	}

	printf("建立Young氏矩阵：\n");
	for(i=1;i<BUFFER_SIZE+1;i++)
	{
		for(j=1;j<BUFFER_SIZE+1;j++)
		{
			printf("%d\t",a[i][j]);
		}
		printf("\n");
	} 
	
	
	printf("\n试着查找三个数:\n");
	YoungSearch(a,BUFFER_SIZE,BUFFER_SIZE,1,BUFFER_SIZE,-1000); 
	YoungSearch(a,BUFFER_SIZE,BUFFER_SIZE,1,BUFFER_SIZE,1000);
	YoungSearch(a,BUFFER_SIZE,BUFFER_SIZE,1,BUFFER_SIZE,a[1][1]);

	
	for(i=0;i<BUFFER_SIZE*BUFFER_SIZE;i++)
	{//然后再调用去掉返回堆顶元素的函数得到从小到大的排列 
		c[i]=YoungHeapExtractMin(a,&m,&n);
	}
}

int main()
{
	int i=0;
	int j=0;
	int a[BUFFER_SIZE+1][BUFFER_SIZE+1];
	int b[BUFFER_SIZE+1][BUFFER_SIZE+1];
	int c[BUFFER_SIZE*BUFFER_SIZE];
	//随机生成矩阵
	srand((unsigned)time(NULL));
	for(i=1;i<BUFFER_SIZE+1;i++)
	{
		for(j=1;j<BUFFER_SIZE+1;j++)
		{
			b[i][j]=rand()%100;
		}
	} 
	printf("随机生成的n*n矩阵：\n");
	for(i=1;i<BUFFER_SIZE+1;i++)
	{
		for(j=1;j<BUFFER_SIZE+1;j++)
		{
			printf("%d\t",b[i][j]);
		}
		printf("\n");
	} 
	
	
	YoungSort(a,b,c);
	printf("对n*n矩阵进行排序：\n"); 
	for(i=0;i<BUFFER_SIZE*BUFFER_SIZE;i++)
	{
		printf("%d ",c[i]);
	}
	
	system("pause");
	return 0;
}