Java数据结构之对称矩阵的压缩算法---

特殊矩阵

特殊矩阵是指这样一类矩阵，其中有许多值相同的元素或有许多零元素，且值相同的元素或零元素的分布有一定规律。一般采用二维数组来存储矩阵元素。但是，对于特殊矩阵，可以通过找出矩阵中所有值相同元素的数学映射公式，只存储相同元素的一个副本，从而达到压缩存储数据量的目的。

特殊矩阵的压缩存储

只存储相同矩阵元素的一个副本。此种压缩存储方法是：找出特殊矩阵数据元素的分布规律，只存储相同矩阵元素的一个副本。

n阶对称矩阵的压缩存储对应关系

  aij=aji   1<=i<=n,1<=j<=n

 

 元素个数m = n*(n+1)/2

打印对称矩阵第i行,第j列的元素，与一维数组的下标关系为：

         i*(i-1)/2+j-1  当i>=j

 k=

         j*(j-1)/2+i-1  当i<j

 

采用不等长的二维数组

Java语言支持不等长的二维数组，对于n阶对称矩阵，也可以通过只申请存储下三角（或上三角）矩阵元素所需的二维数组，来达到压缩存储的目的。

不等长的二维数组结构

//对称矩阵的压缩算法
public class SymeMatric {

    double[] a;// 矩阵元素
    int n; // 矩阵的阶数
    int m;// 一维数组的元素的个数--长度

    public SymeMatric(int n) {
        // 对称矩阵中不重复元素，保存到一维数组中所需要的一维数组的长度
        // 2阶对称矩阵对应(1+2=3)维数组，3阶对称矩阵对应1+2+3=6维数组，
        // 4阶对称矩阵对应1+2+3+4维数组，n阶对称矩阵对应前n项和，
        // 所以一维数组的长度m的值为1,2,3...n的前n项和
        m = n * (n + 1) / 2; 
        a = new double[m];
        this.n = n;
    }

    // 通过一个二维数组来初始化
    public void evalute(double[][] b) {
        int k = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                // i >= j表示只保存下三角元素
                if (i >= j) {
                    a[k++] = b[i][j];
                }
            }
        }
    }

    // 通过一个一维数组来初始化,那么这个一维数组就是对称矩阵元素的一个副本
    public void evalute(double[] b) {
        for (int k = 0; k < m; k++) {
            a[k] = b[k];
        }
    }

    // 对称矩阵相加
    public SymeMatric add(SymeMatric b) {
        SymeMatric t = new SymeMatric(n);
        int k;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (i >= j) {
                    k = i * (i - 1) / 2 + j - 1;
                } else {
                    k = j * (j - 1) / 2 + i - 1;
                }
                // 求和
                t.a[k] = a[k] + b.a[k];
            }
        }
        return t;
    }

    // 打印对称矩阵，这个才是关键！！
    public void print() {
        int k;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (i >= j) {
                    k = i * (i - 1) / 2 + j - 1;
                } else {
                    k = j * (j - 1) / 2 + i - 1;
                }
                System.out.print(" " + a[k]);
            }
            System.out.println();
        }
    }

}

public class Test {
    public static void main(String[] args) {
        
        SymeMatric m1 = new SymeMatric(3);
        SymeMatric m2 = new SymeMatric(3);
        SymeMatric m3;

        double[][] a = { { 1, 0, 0 }, { 2, 3, 0 }, { 4, 5, 6 } };
        double[] b= {1,2,3,4,5,6};
        
        m1.evalute(a);
        m2.evalute(b);
        
        m1.print();
        System.out.println();
        System.out.println();
        m2.print();
    }
}