前言

數據結構學習的第一節便是稀疏數組和隊列。

一、稀疏數組

1.1 實際需求

編寫的五子棋程序中，有存盤退出和續上盤的功能。
實現該功能可以使用二維數組進行存儲棋盤，黑子爲1，藍子爲2，如圖所示：
但是該二維數組的很多值是默認值0, 因此記錄了很多沒有意義的數據.->因此使用稀疏數組，來替代二維數組。

1.2 基本介紹

當一個數組中大部分元素爲０，或者爲同一個值的數組時，可以使用稀疏數組來保存該數組。
稀疏數組的處理方法是:

記錄數組一共有幾行幾列，有多少個不同的值
把具有不同值的元素的行列及值記錄在一個小規模的數組中，從而縮小程序的規模

如圖所示：

1.3 應用實例

使用稀疏數組，來保留類似前面的二維數組(棋盤、地圖等等)
把稀疏數組存盤，並且可以從新恢復原來的二維數組數
整體思路分析，如圖所示：
稀疏數組記錄着二維數組的數據位置。稀疏數組的第一行的三列分別代表着二維數組的幾行、幾列、總共幾個數據。下面的數據儲存的是二維數組的第幾行、第幾列、爲何數。
代碼分析邏輯日下：

二維數組轉稀疏數組的思路

遍歷原始的二維數組，得到有效數據的個數 sum

根據sum 就可以創建稀疏數組 sparseArr int[sum + 1] [3]

將二維數組的有效數據數據存入到稀疏數組

稀疏數組轉原始的二維數組的思路

先讀取稀疏數組的第一行，根據第一行的數據，創建原始的二維數組，比如上面的 chessArr2 = int [11][11]

在讀取稀疏數組後幾行的數據，並賦給原始的二維數組即可.

1.4 代碼如下

代碼分爲三步：

顯示原始二維數組
原始二維數組轉稀疏數組
稀疏數組轉原始二維數組

package com.feng.ch01_sparsearray;

public class SparseArray {

    public static void main(String[] args) {
        /*
        * 1. 展示二維數組
        * */
        // 創建一個原始的二維數組 11* 11
        // 0： 便是沒有棋子， 1：黑子， 2：白子
        int[][] chessArr1 = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        // 輸出二維數組長度
        System.out.println("數組有幾行數據，chessArr1.length:" + chessArr1.length); // 求行
        // 第三行的長度
        System.out.println("數組第三行有幾列數據，chessArr1.length[2]:" + chessArr1[2].length);  // 求列

        // 遍歷原始二維數組
        System.out.println();
        System.out.println("原始的二維數組：");
        for (int[] row : chessArr1) {  // 每行數據
            for (int data : row) {     // 每列數組
                System.out.printf("%d\t", data);   // %d:表示將整數格式化爲10進制整數  \t:相當於tab，縮進
            }
            System.out.println();
        }

        /*
        * 2. 將二維數組 轉 稀疏數組的思路
        * */
        // 1、先遍歷 二維數組，得到非0數據的個數
        int num = 0;
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; j++) {
                if (chessArr1[i][j] != 0) {
                    num++;
                }
            }
        }
        System.out.println("二維數組 非0數據 的個數：" + num);

        // 初始化 稀疏數組
        int[][] sparseArr = new int[num+1][3];

        sparseArr[0][0] = chessArr1.length;
        sparseArr[0][1] = chessArr1[0].length;
        sparseArr[0][2] = num;

        int count = 0;
        for (int i=0; i<chessArr1.length; i++){
            for (int j = 0; j <chessArr1[i].length; j++){
                if (chessArr1[i][j]!=0){
                    count++;
                    sparseArr[count][0] = i;   //
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }

        //稀疏數組 創建完成 ,輸出稀疏數組
        System.out.println();
        System.out.println("二維數組 轉成 稀疏數組：");
        for (int i = 0; i < sparseArr.length; i++){
            System.out.printf("%d\t%d\t%d\t\n", sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
        }

        /*
        * 3. 將稀疏數組 --》恢復成 原始的二維數組
        * */
        /**
         * 1、先讀取稀疏數組的第一行，根據第一行的數據，創建原始的二維數組，比如上面的 chessArr2 = int
         * 2、在讀取稀疏數組後幾行的數據，並賦給原始的 二維數組即可。
         */
        // 1、先讀取稀疏數組的第一行，根據第一行的數據，創建原始的二維數組
        int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];
        // 遍歷 稀疏數組的後面幾行數據（從第二行開始），並賦給原始的二維數組即可。
        for (int i = 1; i< sparseArr.length; i++){
            chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
        // 輸出恢復後的二維數組
        System.out.println();
        System.out.println("恢復後的二維數組：");
        for (int[] row : chessArr2){
            for (int data : row){
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
    }
}

1.5 截圖如下

二、隊列

2.1 真實案例

銀行排隊的案例:
在銀行人多的時候，都會進行排隊，每一個人出去，系統都會按照先先排隊的順序進行服務。這裏就用到了隊列先進先出的特性。

2.2 隊列介紹

隊列是一個有序列表，可以用數組或是鏈表來實現。
遵循先入先出的原則。即：先存入隊列的數據，要先取出。後存入的要後取出
示意圖：(使用數組模擬隊列示意圖)

三、數組模擬隊列

3.1 思路

隊列本身是有序列表，若使用數組的結構來存儲隊列的數據，則隊列數組的聲明如下圖, 其中 maxSize 是該隊列的最大容量。
因爲隊列的輸出、輸入是分別從前後端來處理，因此需要兩個變量 front及 rear分別記錄隊列前後端的下標，front 會隨着數據輸出而改變，而 rear則是隨着數據輸入而改變，如圖所示:
當我們將數據存入隊列時稱爲”addQueue”，addQueue 的處理需要有兩個步驟：
思路分析

將尾指針往後移：rear+1 , 當 front == rear 【空】
若尾指針 rear 小於隊列的最大下標 maxSize-1，則將數據存入 rear所指的數組元素中，否則無法存入數據。 rear == maxSize - 1 【隊列滿】

案例實現的功能
添加隊列操作 addQueue
出隊列操作 getQueue
顯示隊列的情況 showQueue
查看隊列頭元素 headQueue
退出系統 exit

3.2 代碼

3.2.1 數組模擬隊列類

Ch01_ArrayQueue.java 數組模擬隊列類

package com.feng.ch02_queue;

// 使用數組 模擬隊列 -- 編寫一個 ArrayQueue 類
public class Ch01_ArrayQueue {
    private int maxSize;  // 便是數組的最大容量
    private int front;    // 隊列頭
    private int rear;     // 隊列尾
    private int[] array;  // 該數據 用於存放數據， 模擬隊列

    // 創建 隊列 的構造器
    public Ch01_ArrayQueue(int arrMaxSize) {
        this.maxSize = arrMaxSize;
        this.array = new int[maxSize];
        this.front = -1;     // 指向隊列頭部，分析出front 是指向: 隊列頭的前一個位置
        this.rear = -1;      // 指向隊列尾，指向: 隊列尾的數據（即就是隊列最後一個數據）
    }

    // 判斷是否爲空
    public boolean isEmpty() {
        return rear == front;
    }

    // 判斷是否爲滿
    public boolean isFull() {
        return rear == maxSize - 1;
    }

    // 添加數據到隊列
    public void addQueue(int num) {
        if (isFull()) {// 判斷是否 已滿
            System.out.println("隊列滿，不能添加數據");
            return;
        }
        rear++; // 讓 rear 後移
        array[rear] = num;
    }

    // 獲取隊列的數據，出隊列
    public int getQueue() {
        if (isEmpty()) {// 判斷是否爲空
            throw new RuntimeException("隊列空，不能取值");
        }
        front++; //改變了 front 的值。
        return array[front];
    }

    // 顯示隊列的所有數據
    public void showQueue() {
        if (isEmpty()) {// 判斷是否爲空
            System.out.println("隊列空，沒有值可顯示");
            return;
        }
        // 遍歷
        for (int i = 0; i < array.length; i++) {
            System.out.printf("array[%d]=%d\n", i, array[i]);
        }
    }

    // 顯示隊列的頭部，注意不是取出數據，僅是顯示數據
    public int headQueue() {
        if (isEmpty()) {// 判斷是否爲空
            throw new RuntimeException("隊列空，不能顯示頭部");
        }
        return array[front + 1]; // 沒有改變 front 的值
    }
}

3.2.2 測試類

Ch01_ArrayQueueMain.java 測試類

package com.feng.ch02_queue;

import java.util.Scanner;

/*
 * 數組 模擬 隊列
 * 特點：先進先出
 *
 * 這個隊列 目前出現的問題並優化：
 * 1、目前數組使用一次就不能用，沒有達到複用的效果
 *  優化：在下一個示例（類）中優化
 * 2、將這個數組使用算法，改進成一個環形的隊列， 取模：%
 * */
public class Ch01_ArrayQueueMain {
    public static void main(String[] args) {

        // 創建一個隊列
        Ch01_ArrayQueue arrayQueue = new Ch01_ArrayQueue(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':
                    arrayQueue.showQueue();
                    break;
                case 'a':
                    System.out.println("輸入一個數");
                    int value = scanner.nextInt();
                    arrayQueue.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = arrayQueue.getQueue();
                        System.out.printf("取出的數據是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int res = arrayQueue.headQueue();
                        System.out.printf("隊列頭的數據是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序已退出！");
    }
}

3.3 截圖

不在截圖，項目直接運行即可。

四、數組模擬環形隊列

4.1 問題分析並優化

數據模擬隊列時，是有一個問題存在的

隊列只能使用一次，沒有達到複用的效果
將這個數組使用算法，改進成一個環形隊列 即可，使用取模 %方式。

4.2 思路分析

尾索引的下一個爲頭索引時表示隊列滿，即將隊列容量空出一個作爲約定,這個在做判斷隊列滿的時候需要注意 (rear + 1) % maxSize == front 【滿】
rear == front 【空】
分析示意圖：
思路如下：

front 變量的含義做一個調整： front 就指向隊列的第一個元素, 也就是說 arr[front] 就是隊列的第一個元素
front 的初始值 = 0

rear 變量的含義做一個調整：rear 指向隊列的最後一個元素的後一個位置. 因爲希望空出一個空間做爲約定.
rear 的初始值 = 0

當隊列滿時，條件是 (rear + 1) % maxSize == front【滿】

對隊列爲空的條件， rear == front 空

當我們這樣分析，隊列中有效的數據的個數 (rear + maxSize - front) % maxSize // rear = 1 front = 0

我們就可以在原來的隊列上修改得到，一個環形隊列

4.3 代碼實現

4.3.1 環形隊列

Ch02_CircleQueue.java

package com.feng.ch02_queue;

/*
* 數組 模擬 環形隊列
* 對上一個示例進行優化：可重複使用
* 充分利用數組，將數組看做一個環形的，（通過取模的方式來實現的即可）
* 重點：1、front、rear 都爲0，
*       2、rear 指向隊列的最後一個元素的後一個位置. 因爲希望空出一個空間做爲約定.，最大下標不存值，做判斷。
*       3、添加、獲取、遍歷、查看頭信息 時的 指針後移都要注意
* */
public class Ch02_CircleQueue {
    private int maxSize; // 表示數組的最大容量
    // front 變量的含義做一個調整： front 就指向隊列的第一個元素, 也就是說 arr[front] 就是隊列的第一個元素
    // front 的初始值 = 0
    private int front; // 隊列頭
    // rear 變量的含義做一個調整：rear 指向隊列的最後一個元素的後一個位置. 因爲希望空出一個空間做爲約定.
    // rear 的初始值 = 0
    private int rear; // 隊列尾
    private int[] array; // 該數據用於存放數據，模擬

    // 創建隊列的構造器
    public Ch02_CircleQueue(int arrMaxSize) {
        this.maxSize = arrMaxSize;
        this.array = new int[maxSize];
//        this.front = 0;
//        this.rear = 0;
    }

    // 判斷隊列 是否滿
    public Boolean isFull() {
        return (rear + 1) % maxSize == front;  // 舉例： maxSize=6，最大下標爲5，  （5+1）%6=0   爲true，則爲滿
    }

    // 判斷隊列是否爲空
    public Boolean isEmpty() {
        return rear == front;  // 初始值皆爲 0
    }

    /*
     * 添加數據 到 隊列
     * 直接將數據加入:  rear 初始爲 0，直接賦值即可，賦值完後，需將 rear 向後移一位。
     * */
    public void addQueue(int n) {
        // 判斷 隊列 是否滿
        if (isFull()) {
            System.out.println("隊列滿，不能加入數據~");
            return;
        }
        array[rear] = n;
        // 將 rear 後移，這裏必須考慮取模
        rear = (rear + 1) % maxSize;
    }

    // 獲取 隊列 的數據，出隊列
    public int getQueue() {
        // 判斷 隊列 是否爲空
        if (isEmpty()) {
            throw new RuntimeException("隊列空，不能取數據");
        }
        // 這裏 需要分析出 front 是指向隊列的第一個元素
        // 1. 先把 front 對應的值保留到一個臨時變量
        // 2. 將 front 後移, 考慮取模
        // 3. 將臨時保存的變量返回
        int value = array[front];
        front = (front + 1) % maxSize; // 改變 front 所指的數據。
        return value;
    }

    // 顯示隊列的所有數據
    public void showQueue() {
        // 遍歷
        if (isEmpty()) {
            System.out.println("隊列爲空，沒有數據~~~");
            return;
        }
        // 思想：從 front 開始遍歷，遍歷多少個元素
        // 動腦筋
        /*
        * i =  front, 我開始寫錯了，寫成了 0 ，所以就有了問題。
        * */
        for (int i = front; i < front + size(); i++) {
            System.out.printf("arr[%d]=%d\n", i % maxSize, array[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 array[front];
    }
}

4.3.2 測試類

Ch02_CircleQueueMain.java 測試類

package com.feng.ch02_queue;

import java.util.Scanner;

public class Ch02_CircleQueueMain {
    public static void main(String[] args) {
        // 創建一個隊列
        Ch02_CircleQueue arrayQueue = new Ch02_CircleQueue(4);

        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':
                    arrayQueue.showQueue();
                    break;
                case 'a':
                    System.out.println("輸入一個數");
                    int value = scanner.nextInt();
                    arrayQueue.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = arrayQueue.getQueue();
                        System.out.printf("取出的數據是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int res = arrayQueue.headQueue();
                        System.out.printf("隊列頭的數據是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序已退出！");
    }
}

4.4 截圖如下