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

  • Z时代
  • 2024-01-10
  • 分类：综合

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阶对称矩阵，也可以通过只申请存储下三角（或上三角）矩阵元素所需的二维数组，来达到压缩存储的目的。

不等长的二维数组结构

 1 //对称矩阵的压缩算法
 2 public class SymeMatric {
 3 
 4     double[] a;// 矩阵元素
 5     int n; // 矩阵的阶数
 6     int m;// 一维数组的元素的个数--长度
 7 
 8     public SymeMatric(int n) {
 9         // 对称矩阵中不重复元素，保存到一维数组中所需要的一维数组的长度
10         // 2阶对称矩阵对应(1+2=3)维数组，3阶对称矩阵对应1+2+3=6维数组，
11         // 4阶对称矩阵对应1+2+3+4维数组，n阶对称矩阵对应前n项和，
12         // 所以一维数组的长度m的值为1,2,3...n的前n项和
13         m = n * (n + 1) / 2; 
14         a = new double[m];
15         this.n = n;
16     }
17 
18     // 通过一个二维数组来初始化
19     public void evalute(double[][] b) {
20         int k = 0;
21         for (int i = 0; i < n; i++) {
22             for (int j = 0; j < n; j++) {
23                 // i >= j表示只保存下三角元素
24                 if (i >= j) {
25                     a[k++] = b[i][j];
26                 }
27             }
28         }
29     }
30 
31     // 通过一个一维数组来初始化,那么这个一维数组就是对称矩阵元素的一个副本
32     public void evalute(double[] b) {
33         for (int k = 0; k < m; k++) {
34             a[k] = b[k];
35         }
36     }
37 
38     // 对称矩阵相加
39     public SymeMatric add(SymeMatric b) {
40         SymeMatric t = new SymeMatric(n);
41         int k;
42         for (int i = 1; i <= n; i++) {
43             for (int j = 1; j <= n; j++) {
44                 if (i >= j) {
45                     k = i * (i - 1) / 2 + j - 1;
46                 } else {
47                     k = j * (j - 1) / 2 + i - 1;
48                 }
49                 // 求和
50                 t.a[k] = a[k] + b.a[k];
51             }
52         }
53         return t;
54     }
55 
56     // 打印对称矩阵，这个才是关键！！
57     public void print() {
58         int k;
59         for (int i = 1; i <= n; i++) {
60             for (int j = 1; j <= n; j++) {
61                 if (i >= j) {
62                     k = i * (i - 1) / 2 + j - 1;
63                 } else {
64                     k = j * (j - 1) / 2 + i - 1;
65                 }
66                 System.out.print(" " + a[k]);
67             }
68             System.out.println();
69         }
70     }
71 
72 }

 1 public class Test {
 2     public static void main(String[] args) {
 3         
 4         SymeMatric m1 = new SymeMatric(3);
 5         SymeMatric m2 = new SymeMatric(3);
 6         SymeMatric m3;
 7 
 8         double[][] a = { { 1, 0, 0 }, { 2, 3, 0 }, { 4, 5, 6 } };
 9         double[] b= {1,2,3,4,5,6};
10         
11         m1.evalute(a);
12         m2.evalute(b);
13         
14         m1.print();
15         System.out.println();
16         System.out.println();
17         m2.print();
18     }
19 }

以上是 Java数据结构之对称矩阵的压缩算法--- 的全部内容， 来源链接： utcz.com/z/392498.html

回到顶部