棧資料結構

棧是一種遵從後進先出(LIFO)原則的有序集合。新新增的或者待刪除的元素都儲存在棧的同一端，稱作棧頂，另一端就叫棧底。在棧裡，新元素都靠近棧頂，舊元素都接近棧底。

我們在生活中常能看到棧的例子。整齊堆起來的書，廚房堆起的盤子等

棧也被用在程式語言的編譯器和記憶體中儲存變數、方法呼叫等。

/**
 * 使用es6中的Class語法來編寫類：棧
 * 此棧使用陣列來儲存元素
 */
class Stack {
  constructor() {
    this.items = [];
  }

  /**
   * 新增一個（或幾個）新元素到棧頂
   * @param {*} element 新元素
   */
  push(element) {
    this.items.push(element)
  }

  /**
   * 移除棧頂的元素，同時返回被移除的元素
   */
  pop() {
    return this.items.pop()
  }

  /**
   * 返回棧頂的元素，不對棧做任何修改（這個方法不會移除棧頂的元素，僅僅返回它）
   */
  peek() {
    return this.items[this.items.length - 1]
  }

  /**
   * 如果棧裡沒有任何元素就返回true,否則返回false
   */
  isEmpty() {
    return this.items.length === 0
  }

  /**
   * 移除棧裡的所有元素
   */
  clear() {
    this.items = []
  }

  /**
   * 返回棧裡的元素個數。這個方法和陣列的length屬性很類似
   */
  size() {
    return this.items.length
  }

  /**
   * 返回以字串形式輸出的棧
   */
  toString() {
    return this.items.toString()
  }

  /**
   * 返回以陣列形式輸出的棧
   */
  toArray() {
    return this.items
  }

}
 

棧的用法

進位制轉換

更多詳情請檢視原始碼
在計算機裡所有的內容都是二進位制數字表示的（0和1），而我們生活中主要用到十進位制，還有16進位制等。那麼就需要進位制轉換。我們可以利用棧來實現轉換。

/**
 * 10進位制數轉換為其他16進位制以內進位制的數
 * @param {*} decNumber 需要轉換的數
 * @param {Int32Array} hex 進位制數
 */
function hexConverter(decNumber, hex) {
  let remStack = new Stack()
  let rem = 0
  let baseString = ''
  let digits = '0123456789ABCDEF' //進製取數

  if (hex < 2 || hex > 16) {
    return '只轉換大於二進位制小於十六進位制之間的進位制'
  }
  while (decNumber > 0) {
    rem = Math.floor(decNumber % hex) // 求模運算
    remStack.push(rem)
    decNumber = Math.floor(decNumber / hex) // 除運算
  }

  while (!remStack.isEmpty()) {
    baseString += digits[remStack.pop()] // 取出棧中的資料對應於進位制數的表示數
  }

  return baseString
}
 

迴文判斷

更多詳情請檢視原始碼
正讀反讀都相同的字元序列稱為迴文，例如“abccba”、“abcba”、“12321”、“123321”。
迴文判斷有很多種方法，在這裡，我們可以採用先入棧後出棧的方法，來比較入棧之前，和出棧之後兩個字串是否相同。
空字串到底是不是迴文呢，有點疑惑？ 我這裡定義為不是迴文。

/**
 * 判斷字串是否為迴文
 * @param {String} str 要判斷的字串
 */
 function palindrome(str) {
  // 非string型別的 或者  空字串  直接判斷不是迴文
  if (typeof (str) !== 'string' || str.length === 0) {
    return false
  }

  let stack = new Stack()
  let oStr = str.toLocaleLowerCase()
  let nStr = ''

  for (let i = 0; i < str.length; i++) {
    stack.push(str[i])
  }

  while (!stack.isEmpty()) {
    nStr += stack.pop().toLocaleLowerCase()
  }

  if (nStr === oStr) {
    // return `輸入的字串【{$oStr}】是迴文`
    return true
  } else {
    // return `輸入的字串【{$oStr}】不是迴文`
    return false
  }
}
 

平衡括號

更多詳情請檢視原始碼
如果一個括號序列包含完整的左右括號對，則稱為平衡括號序列。如："{[()]}","", "({})", "{()}"都是平衡括號，而"{()[]", ")"則不是平衡括號。

括號只有三種()/[]/{}，每種分別有左右括號。我們可以這樣操作：遇到左括號，左括號入棧，遇到右括號，取出棧中最後一個括號來比對的方式來判斷是否相等平衡。

/**
 * 判斷括號序列是否平衡,空序列也算是平衡
 * @param {String} brackets 括號序列
 */
function balanceBracket(brackets) {
  if (typeof (brackets) !== 'string') {
    return false
  }

  let left = '([{'
  let right = ')]}'
  let num = 0 // 括號的對數
  let stack = new Stack()

  for (let i = 0; i < brackets.length; i++) {
    if (right.indexOf(brackets[0]) > -1) {
      return false
    }
    if (left.indexOf(brackets[i]) > -1) {
      stack.push(brackets[i])
      num++
    } else {
      if (right.indexOf(brackets[i]) > -1) {
        let topBracket = stack.pop()
        let rightSort = right.indexOf(brackets[i])
        let leftSort = left.indexOf(topBracket)

        if (rightSort !== leftSort) {
          return false
        }
      }
    }
  }
  return `是平衡括號序列。有${num}對括號`
}

漢諾塔

更多詳情請檢視原始碼
有三根相鄰的柱子，標號為A,B,C。A柱子上從下到上按金字塔狀疊放著n個不同大小的圓盤，要把所有圓盤移動到B柱子上。
要求：

1. 每次只能移動一個圓盤。
2. 每根柱子上的圓盤，下面的都比上面的大。

問題：
請問至少需要移動多少次圓盤？每次移動的步驟是怎樣的？

let num = 0 // 記錄移動的次數

/**
 * 記錄圓盤移動的過程
 *
 * 這裡的思路，一直在迴圈做一件事情。
 * 把原始柱子上的圓盤分為兩部分，最大和其它。
 * 第一回合，將其它移動到輔助柱子上，將最大的移動到目標柱子上，再將其它移動到目標柱子上
 * 第二回合，將其它移動到輔助柱子上，將最大的移動到目標柱子上，再將其它移動到目標柱子上
 * ...
 * 第2 ** n - 1回合，將其它移動到輔助柱子上，將最大的移動到目標柱子上，再將其它移動到目標柱子上
 *
 * 但是，這裡源柱子、輔助柱子和目標柱子會隨著其它盤而變動。
 * 其它盤在哪個柱子上，哪根柱子就是源柱子。

 * @param {Int32Array} plates 圓盤個數
 * @param {Array} source 源柱子
 * @param {Array} helper 輔助柱子
 * @param {Array} dest 目的地柱子
 * @param {String} sourceName 源柱子的名字
 * @param {String} helperName 輔助柱子的名字
 * @param {String} destName 目的地柱子的名字
 * @param {Array} moves 步驟儲存器，儲存每一步的流程
 */
function moveOfHanoi(
  plates,
  source,
  helper,
  dest,
  sourceName,
  helperName,
  destName,
  moves = []
) {
  if (plates <= 0) {
    return moves
  } else if (plates === 1) {
    // 彈出源柱子上剩下的最大圓盤，並將其壓入目標柱子
    dest.push(source.pop())
    num++
    let sourceArr = source.toString()
    let helperArr = helper.toString()
    let destArr = dest.toString()
    let movestr = `第 ${num} 步，將圓盤 ${plates} 從 ${sourceName} 移至 ${destName}; ${sourceName}: [${sourceArr}],${helperName}: [${helperArr}],${destName}: [${destArr}]`
    moves.push(movestr)
  } else {
    moveOfHanoi(
      plates - 1,
      source,
      dest,
      helper,
      sourceName,
      destName,
      helperName,
      moves
    )

    // 彈出源柱子上剩下的最大圓盤，並將其壓入目標柱子
    dest.push(source.pop())
    num++
    let sourceArr = source.toString()
    let helperArr = helper.toString()
    let destArr = dest.toString()
    let movestr = `第 ${num} 步，將圓盤 ${plates} 從 ${sourceName} 移至 ${destName}; ${sourceName}: [${sourceArr}],${helperName}: [${helperArr}],${destName}: [${destArr}]`
    moves.push(movestr)

    moveOfHanoi(
      plates - 1,
      helper,
      source,
      dest,
      helperName,
      sourceName,
      destName,
      moves
    )
  }
  return moves
}

/**
 * 漢諾塔
 * 記錄每一次圓盤移動的動作。從${源柱子}到${目標柱子}
 * @param {Int32Array} plates 圓盤的個數
 * @param {String} sourceName 源柱子的名稱
 * @param {String} helperName 輔助柱子的名稱
 * @param {String} destName 目標柱子的名稱
 */
function hanoiStackArray(plates, sourceName, helperName, destName) {
  let source = new Stack()
  let helper = new Stack()
  let dest = new Stack()

  for (let i = plates; i > 0; i--) {
    source.push(i)
  }
  num = 0
  return moveOfHanoi(
    plates,
    source,
    helper,
    dest,
    sourceName,
    helperName,
    destName
  )
}

[完]