1 稀疏数组

andyonlines

已于 2023-02-09 14:45:26 修改

阅读量193

点赞数

分类专栏：数据结构与算法文章标签： java scala 算法稀疏数组

于 2019-12-26 17:17:05 首次发布

本文链接：https://blog.csdn.net/andyonlines/article/details/103718636

版权

数据结构与算法专栏收录该内容

20 篇文章 0 订阅

订阅专栏

文章目录

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 + ']';
  }
}