：稀疏数组和队列 -- 稀疏数组链式存储压缩介绍队列

Posted 2022-01-17 CodeJiao

1. 稀疏数组

---

1.1 引入

常见五子棋程序中，有黑子和蓝子棋子，使用二维数组来表示：

0表示默认值，可以发现的是记录了很多没有意义的数据。那么我们思考，如何能够把数据记录优化至最小呢？

1.2 链式存储压缩介绍

---

1.3 稀疏数组介绍

压缩条件：

1. 原数组中存在大量的无效数据，占据了大量的存储空间，真正有用的数据很少
2. 压缩存储可以节省储存空间，避免资源的不必要的浪费，在数据序列化到磁盘时，压缩存储可以提高IO效率。

稀疏数组处理方法：

1. 记录数组一共有几行几列，有多少个不同的值
2. 把具有不同值元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模。

实现步骤：

---

1.4 练习

1. 使用稀疏数组来保留如上二维数组（棋盘）
2. 把稀疏数组存盘可以重新恢复原来的二维数组

示例代码：

package data_structure;

/**
 * 稀疏数组
 */
public class SparseArray 

    public static void main(String[] args) 
        /*
         * 1.模拟出来棋盘数据，使用二维数组
         */
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][4] = 2;

        //打印棋盘查看效果
        for (int[] row : array) 
            for (int val : row) 
                System.out.printf("%d\\t", val);
            
            System.out.println();
        

        /*
         * 需要把如上的二维数组中有效数据压缩至稀疏数组中去
         */
        //计算二维数组中有效数据
        int sum = 0;
        for (int i = 0; i < 11; i++) 
            for (int j = 0; j < 11; j++) 
                if (array[i][j] != 0) 
                    sum++;
                
            
        

        //定义稀疏数组
        int[][] sparseArray = new int[sum + 1][3];
        sparseArray[0][0] = 11;//行
        sparseArray[0][1] = 11;//列
        sparseArray[0][2] = sum;//有效数据个数

        //把有效数据存放至稀疏数组中去
        int count = 0;
        for (int i = 0; i < 11; i++) //行的索引
            for (int j = 0; j < 11; j++) //列的索引
                //判断是否是有效数据
                if (array[i][j] != 0) 
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = array[i][j];
                
            
        

        /*
         * 打印稀疏数组
         */
        for (int i = 0; i < sparseArray.length; i++) 
            System.out.printf("%d,%d,%d\\t", sparseArray[i][0], sparseArray[i][1], sparseArray[i][2]);
        

        /*
         * 把稀疏数组转原始二维数组（面试题）
         */

        int[][] oldArray = new int[sparseArray[0][0]][sparseArray[0][1]];

        for (int i = 1; i <= count; i++) 
            oldArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        

        System.out.println("\\n------------------------------------------");

        /*
         * 原始二维数组棋盘
         */
        for (int[] row : oldArray) 
            for (int val : row) 
                System.out.printf("%d\\t", val);
            
            System.out.println();
        
    

运行结果：

---

2. 队列

---

2.1 队列介绍

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

1. 队列是一个有序列表，可以用数 组和链表来实现
2. 队列先进先出，即是先入队列的数据最先被取出，后存入的数据后取出。

---

2.2 数组模拟队列

• 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量。
• 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front及 rear分别记录队列前后端的下标，front 会随着数据输出而改变，而 rear则是随着数据输入而改变，如图所示：

示意图：(使用数组模拟队列示意图)

ArrayQueue.java

package data_structure;


public class ArrayQueue 

    private final int[] array;

    private final int maxSize;

    private int frontPoint;

    private int rearPoint;


    public ArrayQueue(int maxSize) 
        this.maxSize = maxSize;
        array = new int[maxSize];

        frontPoint = -1;
        rearPoint = -1;

    

    /**
     * 判断当前队列是否已满
     */
    public boolean isFull() 
        return rearPoint == maxSize - 1;
    

    /**
     * 判断是否是空队列
     */
    public boolean isEmpty() 
        return frontPoint == rearPoint;
    

    /**
     * 添加元素进入队列
     */
    public void add(int n) 
        //判断是否已满
        if (isFull()) 
            System.out.println("队列已满");
            return;
        
        rearPoint++;
        array[rearPoint] = n;
    

    /**
     * 获取队列元素并且删除元素，出队列
     */
    public int get() 
        if (isEmpty()) 
            throw new RuntimeException("空队列");
        
        frontPoint++;
        return array[frontPoint];
    

    /**
     * 查看队列中的元素
     */
    public void findQueue() 
        if (isEmpty()) 
            throw new RuntimeException("空队列");
        
        for (int i = frontPoint + 1; i < array.length; i++) 
            System.out.printf("array[%d]=%d\\n", i, array[i]);
        
    

    /**
     * 查看队头元素，不能是出队列
     */
    public int frontQueue() 
        if (isEmpty()) 
            throw new RuntimeException("空队列");
        
        return array[frontPoint + 1];
    

Test.java

package data_structure;


public class Test 
    public static void main(String[] args) 

        ArrayQueue arrayQueue = new ArrayQueue(5);
        arrayQueue.add(1);
        arrayQueue.add(2);
        arrayQueue.add(3);
        arrayQueue.add(4);
        arrayQueue.add(5);
        int i = arrayQueue.get();
        System.out.println(i);
        arrayQueue.findQueue();
    

运行结果：

---

---