Yong式（杨氏）矩阵的概念与性质 ，以及算法实现

//来源于算法导论思考题 6-3

（1）概念

一个m*n的Yong式矩阵（Yong tableau） 是一个m*n矩阵，其中的每一行的数据都是从左到右排序，每一列的数据都是从上到下排序。Yong 式矩阵中可能会有一些

INF 数据项，表示不存在的元素，所以，Yong式矩阵可能用来存放r<=mn 个有限的数。

比如下面 4*4的原始 Yong式矩阵如



(2)操作与性质

a.在一个给定的非空m*n的Yong式 实现 ExtractMin 操作来移除矩阵中的最小元素，但是保持Yong矩阵的特性 。时间复杂度为O(m+n).下图为ExtractMin 后的矩阵

3 4 9 INF

5 8 16 INF

12 14 INF INF

INF INF INF INF

算法思想将：c 中的移除操作机 Del(0,0)

b将一个新的元素插入到一个未满的m*n Yong式矩阵，同时保持 Yong 式矩阵的特性。时间复杂度为O(m+n).例如添加元素 7后的矩阵

2 3 4 INF

5 8 9 INF

7 14 16 INF

12 INF INF INF

操作过程如下图



算法思想：先给新加入值为Key的元素，选择合适的位置该位置记作X,满足条件： 该位置的左边位置XL中的值不为INF，该位置的上边位置XU中的值不为INF。令matrix[X]=key

对于矩阵中给定位置X

若 matrix[X]>=matrix[XL] && matrix[X]>=matrix[XU]

则 退出

若 matrix[XL]<=matrix[XU]

exchange(matrix[X],matrix[XU])，然后对 位置XU做上述类似操作

若 matrix[XL]>matrix[XU]

exchange(matrix[X],matrix[XL])，然后对位置XL做上述类似操作

c.将矩阵中的位置为(i,j)中的元素移除，同时保持 Yong 式 矩阵的特性。时间复杂度是O(m+n)。例如移除（2,1）后的矩阵

2 3 4 INF

5 8 9 INF

12 16 INF INF

INF INF INF INF

操作过程如下：



算法思想:首先令 matrix[X]=INF,

对于矩阵中给定的某个位置X，右边邻接位置记作 XL，下方邻接位置记作XD

若matrix[XL]<matrix[XD]

exchange(matrix[X],matrix[XL]),然后对位置XL做类似于位置X处的操作

若matrix[XL]>=matrix[XD]

exchange(matrix[X],matrix[XD]),然后对位置XD做类似于位置X处的操作

d.对于一个给定的数key，可以在时间复杂度O(m+n)来查找给元素是否在这个矩阵中。例如查找元素 9，返回位置（1,2）

算法思想：从矩阵的左下角位置X，初始化为（m-1,0）,开始下述搜索

若 matrxi[X]>key

则对X的上边位置XU做类似于X处的操作

若 matrix[X]<key

则对X的右边位置XR做类似于X处的操作

若 matrix[X]==key 或者 X位置 超出矩阵边界

则返回当前位置X，或者返回(-1,-1)表示不存在

查找7 的过程如下



查找7的过程如下



e在不用其他排序算法的帮助下，利用n*n Yong式矩阵 对n^2 个数字进行排序，运行时间O(m+n),可以首先构造一个Yong 矩阵，通过从一个空矩阵中逐个插入元素，时间复杂度是O（n^3），然后逐个移除最小元素直到矩阵为空，时间复杂度是O（n^3），总的来说时间复杂度是O（n^3）

源代码这里是4*4矩阵

#include <iostream>
#define INF 0x7FFFFFFF //相当于正无群大
#define  DIM 4
using namespace std;

int matrix[DIM][DIM]={{2,3,4,INF},{5,8,9,INF},{12,14,16,INF},{INF,INF,INF,INF}};
//int matrix[DIM][DIM]={{INF,INF,INF,INF},{INF,INF,INF,INF},{INF,INF,INF,INF},{INF,INF,INF,INF}};
void ShowMatrix(){//将矩阵中的内容输出
int i,j;
for (i=0;i<DIM;i++)
{
for (j=0;j<DIM;j++)
{
if (matrix[i][j]!=INF)
{
cout<<matrix[i][j]<<"\t";
}
else
{
cout<<"INF"<<"\t";
}
}
cout<<endl;
}
}

void Swap(int &i,int &j){
int temp=i;
i=j;j=temp;
}

void ExtractMin(){//将矩阵中的最小元素移除，但是维持矩阵特性
int i,j;
i=j=0;

bool flag=true;

matrix[0][0]=INF;
while (flag)
{
if (j+1<DIM &&i+1<DIM)
{
if (matrix[i][j+1]<=matrix[i+1][j])
{
Swap(matrix[i][j],matrix[i][j+1]);
j++;
}
else
{
Swap(matrix[i][j],matrix[i+1][j]);
i++;
}
}
else if(i+1==DIM &&j+1<DIM)
{
Swap(matrix[i][j],matrix[i][j+1]);
j++;
}else if (j+1==DIM&&i+1<DIM)
{
Swap(matrix[i][j],matrix[i+1][j]);
i++;
}else{
flag=false;
}

}
}

void InSert(int key){//在矩阵还没有满的情况下可以进行插入元素，并且保证矩阵特性
int i,j;

//first find the appropriate position for key
for (i=0;i<DIM;i++)
{
if (matrix[i][i]==INF)
{
break;
}
}
if (i==DIM)
{//means this matrix is full
return ;
}

for (j=i;j>=0;j--)
{
if (matrix[i][j]!=INF)
{
break;
}
}

//start position
j++;

matrix[i][j]=key;

bool flag=true;
while (flag)
{
if (i-1>=0 && j-1>=0)
{
if (matrix[i][j]>=matrix[i-1][j] && matrix[i][j]>=matrix[i][j-1])
{
flag=false;
}
else
{
if (matrix[i-1][j]<=matrix[i][j-1])
{
Swap(matrix[i][j-1],matrix[i][j]);
j--;
}
else
{	Swap(matrix[i-1][j],matrix[i][j]);
i--;
}
}
}
else if(i==0 && j-1>=0)
{
if (matrix[i][j]>=matrix[i][j-1])
{
flag=false;
}
else
{
Swap(matrix[i][j],matrix[i][j-1]);
j--;
}
}else if(i-1>=0 &&j==0)
{
if (matrix[i][j]>=matrix[i-1][j])
{
flag=false;
}
else
{
Swap(matrix[i][j],matrix[i-1][j]);
i--;
}
}else{
flag=false;
}
}
}

void FindKey(int key,int &tarX,int &tarY){//在矩阵中查找值为key的元素是否存在，如果存在则返回对应坐标，否则返回(-1,-1)
int i,j;
i=DIM-1,j=0;//从左下角开始查找
while (true)
{
if (matrix[i][j]>key)
{
i--;
if (i<0)
{
tarX=-1,tarY=-1;
return ;
}
}
else if(matrix[i][j]<key)
{
j++;
if (j>=DIM)
{
tarX=-1,tarY=-1;
return ;
}
}else
{
tarX=i;
tarY=j;
return ;
}
}
}

void DelKey(int x,int y){//将矩阵中的(x,y)处的元素移除，但是维持矩阵性质
if (x<0||x>=DIM||y<0||y>=DIM)
{//out of boundary
return ;
}

matrix[x][y]=INF;
while (true)
{
if (x+1<DIM && y+1<DIM)
{
if (matrix[x][y+1]<=matrix[x+1][y])
{
Swap(matrix[x][y],matrix[x][y+1]);
y++;
}
else
{
Swap(matrix[x][y],matrix[x+1][y]);
x++;
}
}
else if(x+1==DIM && y+1<DIM)
{
Swap(matrix[x][y],matrix[x][y+1]);
y++;
}
else if (x+1<DIM && y+1==DIM)
{
Swap(matrix[x][y],matrix[x+1][y]);
x++;
}else
{
return ;
}
}
}

int main(int argc,char *argv[]){
int i,j;
/*for (i=1;i<=16;i++)
{
InSert(i);
//ShowMatrix()
}

ShowMatrix();
cout<<endl;
DelKey(3,3);
ShowMatrix();

int tarX,tarY;
FindKey(6,tarX,tarY);

cout<<tarX<<","<<tarY<<endl;
*/
ShowMatrix();
cout<<endl;
//ExtractMin();
//InSert(7);
DelKey(2,1);
ShowMatrix();
return 0;
}