这个程序是利用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;
}