数据结构与算法-稀疏数组

1. 数据结构必要知识

1.1 线性结构

• 线性结构是最常用的数据结构，数据元素之间存在一对一的线性关系。

• 线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的。

• 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻的地址信息。

• 线性表结构常见的有：数组，队列，链表，栈

1.2 非线性结构

非线性结构包括：二维数组，多维数组，广义表，树结构，图结构（这就不是一对一了）

2. 什么是稀疏数组？

稀疏数组可以看做是普通数组的压缩，但是这里说的普通数组是指无效数据量远大于有效数据量的数组。

 3. 应用场景

 比如 一些量大，且多数为重复值的时候，可以使用（棋牌，地图等等）

 3.1 举个例子

我们现在要制作一个棋盘游戏.

先不考虑这个棋怎么玩.

我们现在必须要构建出一个二维数组.

如下面所示.

 

类似这个就是一个棋盘

• 用0表示没有被下过的地方
• 用1表示黑子
• 用2表示蓝子

上图的二维数组中大部分值都为0，所以将二维数组转换成为稀释数组,如图所示：

row	col	val
11	11	2
1	2	1
2	3	2

4. 二维数组与稀疏数组的相互转换

4.1 二位数组转稀疏数组思路：

1、首先注意的是，行和列这里设计都从零开始
2、遍历原始二位数组，获取到有效值个数 sum
3、再根据 sum 创建出稀疏数组的长度 sparsearray[sum+1][3]
4、将要二位数组的有效数据存放到稀疏数组中

 4.2 稀疏数组转二维数组思路：

1、先根据稀疏数组的第一行的数据，创建出原始数组的长度
2、在读取稀疏数组的后面行数（第二行开始），将稀疏有效值赋值给原始数组的行列

package com.meiqi;

/**
 * @author Monica
 * @date 2021/11/30 - 16:40
 *
 * 二维数组转稀疏数组
 * 稀疏数组转二维数组
 *
 **/
public class SparseArr {
    public static void main(String[] args) {
        //原始二维数组中的元素个数，初始化为0
        int count = 0;
        //创建个原始的二维数组
        int[][] chessArr = new int[11][11];
        chessArr[1][2] = 1;
        chessArr[2][3] = 2;
        chessArr[10][5] = 1;
        //遍历数组
        for (int[] row : chessArr) {
            for (int data: row) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        
        //得到二维数组中的个数
        for (int i = 0; i < chessArr.length; i++) {
            for (int j = 0; j < chessArr[i].length; j++) {
                if (chessArr[i][j] != 0){
                    count++;
                }
            }
        }
        System.out.println(count);
        //创建稀释数组
        int[][] newArr = new int[count + 1][3];
        newArr[0][0] = 11;
        newArr[0][1] = 11;
        newArr[0][2] = count;
        //将原二维数组中的有效数据放入稀释数组中
        //i表示行，j表示列
        int sum = 0;
        for (int i = 0; i < chessArr.length; i++) {
            for (int j = 0; j < chessArr[i].length; j++) {
                if (chessArr[i][j] != 0){
                    sum++;
                    newArr[sum][0] = i;
                    newArr[sum][1] = j;
                    newArr[sum][2] = chessArr[i][j];
                }
            }
        }
        
        //将稀疏数组转为原二维数组
        for (int i = 0; i < newArr.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n",newArr[i][0],newArr[i][1],newArr[i][2]);
        }
        System.out.println();
        //定义二维数组
        int[][] chessArr2 = new int[newArr[0][0]][newArr[0][1]];

        for (int i = 1; i < newArr.length; i++) {
            chessArr2[newArr[i][0]][newArr[i][1]] = newArr[i][2];
        }
        for (int[] row : chessArr2) {
            for (int data: row) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
    }
}