摘要：紅黑樹的刪除可能出現的情形討論刪除紅黑樹中一個結點，刪除的結點是其子結點狀態和顏色的組合。組合被刪結點無子結點，且被刪結點為紅色此時直接將結點刪除即可，不破壞任何紅黑樹的性質。

刪除紅黑樹中一個結點，刪除的結點是其子結點狀態和顏色的組合。子結點的狀態有三種：無子結點、只有一個子結點、有兩個子結點。顏色有紅色和黑色兩種。所以共會有6種組合。

此時直接將結點刪除即可，不破壞任何紅黑樹的性質。

處理方法略微復雜，稍后再議。

這種組合是不存在的，如圖假如被刪結點node只有一個有值的子結點value，而以value為根結點的子樹中，必然還存在null結點，如此不符合紅黑樹的性質5，對每個結點，從該結點到其所有后代葉結點的簡單路徑上，均包含相同數目的黑色結點。

這種組合下，被刪結點node的另一個子結點value必然為紅色，此時直接將node刪掉，用value代替node的位置，并將value著黑即可。

當被刪結點node有兩個子結點時，先要找到這個被刪結點的后繼結點successor，然后用successor代替node的位置，同時著成node的顏色，此時相當于successor被刪。

因為node有兩個子結點，所以successor必然在node的右子樹中，必然是下圖兩種形態中的一種。

若是(a)的情形，用successor代替node后，相當于successor被刪，若successor為紅色，則變成了組合1；若successor為黑色，則變成了組合2。

若是(b)的情形，用successor代替node后，相當于successor被刪，若successor為紅色，則變成了組合1；若successor為黑色，則變成了組合2或4。

若被刪結點是組合1或組合4的狀態，很容易處理；被刪結點不可能是組合3的狀態；被刪結點是組合5&6的狀態，將變成組合1或組合2或組合4。

因為刪除黑色結點會破壞紅黑樹的性質5，所以為了不破壞性質5，在替代結點上額外增加一個黑色，這樣不違背性質5而只違背性質1，每個結點或是黑色或是紅色。此時將額外的黑色移除，則完成刪除操作。

然后再結合node原來的父結點father和其兄弟結點brother來分析。

brother為黑色，且brother有一個與其方向一致的紅色子結點son，所謂方向一致，是指brother為father的左子結點，son也為brother的左子結點；或者brother為father的右子結點，son也為brother的右子結點。

圖(c)中，白色代表隨便是黑或是紅，方形結點除了存儲自身黑色外，還額外存儲一個黑色。將brother和father旋轉，并重新上色后，變成了圖(d)，方形結點額外存儲的黑色轉移到了father，且不違背任何紅黑樹的性質，刪除操作完成。

圖(c)中的情形顛倒過來，也是一樣的操作。

brother為黑色，且brother有一個與其方向不一致的紅色子結點son

圖(e)中，將son和brother旋轉，重新上色后，變成了圖(f)，情形一。

圖(e)中的情形顛倒過來，也是一樣的操作。

brother為黑色，且brother無紅色子結點

此時若father為紅，則重新著色即可，刪除操作完成。如圖下圖(g)和(h)。

此時若father為黑，則重新著色，將額外的黑色存到father，將father作為新的結點進行情形判斷，遇到情形一、情形二，則進行相應的調整，完成刪除操作；如果沒有，則結點一直上移，直到根結點存儲額外的黑色，此時將該額外的黑色移除，即完成了刪除操作。

brother為紅色，則father必為黑色。

圖(i)中，將brother和father旋轉，重新上色后，變成了圖(j)，新的brother變成了黑色，這樣就成了情形一、二、三中的一種。如果將son和brother旋轉，無論怎么重新上色，都會破壞紅黑樹的性質4或5，例如圖(k)。
圖(i)中的情形顛倒過來，也是一樣的操作。

// 結點
function Node(value) {
  this.value = value
  this.color = "red" // 結點的顏色默認為紅色
  this.parent = null
  this.left = null
  this.right = null
}

function RedBlackTree() {
  this.root = null
}

RedBlackTree.prototype.insert = function (node) {
  // 以二叉搜索樹的方式插入結點
  // 如果根結點不存在，則結點作為根結點
  // 如果結點的值小于node，且結點的右子結點不存在，跳出循環
  // 如果結點的值大于等于node，且結點的左子結點不存在，跳出循環
  if (!this.root) {
    this.root = node
  } else {
    let current = this.root
    while (current[node.value <= current.value ? "left" : "right"]) {
      current = current[node.value <= current.value ? "left" : "right"]
    }
    current[node.value <= current.value ? "left" : "right"] = node
    node.parent = current
  }
  // 判斷情形
  this._fixTree(node)
  return this
}

RedBlackTree.prototype._fixTree = function (node) {
  // 當node.parent不存在時，即為情形1，跳出循環
  // 當node.parent.color === "black"時，即為情形2，跳出循環
  while (node.parent && node.parent.color !== "black") {
    // 情形3
    let father = node.parent
    let grand = father.parent
    let uncle = grand[grand.left === father ? "right" : "left"]
    if (!uncle || uncle.color === "black") {
      // 葉結點也是黑色的
      // 情形3.1
      let directionFromFatherToNode = father.left === node ? "left" : "right"
      let directionFromGrandToFather = grand.left === father ? "left" : "right"
      if (directionFromFatherToNode === directionFromGrandToFather) {
        // 具體情形一或二
        // 旋轉
        this._rotate(father)
        // 變色
        father.color = "black"
        grand.color = "red"
      } else {
        // 具體情形三或四
        // 旋轉
        this._rotate(node)
        this._rotate(node)
        // 變色
        node.color = "black"
        grand.color = "red"
      }
      break // 完成插入，跳出循環
    } else {
      // 情形3.2
      // 變色
      grand.color = "red"
      father.color = "black"
      uncle.color = "black"
      // 將grand設為新的node
      node = grand
    }
  }

  if (!node.parent) {
    // 如果是情形1
    node.color = "black"
    this.root = node
  }
}

RedBlackTree.prototype._rotate = function (node) {
  // 旋轉 node 和 node.parent
  let y = node.parent
  if (y.right === node) {
    if (y.parent) {
      y.parent[y.parent.left === y ? "left" : "right"] = node
    }
    node.parent = y.parent
    if (node.left) {
      node.left.parent = y
    }
    y.right = node.left
    node.left = y
    y.parent = node
  } else {
    if (y.parent) {
      y.parent[y.parent.left === y ? "left" : "right"] = node
    }
    node.parent = y.parent
    if (node.right) {
      node.right.parent = y
    }
    y.left = node.right
    node.right = y
    y.parent = node
  }
}

RedBlackTree.prototype.remove = function (node) {
  while (true) {
    let {
      left,
      right,
      parent,
      color
    } = node
    // 組合1
    if (!left && !right && color === "red") {
      parent[parent.left === node ? "left" : "right"] = null
      return this
    }
    // 組合2
    if (!left && !right && color === "black") {
      if (parent) {
        let nullNode = new Node(null)
        nullNode.parent = parent
        nullNode.color = ["black", "black"]
        parent[parent.left === node ? "left" : "right"] = nullNode
        this._repairTree(nullNode)
      } else {
        this.root = null
      }
      return this
    }
    // 組合4
    if ((!left && right && color === "black") || (left && !right && color === "black")) {
      if (parent) {
        parent[parent.left === node ? "left" : "right"] = node.left || node.right
      } else {
        this.root = node.left || node.right
      }
      node[node.left ? "left" : "right"].color = "black"
      return this
    }
    // 組合5&6
    if (left && right) {
      // 尋找后繼結點
      let successor = right
      while (successor.left) {
        successor = successor.left
      }
      // 用后繼結點代替node
      node.value = successor.value
      // 刪除后街結點
      node = successor
      /* let successorColor = successor.color
      let successorLeft = successor.left
      let successorRight = successor.right
      let successorParent = successor.parent
      // 用后繼節點代替node
      if (parent) {
        parent[parent.left === node ? "left" : "right"] = successor
      } else {
        this.root = successor
      }
      successor.parent = parent
      successor.left = left
      successor.right = right
      left.parent = successor
      right.parent = successor
      successor.color = color
      // 刪除successor
      node.left = successorLeft
      node.right = successorRight
      node.parent = successorParent
      node.color = successorColor */
    }
  }
}

RedBlackTree.prototype._repairTree = function (node) {
  while (node.parent) {
    let father = node.parent
    let brother = father[father.left === node ? "right" : "left"]
    let son = brother[father.left === node ? "right" : "left"]
    let daugh = brother[father.left === node ? "left" : "right"]
    if (brother.color === "black") {
      if (son && son.color === "red") {
        // 情形一
        // 旋轉brother和father
        this._rotate(brother)
        // 變色
        brother.color = father.color
        father.color = "black"
        son.color = "black"
        // 移除black
        if (!node.value) {
          // nullNode
          father[father.left === node ? "left" : "right"] = null
        } else {
          node.color = "black"
        }
        // 刪除操作完成
        return
      } else if (daugh && daugh.color === "red") {
        // 情形二
        // 旋轉son和brother
        this._rotate(son)
        // 變色
        son.color = "black"
        brother.color = "red"
        // 變成情形一，繼續循環
      } else {
        // 情形三
        // brother無紅子結點
        if (father.color === "red") {
          // father為紅色
          father.color = "black"
          brother.color = "red"
          // 移除black
          if (!node.value) {
            // nullNode
            father[father.left === node ? "left" : "right"] = null
          } else {
            node.color = "black"
          }
          // 刪除操作完成
          return
        } else {
          // father為黑色
          father.color = ["black", "black"]
          brother.color = "red"
          // 移除black
          if (!node.value) {
            // nullNode
            father[father.left === node ? "left" : "right"] = null
          } else {
            node.color = "black"
          }
          node = father
          // 結點上移，繼續循環
        }
      }
    } else {
      // 情形四
      this._rotate(brother)
      brother.color = "black"
      father.color = "red"
      // 繼續循環
    }
  }
  this.root = node
  node.color = "black"
}

RedBlackTree.prototype.find = function (value) {
  let current = this.root
  while (current.value !== value) {
    current = current[value >= current.value ? "right" : "left"]
  }
  return current
}

let arr = [11, 2, 14, 1, 7, 15, 5, 8, 4]
let tree = new RedBlackTree()
arr.forEach(i => tree.insert(new Node(i)))
let findNode = tree.find(15)
tree.remove(findNode)
debugger

紅黑樹的插入

紅黑樹的插入和刪除都是通過分類討論來解決的，耐心的分析即可。
為數不多使用技巧的地方，是為了維持紅黑樹的性質，在結點上存兩個黑色，當然這是算法導論告訴我的。