1 稀疏数组

已于 2023-02-09 14:45:26 修改
阅读量193 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： java scala 算法 稀疏数组
于 2019-12-26 17:17:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/andyonlines/article/details/103718636
版权

目录

文章目录

1.稀疏数组的定义和使用

数组上大多数的值都是同一个值,就可以用稀疏数组表示,因为很多相同值,所以相同值相当于没有意义的值. 所以稀疏数组的处理方法就是只记录一共有几行几列和那些不同的值就可以:

在这里插入图片描述

2.稀疏数组的实现

使用稀疏数组来保存类似前面的二维数组(现实中类似于棋盘,地图等). ![在这里插入图片描述](https://img-blog.csdnimg.cn/f3a7e7bce7e340dcb8eff796aef2d97d.png)

2.1 稀疏数组的应用java语言实现

package mysqrasearray;

import java.util.Arrays;

/**
 * @author Andy
 * @email andy.gsq@qq.com
 * @date 2023/2/8 12:30:49
 * @desc 使用稀疏数组模拟二维数组(棋盘的棋子)
 */

public class SparseArrayApp {
    public static void main(String[] args) {
        /**
         * 创建一个原始的二维数组 11*11
         *  0:表示没有棋子,1表示黑子,2表示白子
         */
        int[][] old_array = new int[11][11];
        old_array[1][2] = 1;
        old_array[2][3] = 2;
        old_array[4][5] = 2;
        System.out.println("原始数组:");
        showSparseArray(old_array);

        //将二维数组转为稀疏数组
        //1.求出非0数组的个数
        int sum = 0;//用来存储非0个数
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (old_array[i][j] != 0) {
                    sum += 1;
                }
            }
        }

        //2. 创建对应的稀疏数组
        int spareArr[][] = new int[sum + 1][3];
        //多出来的一行(第一行)是用来存放行数总数,列数总数,非0个数
        //给第一行赋值
        spareArr[0][0] = 11;
        spareArr[0][1] = 11;
        spareArr[0][2] = sum;

        //给稀疏数组赋值
        int count = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (old_array[i][j] != 0) {
                    count++;
                    spareArr[count][0] = i;
                    spareArr[count][1] = j;
                    spareArr[count][2] = old_array[i][j];
                }
            }
        }

        //输出稀疏数组
        System.out.println("得到的稀疏数组为:");
        showSparseArray(spareArr);

        //将稀疏数组转换成二维数据
        /**
         * 1.读第一行数据创建二维数组
         * 2.读取后几行并赋给二维数据
         */

        int newArray[][] = new int[spareArr[0][0]][spareArr[0][1]];
        for (int i = 1;i < spareArr.length;i++){
            newArray[spareArr[i][0]][spareArr[i][1]] = spareArr[i][2];
        }

        //输出恢复后的二维数据
        System.out.println("恢复后的二维数组:");
        showSparseArray(newArray);

    }

    /**
     * 输出二维数组
     *
     * @param array
     */
    public static void showSparseArray(int[][] array) {
        for (int i = 0; i < array.length; ++i) {
            System.out.println(Arrays.toString(array[i]));
        }
    }


}

2.2 稀疏数组的应用scala语言实现

package mysqrasearray

import java.util

/**
 *
 * @author Andy
 * @email andy.gsq@qq.com
 * @date 2023/2/8 18:08:07
 * @desc 使用稀疏数组模拟二维数组(棋盘的棋子)scala语言实现
 *
 */

object SparseArrayForScalaApp {
  def main(args: Array[String]): Unit = {

    /**
     * 创建一个原始的二维数组 11*11
     * 0:表示没有棋子,1表示黑子,2表示白子
     */
    val old_array = {
      val arr = Array.ofDim[Int](11, 11)
      arr(1)(2) = 1
      arr(2)(3) = 2
      arr(4)(5) = 2
      arr
    };

    showSparseArray(old_array)
    // 将二维数组转为稀疏数组
    //1.求出非0数组的个数
    var num = 0
    old_array.foreach(arr => {
      arr.foreach(valune => {
        if (valune != 0) {
          num += 1
        }
      })
    })

    //2. 创建对应的稀疏数组
    val spareArr = Array.ofDim[Int](num + 1, 3)

    //多出来的一行(第一行)是用来存放行数总数,列数总数,非0个数
    //给第一行赋值
    spareArr(0)(0) = 11
    spareArr(0)(1) = 11
    spareArr(0)(2) = num

    //给稀疏数组赋值
    var count = 0
    for (i <- 0 until 11) {
      for (j <- 0 until 11) {
        if (old_array(i)(j) != 0) {
          count += 1
          spareArr(count)(0) = i
          spareArr(count)(1) = j
          spareArr(count)(2) = old_array(i)(j)
        }
      }
    }

    //输出稀疏数组
    println("得到的稀疏数组为:")
    showSparseArray(spareArr)

    //将稀疏数组转换成二维数据
    /**
     * 1.读第一行数据创建二维数组
     * 2.读取后几行并赋给二维数据
     */

    val newArray = Array.ofDim[Int](spareArr(0)(0), spareArr(0)(1))
    for (i <- 1 until (spareArr.length)) {
      newArray(spareArr(i)(0))(spareArr(i)(1)) = spareArr(i)(2)
    }

    //输出恢复后的二维数据
    println("恢复后的二维数组:")
    showSparseArray(newArray)


  }
  
  /**
   * 输出二维数组
   *
   * @param array
   */
  def showSparseArray(array: Array[Array[Int]]) = {
    array.foreach(arr => println(util.Arrays.toString(arr)))
  }
}

2.3 稀疏数组的实现类Java语言

package mysqrasearray;

import java.util.ArrayList;
import java.util.Arrays;

/**
 * @author Andy
 * @email andy.gsq@qq.com
 * @date 2023/2/8 22:32:02
 * @desc TODO
 */

public class SparseArrayForJava {

  public static void showSparseArray(Object[][] array) {
    for (int i = 0; i < array.length; ++i) {
      System.out.println(Arrays.toString(array[i]));
    }
  }
  public static void main(String[] args) {
    Integer[][] old_array = new Integer[11][11];
    old_array[1][2] = 1;
    old_array[2][3] = 2;
    old_array[4][5] = 2;
    System.out.println("原始数组:");
    showSparseArray(old_array);
    SparseArray sparseArray = new SparseArray<Integer>(old_array);

    sparseArray.showSparseArray();

    Object[][] new_array = sparseArray.sparseArrToTwoDim();
    showSparseArray(old_array);
  }


}

/**
 * 定义稀疏数组类
 */
class SparseArray <T>{
  private int size; //稀疏数组的size
  private int totalRow;//总行数
  private int totalCol;//总列数
  private Object defaultValue;//默认值,就是二维数组中占大多数的值

  private ArrayList<Node> ele;

  public Object getDefaultValue() {
    return defaultValue;
  }

  public void setDefaultValue(Object defaultValue) {
    this.defaultValue = defaultValue;
  }
  public SparseArray() {
    this.totalRow = 0;
    this.totalCol = 0;
    this.size = 0;
    this.ele = new ArrayList<>();
  }

  public SparseArray(int totalRowTemp,int totalColTemp,ArrayList<Node> eleTemp) {
    this.totalRow = totalRowTemp;
    this.totalCol = totalColTemp;
    this.size = eleTemp.size();
    this.ele = eleTemp;
  }

  public SparseArray(Object defaultValueTemp,int totalRowTemp,int totalColTemp,ArrayList<Node> eleTemp) {
    this.defaultValue = defaultValueTemp;
    this.totalRow = totalRowTemp;
    this.totalCol = totalColTemp;
    this.size = eleTemp.size();
    this.ele = eleTemp;
  }

  public SparseArray(T[][] arr){
    this.ele = new ArrayList<>();
    twoDimToSparseArr(arr);
  }
  public SparseArray(T defaultValueTemp,T[][] arr){
    this.ele = new ArrayList<>();
    this.defaultValue = defaultValueTemp;
    twoDimToSparseArr(arr);
  }

  public void add(Node node){
    this.ele.add(node);
  }

  public void add(int row, int col, Object value){
    this.ele.add(new Node(row,col,value));
    this.size ++;
  }

  /**
   * 显示稀疏数组
   */
  public void showSparseArray(){
    System.out.println("totalRow: " + this.totalRow + ", " +
            "totalCol: " + this.totalCol + ", " +
            "size: " + this.size);
    for(Node node: this.ele){
      System.out.println(node.toString());
    }
  }

  public boolean isEmpty() {
    return this.size == 0;
  }

  /**
   * 把二维数组转成稀疏数组
   * @param arr 二维数组
   */
  private void twoDimToSparseArr(T[][] arr){
    this.totalRow = arr.length;
    this.totalCol = arr[0].length;
    for(int i = 0;i < arr.length;i++){
      for (int j = 0;j < arr[i].length;j++){
        if(arr[i][j] != null && !arr[i][j].equals(defaultValue)){
          add(i,j,arr[i][j]);
        }
      }
    }
  }

  /**
   * 把稀疏数组转成二维数组
   *
   * @return
   */
  public Object[][] sparseArrToTwoDim(){
    Object[][] arr = new Object[this.totalRow][this.totalCol];
    //如果defaultValue不为null,需要将default值赋给数组
    if(this.defaultValue != null){
      for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr[i].length; j++) {
          arr[i][j] = this.defaultValue;
        }
      }
    }
    if(this.size == 0)
      return arr;
    for(Node node : this.ele){
      arr[node.getRow()][node.getCol()] = (T) node.getValue();
    }
    return arr;
  }

}

/**
 * 用来存放二维数组中的非默认值的行,列,值
 * 在java中使用泛型就是受罪,所以用Object来代替泛型
 */
class Node {
  private int row = 0; //行
  private int col = 0; //列
  private Object value; //值

  public Node() {
  }

  public Node(int row, int col, Object value) {
    this.row = row;
    this.col = col;
    this.value = value;
  }

  public int getRow() {
    return row;
  }

  public void setRow(int row) {
    this.row = row;
  }

  public int getCol() {
    return col;
  }

  public void setCol(int col) {
    this.col = col;
  }

  public Object getValue() {
    return value;
  }

  public void setValue(Object value) {
    this.value = value;
  }

  @Override
  public String toString() {
    return "[" + row + ", " + col + ", " + value + ']';
  }
}
andyonlines
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构实验之数组二：稀疏矩阵
林鹏
08-04 252
数据结构实验之数组二：稀疏矩阵 Time Limit: 5 ms Memory Limit: 1000 KiB Submit Statistic Discuss Problem Description 对于一个n*n的稀疏矩阵M(1 &lt;= n &lt;= 1000)，采用三元组顺序表存储表示，查找从键盘输入的某个非零数据是否在稀疏矩阵中，如果存在则输出OK，不存在则输出ERROR。稀...
1-稀疏数组
一个好人的博客
06-03 55
稀疏数组 基本介绍: 当一个数组中大部分元素为0,或者为同一个值的时候,可以使用稀疏数组来保存该数组 稀疏数组的处理方法: 记录数组一共几列几行,有多少不同的值 比如一个数组六行七列,一共存储了8个值,正常存储就是42个格子,但是我们可以弄一个新的数组,这个数组第一行,记录(6,7,8),代表压缩前数组是6行7列一共八个值,然后第二行(0,3,22)代表下标为(0,3)的格子存放数值22,一次类推,八个值用八行就可以存储完,那么最终的稀疏数组是9行3列,占用了27个格子,相比较原始数组,我们占用
数据结构（10）— 数组、稀疏矩阵
07-30 2174
数据结构（10）— 数组、稀疏矩阵(mi6236)一、数组数组是具有相同类型的变量，其中各个元素共用一个数组名，但是有不同的下标来访问。对于二维数组来说，给定维数和下标，如何得到数组元素存储位置？设每个数组占用1个内存单元，则二维数组Amn按行优先顺序(下标从1开始)，aij的地址为：LOC(aij)=LOC(a11)+((i-1)*n+(j-1))*1。二维数组Amn按列优先顺序(下
数据结构--数组--稀疏矩阵的建立
复兴之路
07-31 1924
稀疏矩阵的建立 #include "stdio.h" #define MAX_SIZE 50 /* 最大的稀疏矩阵 */ typedef enum {head, entry} tagfield; //行链表的头指针和列链表的头指针 struct entry_node { //非零元节点 int row; //非零元所在行的下标 int c
稀疏矩阵数组实现
qq_41785852的博客
08-05 134
稀疏矩阵数组实现
Sparsearray稀疏数组原理及实例详解
08-19
Sparsearray稀疏数组原理及实例详解 Sparsearray稀疏数组是一种特殊的数组结构，它可以用来存储大部分元素为固定值的数组。稀疏数组的主要思想是只记录非默认值的元素及其坐标，从而减小存储空间。 稀疏数组的引入...
稀疏数组的实现java代码
04-18
2)根据sum就可以创建稀疏数组是sparseArr int[sum+1][3] 3)将二维数组的有效的数据存入到稀疏数组 <二 >稀疏数组 转 二维数组的思路 1)先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面...
cpp代码-C++实现稀疏数组
07-14
在IT领域，尤其是在编程中，稀疏数组是一个重要的数据结构概念，特别是在处理大规模数据时，当实际非零元素远少于整个数组元素时，稀疏数组可以极大地节省存储空间。本教程将深入探讨C++中如何实现稀疏数组，以及其...
JavaScript中利用Array filter() 方法压缩稀疏数组
10-18
1. 压缩稀疏数组的空缺： ```javascript var sparse = [1, , 3, , 5]; // 稀疏数组 var dense = sparse.filter(function(currentValue) { return true; // 返回true，保留所有元素 }); console.log(dense); //...
数据结构–稀疏数组（Java实现）
12-21
数据结构–稀疏数组（Java实现） 博客说明 文章所涉及的资料来自互联网整理和个人总结，意在于个人学习和经验汇总，如有什么地方侵权，请联系本人删除，谢谢！ 简介 稀疏数组是普通数组的压缩，普通数组指的是无效...
什么是稀疏数组？
m0_50786325的博客
03-09 378
稀疏数组一般使用在一个二维数组存储着大量无效数据的场景中。举个例子：一个二维数组存储了100个数据，有效数据只有2个，这种情况就可以考虑使用稀疏数组来存储。
稀疏数组详解
m0_52209438的博客
09-17 1097
稀疏数组 一、什么是稀疏数组？ 1、系数矩阵的官方定义 在矩阵中，若数值为0的元素数目远远多于非0元素的数目，并且非0元素分布没有规律时，则称该矩阵为稀疏矩阵；与之相反，若非0元素数目占大多数时，则称该矩阵为稠密矩阵。定义非零元素的总数比上矩阵所有元素的总数为矩阵的稠密度。 2、稀疏数组 当一个数组中大部分元素为0，或者为同一值（也就是说可以不是0）的数组时，可以使用系数数组来保存该数组。 2.1、大部分怎么去理解 通常认为矩阵中非零元素的总数比上矩阵所有元素总数的值小于等于0.05时，则称该矩阵为稀疏矩阵
数组和矩阵
qq_32092437的博客
02-27 263
1、构造数组的方法：增量发和linspace(first,last,num)first和last为起始和终止数，num为需要的数组元素个数。 2、构造矩阵的方法：可以直接用[ ]来输入数组，也可以用以下提供的函数来生成矩阵。 ones( )   创建一个所有元素都为1的矩阵，其中可以制定维数，1，2….个变量 zeros()   创建一个所有元素都为0的矩阵 eye()     创建对角元
HDU 3306
weixin_30437847的博客
09-01 184
先转一些 http://www.cnblogs.com/frog112111/archive/2013/05/19/3087648.html Fibonacci数列：F(0)=1 , F(1)=1 , F(n)=F(n-1)+F(n-2) 我们以前快速求Fibonacci数列第n项的方法是 构造常系数矩阵 （一） Fibonacci数列f[n]=f[n-1]+f[n-2],f[1]=...
稀疏矩阵的三元组表示
m0_45920074的博客
11-11 4080
稀疏矩阵的三元组表示 数据结构作业想找个方式保留下来[嘿嘿] 掌握稀疏矩阵的特点(三元组存储方法)。 掌握稀疏矩阵的三元组存储方法。 稀疏矩阵的存储及基本运算。 （1）针对给出的两个稀疏矩阵a和b，分别输出各自的三元组表示形式。 其中，a，b矩阵表示如下： a，b矩阵三元组表示形式，预期结果下图所示： ```cpp #include<iostream> #include<bits/stdc++.h> #define M 4 #define N 4 #define
数组（稀疏矩阵）
lumaomao_的专栏
01-28 723
typedef struct { int i,j; int value; }Triple; typedef struct { Triple data[MAXSIZE]; int rpos[MAXRC]; int row,col,num; }XiShuArray; int triarray(XiShuArray &M) // 创建一个稀疏矩阵； // 输入行数、列数
数组与稀疏矩阵
我只钓小鱼的博客
04-27 452
数组与稀疏矩阵
使用js完成把稀疏数组变为不稀疏数组
最新发布
05-25
可以使用 JavaScript 中的 `Array.prototype.filter()` 方法来将稀疏数组变为不稀疏数组。 例如，假设有以下稀疏数组： ```js const sparseArray = [1, , 2, , , 3]; ``` 可以使用 `filter()` 方法过滤掉数组中的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值