稠密架构和稀疏架构的区别 结构稀疏

1、线性与非线性结构

数据结构包括线性结构与非线性结构。

1.1 线性结构

1、线性结构作为最常用的数据结构，其特点是数据元素之间是一对一的线性关系。

2、线性结构有两种不同的存储结构，即顺序存储结构(数组)和链式存储结构(链表)，顺序存储的线性表成为顺序表，顺序表存储元素是连续的。

3、链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放的是相邻元素的地址。

4、线性结构常见有：数组、链表、栈、队列。

1.2 非线性结构

非线性结构包括：二维数组、多维数组、广义表、树结构、图结构。

2、稀疏数组

2.1 需求引入

编写五子棋程序中的存盘退出和续上盘的功能

 因为二维数组中很多数据为默认值0，记录了很多无效数据，因此可以使用稀疏数组。

2.2 基本介绍

当一个数组大多数值为0或者其他默认值时，可以使用稀疏数组保存该数组。

稀疏数组的处理方法是：

1、记录数组有多少行，多少列，多少个有效值。

2、把有效值的行列和数值存放在小数组中。

 2.3 应用实例

1、用稀疏数组保存前面的二维数组

2、把稀疏数组存盘，并且可以恢复为新的二维数据

3、整体思路分析

 2.4 代码实现

package day01;import java.io.Serializable;

public class Line implements Serializable {
    private int row;
    private int col;
    private int val;

    public int getRow() {
        return row;
    }

    public int getCol() {
        return col;
    }

    public int getVal() {
        return val;
    }

    public Line() {
    }

    public Line(int row, int col, int val) {
        this.row = row;
        this.col = col;
        this.val = val;
    }

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

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

    public void setVal(int val) {
        this.val = val;
    }
}

Line(封装稀疏数组每一行)

package day01;import java.io.*;import java.util.ArrayList;
import java.util.List;

/**
 * 稀疏数组完成棋盘及棋子的保存
 */
public class sparsearray {

    public static void run() {
        // 原始棋盘
        int[][] arr = new int[11][11];
        arr[1][2] = 1;
        arr[2][3] = 2;
        // 打印原始棋盘
        System.out.println("打印原始数组:");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + "  ");
            }
            System.out.println();
        }

        // 转换成稀疏数组
        int num = 0;
        // 获取原二维数组有效棋子个数
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != 0) {
                    num++;
                }
            }
        }
        int[][] sparseArr = new int[num + 1][3];
        sparseArr[0][0] = arr.length;
        sparseArr[0][1] = arr[0].length;
        sparseArr[0][2] = num;
        //装配棋子位置
        int counter = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != 0) {
                    counter++;
                    sparseArr[counter][0] = i;
                    sparseArr[counter][1] = j;
                    sparseArr[counter][2] = arr[i][j];
                }
            }
        }

        // 打印稀疏数组
        System.out.println("打印稀疏数组:");
        // 持久化稀疏数组到本地
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("D:\\store\\IDEA\\designMode\\src\\day01\\map.data"));
            List list = new ArrayList();
            for (int i = 0; i < sparseArr.length; i++) {
                System.out.println(sparseArr[i][0] + " " + sparseArr[i][1] + " " + sparseArr[i][2]);
                list.add(new Line(sparseArr[i][0], sparseArr[i][1], sparseArr[i][2]));
            }
            oos.writeObject(list);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


        // 读取map.data恢复为稀疏数组
        int[][] fileSparseArr = null;
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("D:\\store\\IDEA\\designMode\\src\\day01\\map.data"));
            try {
                List list = (List) ois.readObject();
                fileSparseArr = new int[list.size()][3];
                for (int i = 0; i < list.size(); i++) {
                    Line line = (Line) list.get(i);
                    fileSparseArr[i][0] = line.getRow();
                    fileSparseArr[i][1] = line.getCol();
                    fileSparseArr[i][2] = line.getVal();
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 打印读取的map.data转换的稀疏数组
        System.out.println("打印读取的稀疏数组:");
        for (int i = 0; i < fileSparseArr.length; i++) {
            System.out.println(fileSparseArr[i][0] + " " + fileSparseArr[i][1] + " " + fileSparseArr[i][2]);
        }


    }


    public static void main(String[] args) {
        run();
    }
}

稀疏数组实现存盘及复盘