第3章稀疏数组和队列

3.1 稀疏sparsearray 数组

3.1.1先看一个实际的需求

编写的五子棋程序中，有存盘退出和续上盘的功能。
image.png
分析问题:
因为该二维数组的很多值是默认值0, 因此记录了很多没有意义的数据.->稀疏数组。

3.1.2基本介绍

当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方法是:
1) 记录数组一共有几行几列，有多少个不同的值
2) 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
 稀疏数组举例说明
image.png

3.1.3应用实例

1) 使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)
2) 把稀疏数组存盘，并且可以从新恢复原来的二维数组数
3) 整体思路分析
image.png
二维数组 转 稀疏数组的思路
1. 遍历 原始的二维数组，得到有效数据的个数 sum
2. 根据sum 就可以创建 稀疏数组 sparseArr int[sum + 1] [3]
3. 将二维数组的有效数据数据存入到 稀疏数组
稀疏数组转原始的二维数组的思路
1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的 chessArr2 = int [11][11]
2. 在读取稀疏数组后几行的数据，并赋给 原始的二维数组 即可.

4) 代码实现

  1. package com.atguigu.sparsearray;
  2. public class SparseArray {
  3.     public static void main(String[] args) {
  4.         // 创建一个原始的二维数组11 * 11
  5.         // 0: 表示没有棋子， 1 表示黑子2 表蓝子
  6.         int chessArr1[][] = new int[11][11];
  7.         chessArr1[1][2] = 1;
  8.         chessArr1[2][3] = 2;
  9.         chessArr1[4][5] = 2;
  11.         // 输出原始的二维数组
  12.         System.out.println("原始的二维数组~~");
  13.         for (int[] row : chessArr1) {
  14.             for (int data : row) {
  15.                   System.out.printf("%d\t", data);
  16.              }
  17.              System.out.println();
  18.             }
  19.         // 将二维数组转稀疏数组的思
  20.         // 1. 先遍历二维数组得到非0 数据的个数
  21.         int sum = 0;
  22.         for (int i = 0; i < 11; i++) {
  23.             for (int j = 0; j < 11; j++) {
  24.                 if (chessArr1[i][j] != 0) {
  25.                     sum++;
  26.                 }
  27.             }
  28.         }
  29.         // 2. 创建对应的稀疏数组
  30.         int sparseArr[][] = new int[sum + 1][3];
  31.         // 给稀疏数组赋值
  32.         sparseArr[0][0] = 11;
  33.         sparseArr[0][1] = 11;
  34.         sparseArr[0][2] = sum;
  36.         // 遍历二维数组，将非0 的值存放到sparseArr 中
  37.         int count = 0; //count 用于记录是第几个非0 数据
  38.         for (int i = 0; i < 11; i++) {
  39.             for (int j = 0; j < 11; j++) {
  40.                 if (chessArr1[i][j] != 0) {
  41.                     count++;
  42.                     sparseArr[count][0] = i;
  43.                     sparseArr[count][1] = j;
  44.                     sparseArr[count][2] = chessArr1[i][j];
  45.                 }
  46.             }
  47.         }
  49.         // 输出稀疏数组的形式
  50.         System.out.println();
  51.         System.out.println("得到稀疏数组为~~~~");
  52.         for (int i = 0; i < sparseArr.length; i++) {
  53.                 System.out.printf("%d\t%d\t%d\t\n", sparseArr[i][0], sparseArr[i][1], sparseArr[i][2]);
  54.         }
  55.         System.out.println();
  57.         //将稀疏数组--》恢复成原始的二维数组
  58.         /*
  59.         * 1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的chessArr2 = int
  60.         [11][11]
  62.         2. 在读取稀疏数组后几行的数据，并赋给原始的二维数组即可.
  63.         */
  65.         //1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
  66.         int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
  68.         //2. 在读取稀疏数组后几行的数据(从第二行开始)，并赋给原始的二维数组即可
  69.         for(int i = 1; i < sparseArr.length; i++) {
  70.             chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
  71.         }
  73.         // 输出恢复后的二维数组
  74.         System.out.println();
  75.         System.out.println("恢复后的二维数组");
  76.         for (int[] row : chessArr2) {
  77.             for (int data : row) {
  78.                 System.out.printf("%d\t", data);
  79.             }
  80.         System.out.println();
  81.         }
  82.     }
  83. }

image.png

3.1.4 课后练习

要求：
1) 在前面的基础上，将稀疏数组保存到磁盘上，比如map.data
2) 恢复原来的数组时，读取map.data 进行恢复
代码见：二维数组与稀疏数组互相转换（先存入磁盘再读取恢复）

3.2 队列

3.2.1 队列的一个使用场景

银行排队的案例:
image.png

3.2.2 队列介绍

1) 队列是一个有序列表，可以用数组或是链表来实现。
2) 遵循先入先出（FIFO）的原则。即：先存入队列的数据，要先取出。后存入的要后取出
3) 示意图：(使用数组模拟队列示意图)
image.png

3.2.3数组模拟队列思路

  • 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中maxSize 是该队

列的最大容量。

  • 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量front 及rear 分别记录队列前后端的下标，

front 会随着数据输出而改变，而rear 则是随着数据输入而改变，如图所示:

image.png

  • 当我们将数据存入队列时称为”addQueue”，addQueue 的处理需要有两个步骤：思路分析

1) 将尾指针往后移：rear+1 , 当front == rear 【空】
2) 若尾指针rear 小于队列的最大下标maxSize-1，则将数据存入rear 所指的数组元素中，否则无法存入数据。
rear == maxSize - 1[队列满]

  • 代码实现 ```java package com.atguigu.queue; import java.util.Scanner; public class ArrayQueueDemo { public static void main(String[] args) {
    1.   //测试一把
    2.   //创建一个队列
    3.   ArrayQueue queue = new ArrayQueue(3);
    4.   char key = ' '; //接收用户输入
    5.   Scanner scanner = new Scanner(System.in);//
    6.   boolean loop = true;
    7.   //输出一个菜单
    8.   while(loop) {
    9.   System.out.println("s(show): 显示队列");
    10.   System.out.println("e(exit): 退出程序");
    11.   System.out.println("a(add): 添加数据到队列");
    12.   System.out.println("g(get): 从队列取出数据");
    13.   System.out.println("h(head): 查看队列头的数据");
    14.   key = scanner.next().charAt(0);//接收一个字符
    15.   switch (key) {
    16.       case 's':
    17.           queue.showQueue();
    18.       break;
    19.       case 'a':
    20.           System.out.println("输出一个数");
    21.           int value = scanner.nextInt();
    22.           queue.addQueue(value);
    23.       break;
    24.       case 'g': //取出数据
    25.           try {
    26.               int res = queue.getQueue();
    27.               System.out.printf("取出的数据是%d\n", res);
    28.           } catch (Exception e) {
    29.               // TODO: handle exception
    30.               System.out.println(e.getMessage());
    31.           }
    32.          break;
    33.       case 'h': //查看队列头的数据
    34.           try {
    35.               int res = queue.headQueue();
    36.               System.out.printf("队列头的数据是%d\n", res);
    37.           } catch (Exception e) {
    38.               // TODO: handle exception
    39.               System.out.println(e.getMessage());
    40.           }
    41.       break;
    42.       case 'e': //退出
    43.           scanner.close();
    44.           loop = false;
    45.       break;
    46.       default:
    47.       break;
    48.       }
    49.   }
    50.   System.out.println("程序退出~~");
    } }

// 使用数组模拟队列-编写一个ArrayQueue 类 class ArrayQueue { private int maxSize; // 表示数组的最大容量 private int front; // 队列头 private int rear; // 队列尾 private int[] arr; // 该数据用于存放数据, 模拟队列

        // 创建队列的构造器
        public ArrayQueue(int arrMaxSize) {
            maxSize = arrMaxSize;
            arr = new int[maxSize];
            front = -1; // 指向队列头部，分析出front 是指向队列头的前一个位置.
            rear = -1; // 指向队列尾，指向队列尾的数据(即就是队列最后一个数据)
          }

        // 判断队列是否满
        public boolean isFull() {
            return rear == maxSize - 1;
        }
        // 判断队列是否为空
        public boolean isEmpty() {
            return rear == front;
        }

        // 添加数据到队列
        public void addQueue(int n) {
            // 判断队列是否满
            if (isFull()) {
                System.out.println("队列满，不能加入数据~");
                return;
            }
            rear++; // 让rear 后移
            arr[rear] = n;
          }

        // 获取队列的数据, 出队列
        public int getQueue() {
            // 判断队列是否空
            if (isEmpty()) {
            // 通过抛出异常
                   throw new RuntimeException("队列空，不能取数据");
            }
            front++; // front 后移
            return arr[front];
        }

        // 显示队列的所有数据
        public void showQueue() {
            // 遍历
            if (isEmpty()) {
                System.out.println("队列空的，没有数据~~");
                   return;
            }
            for (int i = 0; i < arr.length; i++) {
                System.out.printf("arr[%d]=%d\n", i, arr[i]);
            }
        }

        // 显示队列的头数据， 注意不是取出数据
        public int headQueue() {
            // 判断
            if (isEmpty()) {
                throw new RuntimeException("队列空的，没有数据~~");
            }
        return arr[front + 1];
           }
    }

![image.png](https://cdn.nlark.com/yuque/0/2021/png/2196885/1617889191003-63452466-4882-442c-a920-5351af46745d.png#align=left&display=inline&height=193&margin=%5Bobject%20Object%5D&name=image.png&originHeight=385&originWidth=480&size=22721&status=done&style=none&width=240)

<a name="X4qRm"></a>
#### 问题分析并优化-环形队列
1) 目前数组使用一次就不能用， 没有达到复用的效果<br />2) 将这个数组使用算法，改进成一个环形的队列取模：%

<a name="hFGL6"></a>
### 3.2.4数组模拟环形队列
对前面的数组模拟队列的优化，充分利用数组. 因此将数组看做是一个环形的。(通过取模的方式来实现即可)<br />**分析说明：**<br />1) 尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定,这个在做判断队列满的<br />时候需要注意(rear + 1) % maxSize == front 满]<br />2) rear == front [空]<br />3) 分析示意图:<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/2196885/1617889292557-fb6ea778-3f8a-414a-818c-a342c7e57142.png#align=left&display=inline&height=215&margin=%5Bobject%20Object%5D&name=image.png&originHeight=430&originWidth=822&size=226630&status=done&style=none&width=411)<br />**思路如下: （不局限于下面这种）**<br />1. front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素  front 的初始值 = 0 <br />2.  rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定. rear 的初始值 = 0 <br />3. 当队列满时，条件是  (rear  + 1) % maxSize == front 【满】 <br />4. 对队列为空的条件， rear == front 空 <br />5. 当我们这样分析， 队列中有效的数据的个数   (rear + maxSize - front) % maxSize   // rear = 1 front = 0  <br />6. 我们就可以在原来的队列上修改得到，一个环形队列 


**代码实现**
```java
package com.atguigu.queue;
import java.util.Scanner;
public class CircleArrayQueueDemo {
    public static void main(String[] args) {
        //测试一把
        System.out.println("测试数组模拟环形队列的案例~~~");
        // 创建一个环形队列
        CircleArray queue = new CircleArray(4); //说明设置4, 其队列的有效数据最大是3
        char key = ' '; // 接收用户输入
        Scanner scanner = new Scanner(System.in);//
        boolean loop = true;
        // 输出一个菜单
        while (loop) {
            System.out.println("s(show): 显示队列");
            System.out.println("e(exit): 退出程序");
            System.out.println("a(add): 添加数据到队列");
            System.out.println("g(get): 从队列取出数据");
            System.out.println("h(head): 查看队列头的数据");
            key = scanner.next().charAt(0);// 接收一个字符
            switch (key) {
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.println("输出一个数");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g': // 取出数据
                    try {
                        int res = queue.getQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h': // 查看队列头的数据
                    try {
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                    } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e': // 退出
                    scanner.close();
                        loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出~~");
    }
}



class CircleArray {
    private int maxSize; // 表示数组的最大容量
    //front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说arr[front] 就是队列的第一个元素
    //front 的初始值= 0
    private int front;
    //rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定.
    //rear 的初始值= 0
    private int rear; // 队列尾
    private int[] arr; // 该数据用于存放数据, 模拟队列

    public CircleArray(int arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        }

    // 判断队列是否满
    public boolean isFull() {
        return (rear + 1) % maxSize == front;
    }

    // 判断队列是否为空
    public boolean isEmpty() {
        return rear == front;
    }

    // 添加数据到队列
    public void addQueue(int n) {
        // 判断队列是否满
        if (isFull()) {
            System.out.println("队列满，不能加入数据~");
            return;
        }
        //直接将数据加入
        arr[rear] = n;
        //将rear 后移, 这里必须考虑取模
        rear = (rear + 1) % maxSize;
    }

    // 获取队列的数据, 出队列
    public int getQueue() {
        // 判断队列是否空
        if (isEmpty()) {
            // 通过抛出异常
            throw new RuntimeException("队列空，不能取数据");
        }
        // 这里需要分析出front 是指向队列的第一个元素
        // 1. 先把front 对应的值保留到一个临时变量
        // 2. 将front 后移, 考虑取模
        // 3. 将临时保存的变量返回
        int value = arr[front];
        front = (front + 1) % maxSize;
        return value;
    }

    // 显示队列的所有数据
    public void showQueue() {
        // 遍历
        if (isEmpty()) {
            System.out.println("队列空的，没有数据~~");
            return;
        }
        // 思路：从front 开始遍历，遍历多少个元素
        // 动脑筋
        for (int i = front; i < front + size() ; i++) {
            System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
        }
    }

    // 求出当前队列有效数据的个数
    public int size() {
        // rear = 2
        // front = 1
        // maxSize = 3
        return (rear + maxSize - front) % maxSize;
    }

    // 显示队列的头数据， 注意不是取出数据
    public int headQueue() {
        // 判断
        if (isEmpty()) {
            throw new RuntimeException("队列空的，没有数据~~");
        }
        return arr[front];
    }
}

预留位发挥作用，因此这个环形数组队列的有效数据最大是3
image.png

IDEA快捷键小记01：

1.创建对象：Alt+Enter
image.png
2.整行复制：Ctrl+Alt+向上箭头快速复制当前行至上一行
3.代码格式化：Alt+Ctrl+l
4.Tab向左缩进：Shift+Tab