2. 程式人生 > 其它 >資料結構--稀疏陣列和佇列

資料結構--稀疏陣列和佇列

阿新 • • 發佈：2021-08-05

最近在學尚矽谷的資料結構，特此開一篇blog來做筆記

稀疏陣列

當一個數組中大部分元素是0時，或者為同一個值的陣列時，可以用稀疏陣列來儲存該陣列，節省儲存空間(二維陣列儲存太浪費空間了)

應用場景

  • 五子棋、圍棋記錄黑白子，無佔位處記為0，黑白分別記為1，2
  • 掃雷
  • 象棋類，跳棋等

處理方法：

  • 記錄陣列有幾行幾列，有多少個不同的值
  • 把有不同值的元素的行列及值記錄在一個小規模的數組裡，從而縮小程式的規模

二維陣列轉化稀疏陣列的思路

  • 遍歷原始二維陣列，得到有效資料的個數
  • 根據sum就可以建立稀疏陣列 int spareseArr[sum + 1][3]
  • 將二維陣列的有效資料的個數sum存入稀疏陣列

稀疏陣列轉原始二維陣列

  • 先讀稀疏陣列第一行，根據第一行資料建立原始二維陣列
  • 在讀取稀疏陣列後幾行的資料，並賦予原始的二維陣列int originArr[size][size]即可

程式碼

//spareseArray.java
import java.util.Scanner;
public class spareseArray{
    public static void main(String[] args){
        public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int size = scan.nextInt();
        scan.close();
        int chessArr[][] = new int[size][size];//建立一個11*11的棋盤
        chessArr[1][2] = 1;
        chessArr[2][3] = 2;
        chessArr[4][6] = 1;
        int sum = 0;
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                if (chessArr[i][j] != 0)
                    sum++;
            }
        }
        //建立稀疏陣列
        int spareseArr[][] = new int[sum + 1][3];
        //給稀疏陣列賦值
        spareseArr[0][0] = size;
        spareseArr[0][1] = size;
        spareseArr[0][2] = sum;
        //遍歷二維陣列，把非0的值存放在稀疏陣列中
        int count = 0;//計數器，記錄非0資料個數
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                if (chessArr[i][j] != 0) {
                    count++;
                    spareseArr[count][0] = i;
                    spareseArr[count][1] = j;
                    spareseArr[count][2] = chessArr[i][j];
                }
            }
        }
        //輸出稀疏陣列的形式
        System.out.println("the sparese Array:");
        for (int i = 0; i < sum + 1; i++) {
            System.out.printf("%d %d %d\n", spareseArr[i][0], spareseArr[i][1], spareseArr[i][2]);
        }
        //稀疏陣列恢復二維陣列
        int originArr[][] = new int[spareseArr[0][0]][spareseArr[0][1]];
        //輸出恢復後的二維陣列
        for (int i = 1; i < spareseArr.length; i++) {
            originArr[spareseArr[i][0]][spareseArr[i][1]] = spareseArr[i][2];
        }
        System.out.println("the origin array:");
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                System.out.print(originArr[i][j] + " ");
            }
            System.out.println();
        }    
    }
}

參考連結：尚矽谷--Java資料結構p7-p9bilibili

佇列(陣列)

佇列是一個有序列表，可以用陣列或者連結串列來實現。遵循先入先出原則，這一部分用陣列來模擬

應用場景：銀行排隊案例

佇列本身是有序列表，需要兩個變數front和rear分別標記佇列前後端，front隨著資料輸出而改變，rear隨著資料輸入而改變。還有需要一個maxSize來標記佇列的最大容量。

當存資料入列時

  • 把尾指標後移：rear+1，當front=rear [ 空 ]
  • 若尾指標rear小於佇列的最大下標maxSize-1，則將資料存入rear所指的陣列元素中，否則無法存入資料。rear == maxSize-1
    => 佇列滿

程式碼

package hello;
import java.util.Scanner;
public class Queue {
    public static void main(String[] args) {
        //建立一個佇列
        ArrayQueue queue = new ArrayQueue(3);
        char key = ' ';
        Scanner scan = new Scanner(System.in);
        boolean loop = true;
        //輸出一個選單
        while (loop) {
            System.out.println("s(show queue)");
            System.out.println("e(exit)");
            System.out.println("a(add)");
            System.out.println("g(get)");
            System.out.println("h(head)");
            key = scan.next().charAt(0);
            switch (key) {
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.println("output a num:");
                    int value = scan.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = queue.getQueue();
                        System.out.printf("get the num is: %d\n", res);
                    } catch (Exception e) {
                        //TODO: handle exception
                        System.out.println(e.getMessage());
                        break;
                    }
                    break;
                case 'h':
                    //檢視佇列頭資料
                    try {
                        int res = queue.headQueue();
                        System.out.printf("head data: %d\n", res);
                    } catch (Exception e) {
                        //TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e'://退出
                    scan.close();
                    loop = false;//退出while迴圈
                    break;
                default:
                    break;
            }
        }
    }
}
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;//指向佇列頭部，指向資料頭部前一個位置
        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("the queue is full~~");
            return;
        }
        //rear++;//rear後移
        //arr[rear] = n;
        arr[++rear] = n;//這是上兩行程式碼簡寫
    }
    //獲取佇列資料，出佇列
    public int getQueue() {
        //判斷是否為空
        if (isEmpty()) {
            //丟擲異常
            throw new RuntimeException("empty queue~~");
        }
        front++;
        return arr[front];
    }
    //顯示佇列所有資料
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("empty queue~~");
            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("empty queue~~");
        }
        return arr[front + 1];//使front指向頭資料
    }
}

缺點：

  • 陣列只能用一次

優化：

  • 改進成為環形佇列 演算法思想：取模%

陣列模擬環形佇列

思路：

  • front變數含義做一個調整：front指向佇列第一個元素，也就是arr[front]就是佇列第一個元素
  • rear變數含義做一個調整：rear指向佇列最後一個元素的後一個位置。留出一個空間來判斷佇列是空或滿
  • 當佇列滿時，條件是：(rear+1)&maxSize == front =>佇列滿

佇列中有效資料的個數 (rear + maxSize - front) % maxSize

程式碼

import java.util.Scanner;
public class CircleArrayQueue {
    public static void main(String[] args) {
        CircleArray queue = new CircleArray(4);//佇列有效資料是3
        char key = ' ';
        Scanner scan = new Scanner(System.in);
        boolean loop = true;
        //輸出一個選單
        while (loop) {
            System.out.println("s(show queue)");
            System.out.println("e(exit)");
            System.out.println("a(add)");
            System.out.println("g(get)");
            System.out.println("h(head)");
            key = scan.next().charAt(0);
            switch (key) {
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.println("output a num:");
                    int value = scan.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = queue.getQueue();
                        System.out.printf("get the num is: %d\n", res);
                    } catch (Exception e) {
                        //TODO: handle exception
                        System.out.println(e.getMessage());
                        break;
                    }
                    break;
                case 'h':
                    //檢視佇列頭資料
                    try {
                        int res = queue.headQueue();
                        System.out.printf("head data: %d\n", res);
                    } catch (Exception e) {
                        //TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scan.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
    }
}

class CircleArray {
    private int maxSize;//陣列最大容量
    private int front;//佇列頭，佇列的第一個元素，不一定是0
    private int rear;//佇列尾
    private int[] arr;//該陣列用於存放資料，模擬佇列

    public CircleArray(int arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = 0;
        rear = 0;
    }
    public boolean isFull() {
        return (rear + 1) % maxSize == front;//+1是利用了留出的空位來判斷佇列是否為滿
    }
    public boolean isEmpty() {
        return rear == front;//初始化時rear和front都是0，如果沒有add，即可判斷為空
    }
    public void addQueue(int n) {
        if (isFull()) {
            System.out.println("full array~~");
            return;
        }
        arr[rear] = n;//直接把n賦給arr
        rear = (rear + 1) % maxSize;//考慮取模
    }
    public int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("empty array~~");
        }
        //這裡要分析出front是指向佇列的第一個元素
        //1.先把front對應的值保留到一個臨時變數
        //2.把front後移
        //3.把臨時儲存的變數返回
        int value = arr[front];    
        front = (front + 1) % maxSize;
        return value;
    }
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("empty array~~");
            return;
        }
        for (int i = front; i < front + size(); i++) {
            System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
        }
    }
    //求出當前佇列有效資料個數
    public int size() {
        return (rear + maxSize - front) % maxSize;
    }
    public int headQueue() {
        if (isEmpty()) {
            throw new RuntimeException("empty array~~");
        }
        return arr[front];
    }
}

相關推薦

資料結構--稀疏陣列和佇列

最近在學尚矽谷的資料結構，特此開一篇blog來做筆記 稀疏陣列 當一個數組中大部分元素是0時，或者為同一個值的陣列時，可以用稀疏陣列來儲存該陣列，節省儲存空間(二維陣列儲存太浪費空間了)

資料結構--稀疏陣列

實際場景 如下圖：棋盤可以看做是一個二維陣列，如果將黑子用1表示，藍子用2表示，空白的地方用0表示，如果我們直接將棋盤資料存入二維陣列，則陣列中會存在大量的0，因此記錄了很多沒有意義的資料，於是，我們便想

B.資料結構（棧和佇列）

一、棧 A、順序儲存結構 # 自定義異常 class StackUnderflow(ValueError): # 棧下溢（空棧訪問）

稀疏陣列和佇列 —— 佇列

佇列介紹 佇列是一個有序列表，可以用陣列或是連結串列來實現。 遵循先入先出的原則。即：先存入佇列的資料，要先取出。後存入的要後取出

資料結構筆記 — 棧和佇列

​ 棧和佇列 1 棧 1.1 棧基本概念 定義：棧 (Stack) 時一個後進先出的線性表，塔要求 只在表尾進行刪除和插入操作

第 3 章：稀疏陣列和佇列（一）

稀疏陣列 實際需求 編寫的五子棋程式中，有存檔退出和續上盤的功能 因為該二維陣列的很多值是預設值 0 ，因此記錄了很多沒有意義的資料，我們將其轉為稀疏陣列進行儲存

【PHP資料結構】棧和佇列的應用

通過棧和佇列的學習，我們似乎會感覺到其實資料結構還是非常簡單的嘛。當然，這只是一個開始，我們從順序表、連結串列開始，到現在的棧和佇列，其實都是為了將來在鋪路。在樹和圖的遍歷演算法中，都可以見到棧和佇列

02java演算法與資料結構------稀疏陣列程式碼實現

package com.java.test; import java.util.Scanner; public class Test2 { public static void main(String[] args) {

Java資料結構---稀疏陣列

稀疏數值的基礎概念（圖示） ◆當一個數組中大部分元素為0,或者為同一值的陣列時,可以使用稀疏陣列來儲存該陣列。◆稀疏陣列的處理方式是:◆記錄陣列一共有幾行幾列，有多少個不同值◆把具有不同值的元素和行列及

【c 語言資料結構】棧和佇列的相關操作

目錄棧一，棧的基本操作介紹二，棧的順序儲存實現1，順序棧的定義2，初始化操作3，進棧操作4，出棧操作三，棧的鏈式儲存實現佇列一，佇列的定義二，佇列的順序實現1，初始化操作2，入隊操作3，出隊操作三，佇列的鏈

資料結構——稀疏陣列

資料結構——稀疏陣列 棋局存檔問題：如何將一局五子棋儲存下來，並實現讀檔

TCP連線三次握手中的重要資料結構：半連線佇列和全連線佇列

什麼是 TCP 半連線佇列和全連線佇列？ 在 TCP 三次握手的時候，Linux 核心會維護兩個佇列，分別是：

資料結構-非線性結構-稀疏陣列

一、稀疏陣列介紹 二、稀疏陣列引入 　　二維陣列轉稀疏陣列、稀疏陣列轉二維陣列：程式碼實現(Java)

資料結構之陣列

什麼是陣列 陣列是一種線性表資料結構,它用一組連續的記憶體空間來儲存一組具有相同型別的資料

Redis實戰(4)-資料結構List實戰之佇列特性實現訊息多執行緒 廣播通知

概述：本系列博文所涉及的相關內容來源於debug親自錄製的實戰課程：快取中介軟體Redis技術入門與應用場景實戰（SpringBoot2.x + 搶紅包系統設計與實戰），感興趣的小夥伴可以點選自行前往學習（畢竟以視訊的形式來掌

python資料分析03Python的資料結構、函式和檔案

我們會從Python最基礎的資料結構開始：元組、列表、字典和集合。然後會討論建立你自己的、可重複使用的Python函式。最後，會學習Python的檔案物件，以及如何與本地硬碟互動。

python資料結構_雙端佇列

雙端佇列 雙端佇列（deque，全名double-ended queue），是一種具有佇列和棧的性質的資料結構。

資料結構與演算法-優先順序佇列

優先順序佇列 概念 搜尋樹結構和詞典結構，都支援覆蓋資料全集的訪問和操作。也就是說，其中儲存的每一資料物件都可作為查詢和訪問目標

【資料結構】數和二叉樹相關演算法

二叉樹的遍歷 先序遍歷 //先序遍歷 void InOrder(BiTree T) { InitStack(S); BiTree p = T; while (p || !Empty(S)) {

重學資料結構（三、佇列）

@目錄1、佇列的定義和特點2、佇列的基本操作3、順序佇列3、鏈式佇列4、java中的佇列