矩阵存储和特殊矩阵的压缩存储

● 矩阵存储方案
    •直接用二维数组存储
●特殊矩阵可以"压缩"以降低空间需求
    (1)对角矩阵 
    (2)对称矩阵
    (3)上/下三角矩阵 
● 为什么可以降低空间需求,
    因为他们的存储数据有规律,并且可以通过同样的操作,
    来完成相应的目的 , 所以我们改变一下数据结构来满足我们降低存储空间,并且不改变逻辑结构
●我们这里举的例子 ,都是方阵(行数和列数都相同),开拓我们的思维,举出方阵例子, 以供我们构建
对称矩阵
● 定义
    •若一个n阶方阵A[n][n]中的元素满足aij = aji(0<=i,j<=n-1),则称其为n阶对称矩阵
对称矩阵的压缩存储
●策略
    • 存储时可只存储矩阵上三角或下三角中的元素 , 使得对称的元素共享一个存储空间
    •我们先以行序为主序存储其下三角+对角线的元素
    •相当于 n^2个元素, 我们只用存储n(n+1)/2个元素即可.
    •此时 下三角,行序大于列序, 我们可以下三角的下标转化为一位数组里面的位序,这样我们就可以一一对应了
    •通过输入二维坐标,然后转换成一位数组里面的位序,从而输出我们想要的数字
    •我们分析下三角的结构,用元素前面的元素个数来映射一维数组,然后进行位序推算即可
●结构换算
    •通过观察下三角,我们通过位序,就可以算出前面的元素个数,从而计算出对应的一位数组的位序,输出结果
    •这里注意,我们有上下两个区域,上下三角,所以换算前,需要比较一下纵横坐标的大小,
    • 行大于列,得出下三角,直接换算
    • 列大于行,得出是上三角,我们需要把他纵横坐标调换一下,因为这是对称矩阵,再进行换算即可
    • k = i(i+1)/2 , i>=j
    • k = j(j+1)/2 , i

基本运算(方阵阶数为N)

//为N阶对称矩阵初始化存储空间

void Init(int *&b)
{
	b = (int *)malloc(sizeof(int)*N(N+1)/2);
}

---

//将A[i][j]的值存储到b中

void Assign(int b[],int e,int i,int j)
{
	//说明是下三角
	if(i>=j)
	{
		b[i*(i+1)/2+j] = e;
	}
	else
	{
		b[j*(j++1)/2+i] = e;
	}
}

---

//返回存储在b[M]中的A[i][j]值

int Value(int b[],int i,int j)
{
	if(i>=j)
	{
		return b[i*(i+1)/2+j];
	}
	else
	{
		return b[j*(j+1)/2+i];
	}
}

---

//输出压缩存储在b中的对称矩阵

void Disp(int b[]) 
{
	int i,j;
	for(i=0;i
	{
		for(j=0;j
		{
			printf("%4d",Value(b,i,j));			
		}
		printf("\n");
	}
}

---

//销毁存储空间

void Destroy(int b[])
{
	free(b);
}

---

//主函数调用

//主函数调用
int main()
{
	int *b1;
	int i,j,v;
	Init(b1);
	i=0;
	j=0;
	printf("请输入对称矩阵(只需要输入下三角部分即可)");
	for(i=0;i
	{
		printf("输入第%d行的%d个数据元素",i+1,i+1);
		for(j=0;j<=i;j++)
		{
			scanf("%d",&v);
			Assign(b1,v,i,j);
		}
	}
	Disp(b1);
	Destroy(b1);
	return 0;
}

完整代码如下:

#include 
#include 
#define N 4
 
//为N阶对称矩阵初始化存储数据的一维数组B
void Init(int *&b)
{
    b = (int*)malloc(sizeof(int)*(N*(N+1)/2));
}
 
//返回存储在b[M]中，对应二维数组A[i][j]的值
int Value(int b[], int i, int j)
{
    if (i>=j)
        return b[(i*(i+1))/2+j];
    else
        return b[(j*(j+1))/2+i];
}
 
//将e赋值给对应二维数组元素A[i][j]，要存储到B[M]中
void Assign(int b[], int e, int i, int j)
{
    if (i>=j)
        b[(i*(i+1))/2+j] = e;
    else
        b[(j*(j+1))/2+i] = e;
    return;
}
 
//输出压缩存储在b中的对称矩阵
void Disp(int b[])
{
    int i,j;
    for (i=0; i
    {
        for (j=0; j
            printf("%4d",Value(b,i,j));
        printf("\n");
    }
}
 
//销毁存储空间
void Destroy(int b[])
{
    free(b);
}
 
int main()
{
    int *b1;  //指向整型的指针，待初始化
    int i, j;
    int v;
    Init(b1);
    printf("请输入对称矩阵(只需要输入下三角部分即可)\n");
    for(i=0;i
    {
        printf("输入第%d行的%d个数据元素: ", i+1, i+1);
        for(j=0; j<=i; j++)
        {
             scanf("%d", &v);
             Assign(b1, v, i, j);
        }
    }
    Disp(b1);
    Destroy(b1);
    return 0;
}

上三角, 存储结构,完整代码:

#include 
#include 
#define N 4
 
//为N阶对称矩阵初始化存储数据的一维数组B
void Init(int *&b)
{
    b = (int*)malloc(sizeof(int)*(N*(N+1)/2));
}
 
//返回存储在b[M]中，对应二维数组A[i][j]的值
int Value(int b[], int i, int j)
{
	int k1 = 0;
	int k2 = 0;
	k1 = (j*(((2*N)-j)+1))/2+i-j;
	k2 = (i*(((2*N)-i)+1))/2+j-i;
    if (i>j)
	{
//		printf("%d",k1);
        return b[k1];
//		printf("\n");
	}
    else
	{
//		printf("%d",k2);
        return b[k2];
//		printf("\n");
	}
}
 
//将e赋值给对应二维数组元素A[i][j]，要存储到B[M]中
void Assign(int b[], int e, int i, int j)
{
	int k1 = 0;
	int k2 = 0;
	k1 = (j*(((2*N)-j)+1))/2+i-j;
	k2 = (i*(((2*N)-i)+1))/2+j-i;
    if (i>=j)
	{
        b[k1] = e;
//		printf("第%d行,第%d列,赋值为%d",i,j,b[k1]);
//		printf("%d",b[k1]);
	}
    else
	{
        b[k2] = e;
//		printf("第%d行,第%d列,赋值为%d",i,j,b[k2]);
//		printf("%d",b[k2]);
	}
}
 
//输出压缩存储在b中的对称矩阵
void Disp(int b[])
{
    int i,j;
    for (i=0; i
    {
        for (j=0; j
        {
//		printf("第 %d行,第%d列,数值为%d",i,j,Value(b,i,j));
//		printf("\n");
		printf("%d\t",Value(b,i,j));
		}
	printf("\n\n\n");
    }
}
 
//销毁存储空间
void Destroy(int b[])
{
    free(b);
}
 
int main()
{
    int *b1;  //指向整型的指针，待初始化
    int i, j;
    int v;
    Init(b1);
    printf("请输入对称矩阵(只需要输入下三角部分即可)\n");
 
	int k = N;
    for(i=0;i
    {
        printf("输入第%d行的%d个数据元素: ", i+1, k-i);
 
        for(j=i; j
        {
             scanf("%d", &v);
             Assign(b1, v, i, j);
        }
    }
    Disp(b1);
    Destroy(b1);
    return 0;
}