一、棧

　　棧（stack）是一種操作受限的線性表資料結構，基於後進先出（LIFO）策略的集合型別，例如函式中的臨時變數符合後進先出的特性，因此用棧儲存最合適。

　　在入棧和出棧過程中所需的空間複雜度是 O(1)，時間複雜度也是 O(1)。空間複雜度是指執行演算法還需要的額外儲存空間。

　　注意，記憶體中的堆疊和資料結構中的堆疊不是一個概念，前者是真實存在的物理區，後者是抽象的資料儲存結構。

　　面試題30 包含min函式的棧。在壓棧時，與之前的最小值比較，每次把兩者較小的那個值存放到輔助棧中。

　　面試題31 棧的壓入和彈出序列。如果彈出的數字是棧頂，則彈出；如果彈出的數字不在棧頂，則把還沒入棧的數字壓入到輔助棧中，直到棧頂是彈出數字為止。

1）括號匹配

　　用正確的型別和順序匹配括號，例如“(”跟“)”匹配，“[”跟“]”匹配，“{”跟“}”匹配。例題：LeetCode的20. 有效的括號。

　　第一種思路是，當遇到匹配的最小括號對時，將它們從棧中刪除（即出棧），如果最後棧為空，那麼它是有效的括號，反之不是，程式碼如下所示。

function isValidParentheses(s) {
  const length = s.length;
  let i = 0;
  const stack = [];
  while (i < length) {
    let stackLen = stack.length > 0 ? stack.length - 1 : stack.length;
    if (
      (stack[stackLen] == "(" && s[i] == ")") ||
      (stack[stackLen] == "{" && s[i] == "}") ||
      (stack[stackLen] == "[" && s[i] == "]")
    ) {
      stack.pop();
      i++;
      continue;
    }
    stack.push(s[i]);
    i++;
  }
  return stack.length === 0;
}

　　第二種思路是巧妙的利用一張對映表，以右括號為鍵，左括號為值。先判斷當前字元是否是左括號，若是，就入棧，否則匹配當前棧頂元素是否與當前字元匹配。

function isValidParentheses(s) {
  const stack = [],
    map = { "}": "{", "]": "[", ")": "(" };
  for (let i = 0, len = s.length; i < len; i++) {
    let c = s[i];
    if (!map[c]) {
      stack.push(c);
      continue;
    }
    if (stack.length > 0 && map[c] != stack.pop())
      return false;
  }
  return stack.length == 0;
}

2）算術表示式求值

　　( 1 + ( 2 + 3 ) * ( 4 * 5 ) ) 是一個算術表示式，如果將4乘以5，把3加上2，取它們的積然後加1，就得到了101。

　　表示式由括號、運算子和運算元（數字）組成，可以用兩個棧分別儲存運算子和運算元來完成算術求值，處理過程如下所列。

　　（1）將運算元壓入運算元棧；

　　（2）將運算子壓入運算子棧；

　　（3）忽略左括號；

　　（4）在遇到右括號時，彈出一個運算子，彈出所需數量的運算元，並將運算子和運算元的運算結果壓入運算元棧。

　　原始碼如下所示。例題：LeetCode的150. 逆波蘭表示式求值。

function evalExpress(s) {
  const length = s.length;
  let i = 0;
  const ops = [],
    vals = [];
  while (i < length) {
    let word = s[i];
    if (word == "(") {
    } else if (word == "+" || word == "-" || word == "*" || word == "/")
      ops.push(word);
    else if (word == ")") {
      let op = ops.pop(),
        val = vals.pop();
      if (op == "+") val = vals.pop() + val;
      else if (op == "-") val = vals.pop() - val;
      else if (op == "*") val = vals.pop() * val;
      else if (op == "/") val = vals.pop() / val;
      vals.push(val);
    } else
      vals.push(parseInt(word));
    i++;
  }
  return vals.pop();
}

二、佇列

　　佇列（queue）也是一種操作受限的線性表資料結構，基於先進先出（FIFO）策略的集合型別，佇列的應用非常廣泛，例如迴圈佇列、阻塞佇列、併發佇列等。

　　棧只需一個棧頂指標，而佇列需要兩個：隊首指標和隊尾指標。

　　面試題9 用兩個棧實現佇列。先進後出的棧實現先進先出的佇列，一系列棧的壓入和彈出模擬佇列。

　　面試題59 視窗滑動的最大值。只把可能成為滑動視窗最大值的數存入一個兩端開口的佇列（deque）。延伸題：佇列的最大值。

1）迴圈佇列

　　迴圈佇列是首尾相連的佇列，這樣可避免在出隊時進行資料搬移的操作，但需要準確的判斷出隊空和隊滿，如下所示。例題：LeetCode的641. 設計迴圈雙端佇列。

class CircularQueue {
  constructor(capacity) {
    this.items = [];
    this.n = capacity;    //佇列大小
    this.head = 0;        //隊首指標
    this.tail = 0;        //隊尾指標
  }
  enqueue(item) {
    const { head, tail, n } = this;
    //隊滿
    if ((tail + 1) % n == head) return false;
    this.items[tail] = item;
    //隊尾沒有儲存資料，會浪費一個數組的儲存空間
    this.tail = (tail + 1) % n;
    return true;
  }
  dequeue() {
    const { head, tail, n, items } = this;
    //隊空
    if (head == tail) return null;
    const result = items[head];
    this.head = (head + 1) % n;
    return result;
  }
}

三、散列表

　　散列表（Hash Table）也叫雜湊表，一種以空間換時間的方式，是陣列的擴充套件，可根據鍵（Key）而直接訪問記憶體儲存位置的資料結構。

　　它通過計算一個關於鍵值的函式，將所需查詢的資料對映到表中一個位置來訪問記錄，提升查詢速度。

　　這個對映函式稱做雜湊函式，存放記錄的陣列稱做散列表。

　　雜湊函式的特點如下：

　　（1）計算得到的結果是一個非負整數。

　　（2）如果 key1 = key2，那 hash(key1) == hash(key2)。

　　（3）如果 key1 ≠ key2，那 hash(key1) ≠ hash(key2)。

　　但即使是著名的MD5、SHA等雜湊演算法，也不能避免雜湊衝突。當出現衝突時，可採用拉鍊法（Chaining）和線性探測法（Linear Probing）。

　　所以在散列表中查詢資料，最好情況是 O(1)，最壞情況是 O(n)。

　　LeetCode的242. 有效的字母異位詞，除了排序字元之外，還可用散列表記錄字元出現的次數。

　　LeetCode的1. 兩數之和，將陣列放入一個散列表中，用總數減去遍歷的值，判斷差是否可在散列表中查到。複雜度升級後的例題：15. 三數之和、18. 四數之和。

四、位運算

　　位運算就是直接對整數在記憶體中的二進位制進行操作。由於位運算不需要轉成十進位制，因此處理速度非常快。位運算的總結摘錄於《演算法面試通關40講》。

　　XOR（異或）的特點如下：

x^0 = x
x^1s = ~x;        //1s是一種全為1的數，即1s = ~0
x^(~x) = 1s;
x^x = 0;
a^b=c => a^c=b, b^c=a        //swap
a^b^c = a^(b^c) = (a^b)^c

　　常用的位運算包括：

x&1 == 1 OR == 0    //判斷奇偶（x%2==1）。
x = x&(x-1)         //將最低位的 1 清零。
x & -x              //得到最低位的 1。

　　更復雜的位運算包括：

x & (~0 << n)                   //將x最右邊的n位清零
(x >> n) & 1                    //獲取x的第n位值（0或1）
x & (1 << (n-1))                //獲取x的第n位的冪值
x | (1 << n)                    //僅將第n位置為1
x & (~(1 << n))                 //僅將第n位置為0
x & ((1 << n) - 1)              //將x最高位至第n位（含）清零
x & (~((1 << (n+1)) - 1))       //將第n位至第0位（含）清零

　　LeetCoded的191. 位1的個數，迴圈執行 x&(x-1)，並且記錄迴圈次數，判斷條件是x和0是否相同。

　　LeetCoded的231. 2的冪，仍然使用 x&(x-1)，然後判斷x是否等於0。

　　LeetCoded的338. 位元位計數，使用遞推公式 count[i] = count[i&(i-1)] + 1，只需一遍迴圈就能得出1的數量。

&n