【LeetCode】算法與數據結構筆記(二) 隊列和棧

原創 小小何先生 2020-06-16 04:01

文章目錄

隊列

  隊列是先近先出的數據結構(FIFO)。插入（insert）操作也稱作入隊（enqueue），新元素始終被添加在隊列的末尾。 刪除（delete）操作也被稱爲出隊（dequeue)。 你只能移除第一個元素。

#include <iostream>

class MyQueue {
    private:
        // store elements
        vector<int> data;       
        // a pointer to indicate the start position
        int p_start;            
    public:
        MyQueue() {p_start = 0;}
        /** Insert an element into the queue. Return true if the operation is successful. */
        bool enQueue(int x) {
            data.push_back(x);
            return true;
        }
        /** Delete an element from the queue. Return true if the operation is successful. */
        bool deQueue() {
            if (isEmpty()) {
                return false;
            }
            p_start++;
            return true;
        };
        /** Get the front item from the queue. */
        int Front() {
            return data[p_start];
        };
        /** Checks whether the queue is empty or not. */
        bool isEmpty()  {
            return p_start >= data.size();
        }
};

int main() {
    MyQueue q;
    q.enQueue(5);
    q.enQueue(3);
    if (!q.isEmpty()) {
        cout << q.Front() << endl;
    }
    q.deQueue();
    if (!q.isEmpty()) {
        cout << q.Front() << endl;
    }
    q.deQueue();
    if (!q.isEmpty()) {
        cout << q.Front() << endl;
    }
}

  上述實現方法效率低下。 隨着起始指針的移動，浪費了越來越多的空間。 當我們有空間限制時，這將是難以接受的。

  • 循環隊列

  更有效的方法是循環隊列的方式。具體來說，我們可以使用固定大小的數組和兩個指針來指示起始位置和結束位置。 目的是重用我們之前提到的被浪費的存儲。

設計循環隊列

class MyCircularQueue {

private:
    vector<int> data;
    int size;
    int head;
    int tail;
    int capacity;

public:
    /** Initialize your data structure here. Set the size of the queue to be k. */
    MyCircularQueue(int k) {
        data.resize(k);
        size=k;
        head=0;
        tail=0;
        capacity=0;
    }
    
    /** Insert an element into the circular queue. Return true if the operation is successful. */
    bool enQueue(int value) {
        if(capacity<size){
            data[tail]=value;
            tail = (tail+1)%size;
            ++capacity;
            return true;
        } else return false;
    }
    
    /** Delete an element from the circular queue. Return true if the operation is successful. */
    bool deQueue() {
        if(capacity>0){
            head=(head+1)%size;
            --capacity;
            return true;
        } else return false;
    }
    
    /** Get the front item from the queue. */
    int Front() {
        if(!isEmpty()){
            return data[head];
        } else return -1;
    }
    
    /** Get the last item from the queue. */
    int Rear() {
        if(!isEmpty()){
            return tail==0?data[size-1]:data[tail-1];
        } else return -1;
    }
    
    /** Checks whether the circular queue is empty or not. */
    bool isEmpty() {
        return capacity==0;
    }
    
    /** Checks whether the circular queue is full or not. */
    bool isFull() {
        return capacity==size;
    }
};

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * MyCircularQueue* obj = new MyCircularQueue(k);
 * bool param_1 = obj->enQueue(value);
 * bool param_2 = obj->deQueue();
 * int param_3 = obj->Front();
 * int param_4 = obj->Rear();
 * bool param_5 = obj->isEmpty();
 * bool param_6 = obj->isFull();
 */

  這裏的程序要注意用Rear()函數取最後一個元素的時候，由於tail需要減1，因此當tail等於0的時候減1是會越界的，因此需要處理一下爲0的特殊情況。

  大多數的編程語言都有內置的隊列庫，我們無需重新造輪子。隊列最基本的兩個操作就是入隊(enqueue)和出隊(dequeue)。其用法如下：

#include <iostream>

int main() {
    // 1. Initialize a queue.
    queue<int> q;
    // 2. Push new element.
    q.push(5);
    q.push(13);
    q.push(8);
    q.push(6);
    // 3. Check if queue is empty.
    if (q.empty()) {
        cout << "Queue is empty!" << endl;
        return 0;
    }
    // 4. Pop an element.
    q.pop();
    // 5. Get the first element.
    cout << "The first element is: " << q.front() << endl;
    // 6. Get the last element.
    cout << "The last element is: " << q.back() << endl;
    // 7. Get the size of the queue.
    cout << "The size is: " << q.size() << endl;
}

隊列和廣度優先搜索

尋找根節點A和目標結點G之間的最短路徑

  若使用廣度優先搜索，第零輪中首先需要處理根節點，即A進入隊列；第一輪中處理根節點旁邊的結點BCD 近隊列，第二輪處理距離根結點兩步的結點後面依此類推。

  與樹的層序遍歷類似，越是接近根結點的結點將越早地遍歷。

  如果在第 k輪中將結點 X添加到隊列中，則根結點與X之間的最短路徑的長度恰好是 k。也就是說，第一次找到目標結點時，你已經處於最短路徑中。

  結點的處理順序與它們添加到隊列的順序是完全相同的順序，即先進先出（FIFO）。這就是我們在 BFS 中使用隊列的原因。

  • 實現

  在程序執行BFS時，確定節點和邊緣是非常重要的。其大體的實現思路如下所示：

/**
 * Return the length of the shortest path between root and target node.
 */
int BFS(Node root, Node target) {
    Queue<Node> queue;  // store all nodes which are waiting to be processed
    int step = 0;       // number of steps neeeded from root to current node
    // initialize
    add root to queue;
    // BFS
    while (queue is not empty) {
        step = step + 1;
        // iterate the nodes which are already in the queue
        int size = queue.size();
        for (int i = 0; i < size; ++i) {
            Node cur = the first node in queue;
            return step if cur is target;
            for (Node next : the neighbors of cur) {
                add next to queue;
            }
            remove the first node from queue;
        }
    }
    return -1;          // there is no path from root to target
}

島嶼數量

  這道題目需要用到沉沒島嶼這個思想，當前位置座標爲1時，四周爲1的島嶼都需要置1沉沒。遞歸調用。下面提供廣度優先搜索代碼，用於理解題目意思和解題思路，之後再介紹深度優先搜索的時候再看與之不同點。

  • 廣度優先搜索：
class Solution {
private:
    void bfs(vector<vector<char>>& grid, int row, int col){
        queue<pair<int, int>> neighbors;
        neighbors.push({row, col});
        while(!neighbors.empty()){
            auto rc = neighbors.front();
            neighbors.pop();
            int row = rc.first;
            int col=rc.second;
            if (row - 1 >= 0 && grid[row-1][col] == '1') {
                neighbors.push({row-1, col});
                grid[row-1][col] = '0';
            }
            if (row + 1 < grid.size() && grid[row+1][col] == '1') {
                neighbors.push({row+1, col});
                grid[row+1][col] = '0';
            }
            if (col - 1 >= 0 && grid[row][col-1] == '1') {
                neighbors.push({row, col-1});
                grid[row][col-1] = '0';
            }
            if (col + 1 < grid[0].size() && grid[row][col+1] == '1') {
                neighbors.push({row, col+1});
                grid[row][col+1] = '0';
            }
        }
    }
public:
    int numIslands(vector<vector<char>>& grid) {
        int ans=0;
        for(int row=0; row<grid.size();++row){
            for(int col=0;col<grid[0].size();++col){
                if(grid[row][col] == '1'){
                    ++ans;
                    bfs(grid, row, col);
                }
            }
        }
        return ans;
    }
};

棧

  與隊列不同，棧是後入先出的數據結構。通常插入操作在棧中被稱作入棧push，與隊列類似，總是在堆棧的末尾添加一個新元素，但是，刪除操作，退棧pop，將始終刪除隊列中相對於它的最後一個元素。

  棧的實現比隊列容易。動態數組足以實現堆棧結構。其原理實現如下所示：

#include <iostream>

class MyStack {
    private:
        vector<int> data;               // store elements
    public:
        /** Insert an element into the stack. */
        void push(int x) {
            data.push_back(x);
        }
        /** Checks whether the queue is empty or not. */
        bool isEmpty() {
            return data.empty();
        }
        /** Get the top item from the queue. */
        int top() {
            return data.back();
        }
        /** Delete an element from the queue. Return true if the operation is successful. */
        bool pop() {
            if (isEmpty()) {
                return false;
            }
            data.pop_back();
            return true;
        }
};

int main() {
    MyStack s;
    s.push(1);
    s.push(2);
    s.push(3);
    for (int i = 0; i < 4; ++i) {
        if (!s.isEmpty()) {
            cout << s.top() << endl;
        }
        cout << (s.pop() ? "true" : "false") << endl;
    }
}

  大多數流行的語言都提供了內置的棧庫，因此你不必重新發明輪子。除了初始化，我們還需要知道如何使用兩個最重要的操作：入棧和退棧。除此之外，你應該能夠從棧中獲得頂部元素。下面是一些供你參考的代碼示例：

#include <iostream>

int main() {
    // 1. Initialize a stack.
    stack<int> s;
    // 2. Push new element.
    s.push(5);
    s.push(13);
    s.push(8);
    s.push(6);
    // 3. Check if stack is empty.
    if (s.empty()) {
        cout << "Stack is empty!" << endl;
        return 0;
    }
    // 4. Pop an element.
    s.pop();
    // 5. Get the top element.
    cout << "The top element is: " << s.top() << endl;
    // 6. Get the size of the stack.
    cout << "The size is: " << s.size() << endl;
}

棧和深度優先搜索

尋找根節點A和目標結點G之間的最短路徑

  同樣對於上圖所示這個問題，採用深度優先搜索算法的時候，我們從根結點 A 開始。首先，我們選擇結點 B 的路徑，並進行回溯，直到我們到達結點 E，我們無法更進一步深入。然後我們回溯到 A 並選擇第二條路徑到結點 C。從 C 開始，我們嘗試第一條路徑到 E 但是 E 已被訪問過。所以我們回到 C 並嘗試從另一條路徑到 F。最後，我們找到了 G。

  在到達最深處的結點之後開始回溯，回溯時從棧中彈出最深的結點，所以也叫做深度優先搜索。但是DFS找到的路徑並不總是最短的路徑。

  以之前島嶼的例子舉例，大多數情況下能使用BFS時也可以使用DFS。與 BFS 不同，更早訪問的結點可能不是更靠近根結點的結點。因此，你在 DFS 中找到的第一條路徑可能不是最短路徑。

  • 深度優先搜索：
class Solution {
private:
    void dfs(vector<vector<char>>& grid, int row, int col){
            if(row<0||row>=grid.size()||col<0||col>=grid[0].size()
            ||grid[row][col]=='0'){
                return;
            } 
            else {
                grid[row][col] ='0';
                dfs(grid, row-1,col);
                dfs(grid, row+1,col);
                dfs(grid, row,col-1);
                dfs(grid, row,col+1);
            } 
        }
public:
    int numIslands(vector<vector<char>>& grid) {
        int ans=0;
        for(int row=0; row<grid.size();++row){
            for(int col=0;col<grid[0].size();++col){
                if(grid[row][col] == '1'){
                    ++ans;
                    dfs(grid, row, col);
                }
            }
        }
        return ans;
    }
};

  深度優先搜索模板可總結爲：

/*
 * Return true if there is a path from cur to target.
 */
boolean DFS(Node cur, Node target, Set<Node> visited) {
    return true if cur is target;
    for (next : each neighbor of cur) {
        if (next is not in visited) {
            add next to visted;
            return true if DFS(next, target, visited) == true;
        }
    }
    return false;
}

  當我們遞歸地實現 DFS 時，似乎不需要使用任何棧。但實際上，我們使用的是由系統提供的隱式棧，也稱爲調用棧（Call Stack）。

  棧的大小正好是DFS 的深度。因此，在最壞的情況下，維護系統棧需要 O(h)O(h)，其中 h是 DFS 的最大深度。

  遞歸解決方案的優點是它更容易實現。 但是，存在一個很大的缺點：如果遞歸的深度太高，你將遭受堆棧溢出。 在這種情況下，您可能會希望使用 BFS，或使用顯式棧實現 DFS。

  使用顯式棧的模板：

/*
 * Return true if there is a path from cur to target.
 */
boolean DFS(int root, int target) {
    Set<Node> visited;
    Stack<Node> s;
    add root to s;
    while (s is not empty) {
        Node cur = the top element in s;
        return true if cur is target;
        for (Node next : the neighbors of cur) {
            if (next is not in visited) {
                add next to s;
                add next to visited;
            }
        }
        remove cur from s;
    }
    return false;
}

  該邏輯與遞歸解決方案完全相同。 但我們使用 while 循環和棧來模擬遞歸期間的系統調用棧。

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Python進階(一)Python中的內置函數詳解

dir   python內置方法有很多，無論是初學者還是精通python的程序員都不能全部記住所有的方法，這時候 dir() 方法就非常有用了，使用 dir()函數可以查看對象內的所有的屬性和方法，在 python中任何東西都是對

小小何先生 2020-06-28 07:14:03

Python進階(六)文件操作

文章目錄操作文件的套路文件指針打開文件的方式文件/目錄常用管理操作   在計算機中，文件是以二進制的方式保存在計算機磁盤上的。 操作文件的套路   計算機中操作文件套路非常固定，一共包含三個步驟： 打開文件 讀、寫文件 關閉文件

小小何先生 2020-06-28 07:14:03

Python進階(五)模塊、包詳解

文章目錄導入時指定別名局部導入注意模塊搜索順序包發佈模塊   模塊是Python程序架構的一個核心概念。每一個以擴展名py結尾的Python源代碼文件都是一個模塊。模塊就好比是工具包，要想使用這個工具包中的工具，就需要先導入這個模

小小何先生 2020-06-28 07:14:03

Python進階(四)Python中的異常

文章目錄自定義異常使用raise拋出異常try...except捕獲異常異常的傳遞assert語句的使用   異常機制是指程序出現錯誤後，程序的處理方法。   當出現錯誤後，程序的執行流程發生改變，程序的控制權轉移到異常處理。Ex

小小何先生 2020-06-28 07:14:03

Python進階(三)單例設計模式

  在瞭解python的單例設計模式之前，我們需要先知道什麼是設計模式：前人工作的總結和提煉，通常，被人們廣泛流傳的設計模式都是針對某一特定問題的成熟解決方案。   使用設計模式是爲了可重用代碼、讓代碼更容易被他人理解、保證代碼可

小小何先生 2020-06-28 07:14:03

Python進階(二)Python中的類繼承、封裝、多態使用方法

文章目錄封裝繼承和重寫繼承基本思想super()擴展父類，重寫多繼承多態類屬性類方法靜態方法   python中可以在類的外面給對象增加屬性，比如tom.name="Tom"就可以給tom類增加一個name屬性，但是這種方法並不推

小小何先生 2020-06-28 07:14:02

Python進階(零)字典、缺省參數、多值參數

文章目錄字典字典的增、刪、改字典的統計、合併、清空字典的遍歷循環字典和列表組合應用缺省參數多值參數 字典   dictionary(字典)是除列表以外Python中最靈活的數據類型。字典同樣可以用來存儲多個數據，與列表相比，字典中

小小何先生 2020-06-28 07:14:02

C++ string類相關函數

1、簡介   string 類是 STL 中 basic_string 模板實例化得到的模板類。其定義如下： typedef basic_string <char> string;   basic_string 此處可以不必深究

小小何先生 2020-06-07 17:29:44

【LeetCode】算法與數據結構筆記(一) 數組和字符串

文章目錄核心要點集合列表數組編程實例一維數組合併區間二維數組旋轉圖像對角線遍歷字符串簡介最長公共前綴翻轉字符串裏的單詞雙指針移除元素   本文主要爲LeetCode刷題學習筆記。 核心要點 集合   集合裏的元素類型不一定相同。

小小何先生 2020-06-07 17:29:44

數據結構(三)二叉搜索樹

小小何先生 2020-05-06 08:37:29

數據結構(三)平衡二叉樹

小小何先生 2020-05-06 08:37:29

數據結構(三)二叉樹的遍歷

小小何先生 2020-04-30 23:05:40

數據結構(三)二叉樹及存儲結構

小小何先生 2020-04-29 12:59:54

數據結構(三)樹之樹與樹的表示

小小何先生 2020-04-28 09:15:39

數據結構(二)線性結構之隊列

小小何先生 2020-04-26 00:57:28