【数据结构与算法】数组应用3:稀疏矩阵压缩(Java实现)

简介:

    直接看下面的程序代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
package  chapter02;
 
import  java.util.Arrays;
 
/*
  * 稀疏矩阵压缩(简单版)
  */
public  class  CH02_05 {
     public  static  void  main(String[] args) {
         //定义一个稀疏矩阵
         int [][] arr = 
             {
                     { 25 0 0 32 0 , - 25 },
                     { 0 33 77 0 0 0 },
                     { 0 0 0 55 0 0 },
                     { 0 0 0 0 0 0 },
                     { 101 0 0 0 0 0 },
                     { 0 0 38 0 0 0 }
             };
         
         //输出稀疏矩阵
         for ( int  i =  0 ; i < arr.length; i++){
             System.out.println(Arrays.toString(arr[i]));
         }
         
         //压缩稀疏矩阵的准备工作
         int  rows = arr.length;        //稀疏矩阵的行
         int  cols = arr[ 0 ].length;     //稀疏矩阵的列
         int  real =  0 ;                 //稀疏矩阵非0元素
         //遍历获取稀疏矩阵的非0元素个数
         for ( int  i =  0 ; i < rows; i++){
             for ( int  j =  0 ; j < cols; j++){
                 if (arr[i][j] !=  0 ){
                     real +=  1 ;
                 }
             }
         }
         //定义一个数组,用来保存压缩后的稀疏矩阵
         int [][] arrResult =  new  int [real+ 1 ][ 3 ];
         //初始化arrResult
         for ( int  i =  0 ; i < arrResult.length; i++){
             Arrays.fill(arrResult[i],  0 );
         }
         //在arrResult中保存稀疏矩阵的基本信息
         //arrResult[0][0]:稀疏矩阵的行数   arrResult[0][1]:稀疏矩阵的列数     arrResult[0][2]:稀疏矩阵非0元素个数
         arrResult[ 0 ][ 0 ] = rows;
         arrResult[ 0 ][ 1 ] = cols;
         arrResult[ 0 ][ 2 ] = real;
         //输出初始化后的arrResult
         System.out.println();
         for ( int  i =  0 ; i < arrResult.length; i++){
             System.out.println(Arrays.toString(arrResult[i]));
         }
         
         //开始压缩稀疏矩阵
         int  k =  1 ;    //用来记录arrResult到第几行,因为第0行已经用来保存基本信息,所以从第1行开始
         for ( int  i =  0 ; i < rows; i++){
             for ( int  j =  0 ; j < cols; j++){
                 if (arr[i][j] !=  0 ){
                     arrResult[k][ 0 ] = i;
                     arrResult[k][ 1 ] = j;
                     arrResult[k][ 2 ] = arr[i][j];
                     k++;
                 }
             }
         }
         
         //输出压缩后的稀疏矩阵
         System.out.println();
         for ( int  i =  0 ; i < arrResult.length; i++){
             System.out.println(Arrays.toString(arrResult[i]));
         }
 
     }
}

    执行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
[25, 0, 0, 32, 0, -25]
[0, 33, 77, 0, 0, 0]
[0, 0, 0, 55, 0, 0]
[0, 0, 0, 0, 0, 0]
[101, 0, 0, 0, 0, 0]
[0, 0, 38, 0, 0, 0]
 
[6, 6, 8]
[0, 0, 0]
[0, 0, 0]
[0, 0, 0]
[0, 0, 0]
[0, 0, 0]
[0, 0, 0]
[0, 0, 0]
[0, 0, 0]
 
[6, 6, 8]
[0, 0, 25]
[0, 3, 32]
[0, 5, -25]
[1, 1, 33]
[1, 2, 77]
[2, 3, 55]
[4, 0, 101]
[5, 2, 38]



本文转自 xpleaf 51CTO博客,原文链接:http://blog.51cto.com/xpleaf/1976965,如需转载请自行联系原作者
相关文章
|
3月前
|
存储 人工智能 算法
数据结构与算法细节篇之最短路径问题:Dijkstra和Floyd算法详细描述,java语言实现。
这篇文章详细介绍了Dijkstra和Floyd算法,这两种算法分别用于解决单源和多源最短路径问题,并且提供了Java语言的实现代码。
99 3
数据结构与算法细节篇之最短路径问题:Dijkstra和Floyd算法详细描述,java语言实现。
|
3月前
|
存储 缓存 算法
Java 数组
【10月更文挑战第19天】Java 数组是一种非常实用的数据结构,它为我们提供了一种简单而有效的方式来存储和管理数据。通过合理地使用数组,我们能够提高程序的运行效率和代码的可读性。更加深入地了解和掌握 Java 数组的特性和应用,为我们的编程之旅增添更多的精彩。
39 4
|
3月前
|
存储 缓存 算法
提高 Java 数组性能的方法
【10月更文挑战第19天】深入探讨了提高 Java 数组性能的多种方法。通过合理运用这些策略,我们可以在处理数组时获得更好的性能表现,提升程序的运行效率。
45 2
|
3月前
|
存储 Java
Java“(array) <X> Not Initialized” (数组未初始化)错误解决
在Java中,遇到“(array) &lt;X&gt; Not Initialized”(数组未初始化)错误时,表示数组变量已被声明但尚未初始化。解决方法是在使用数组之前,通过指定数组的大小和类型来初始化数组,例如:`int[] arr = new int[5];` 或 `String[] strArr = new String[10];`。
104 2
|
3月前
|
Java
Java数组动态扩容和动态缩减
Java数组动态扩容和动态缩减
30 3
|
3月前
|
存储 Java 程序员
【一步一步了解Java系列】:何为数组,何为引用类型
【一步一步了解Java系列】:何为数组,何为引用类型
37 1
|
3月前
|
存储 算法 Java
带你学习java的数组军队列
带你学习java的数组军队列
41 0
|
8天前
|
Java
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类:`Producer`(生产者)、`Consumer`(消费者)、`Resource`(公共资源)和`TestMain`(测试类)。通过`synchronized`和`wait/notify`机制控制线程同步,但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`,解决了多次生产和消费的问题,但仍可能因`notify()`随机唤醒线程而导致死锁。因此,引入了`notifyAll()`来唤醒所有等待线程,但这会带来性能问题。
Java—多线程实现生产消费者
|
10天前
|
安全 Java Kotlin
Java多线程——synchronized、volatile 保障可见性
Java多线程中,`synchronized` 和 `volatile` 关键字用于保障可见性。`synchronized` 保证原子性、可见性和有序性,通过锁机制确保线程安全;`volatile` 仅保证可见性和有序性,不保证原子性。代码示例展示了如何使用 `synchronized` 和 `volatile` 解决主线程无法感知子线程修改共享变量的问题。总结:`volatile` 确保不同线程对共享变量操作的可见性,使一个线程修改后,其他线程能立即看到最新值。
|
10天前
|
消息中间件 缓存 安全
Java多线程是什么
Java多线程简介:本文介绍了Java中常见的线程池类型,包括`newCachedThreadPool`(适用于短期异步任务)、`newFixedThreadPool`(适用于固定数量的长期任务)、`newScheduledThreadPool`(支持定时和周期性任务)以及`newSingleThreadExecutor`(保证任务顺序执行)。同时,文章还讲解了Java中的锁机制,如`synchronized`关键字、CAS操作及其实现方式,并详细描述了可重入锁`ReentrantLock`和读写锁`ReadWriteLock`的工作原理与应用场景。