2-3树和左倾红黑树

某些教程不区分普通红黑树和左倾红黑树的区别，直接将左倾红黑树拿来教学，并且称其为红黑树，因为左倾红黑树与普通的红黑树相比，实现起来较为简单，容易教学。在这里，我们区分开左倾红黑树和普通红黑树。

红黑树是一种近似平衡的二叉查找树，从 2-3 树或 2-3-4 树衍生而来。通过对二叉树节点进行染色，染色为红或黑节点，来模仿 2-3 树或 2-3-4 树的3节点和4节点，从而让树的高度减小。2-3-4 树对照实现的红黑树是普通的红黑树，而 2-3 树对照实现的红黑树是一种变种，称为左倾红黑树，其更容易实现。

使用平衡树数据结构，可以提高查找元素的速度，我们在本章介绍 2-3 树，再用二叉树形式来实现 2-3 树，也就是左倾红黑树。

一、2-3 树

1.1. 2-3 树介绍

2-3 树是一棵严格自平衡的多路查找树，由1986年图灵奖得主，美国理论计算机科学家 John Edward Hopcroft 在1970年发明，又称 3阶的B树 (注：B 为 Balance 平衡的意思)

它不是一棵二叉树，是一棵三叉树。具有以下特征：

  1. 内部节点要么有1个数据元素和2个孩子，要么有2个数据元素和3个孩子，叶子节点没有孩子，但有1或2个数据元素。
  2. 所有叶子节点到根节点的长度一致。这个特征保证了完全平衡，非常完美的平衡。
  3. 每个节点的数据元素保持从小到大排序，两个数据元素之间的子树的所有值大小介于两个数据元素之间。

因为 2-3 树的第二个特征，它是一棵完美平衡的树，非常完美，除了叶子节点，其他的节点都没有空儿子，所以树的高度非常的小。

如图：

2-3树和左倾红黑树 - 图1

如果一个内部节点拥有一个数据元素、两个子节点，则此节点为2节点。如果一个内部节点拥有两个数据元素、三个子节点，则此节点为3节点。

可以说，所有平衡树的核心都在于插入和删除逻辑，我们主要分析这两个操作。

1.2. 2-3 树插入元素

在插入元素时，需要先找到插入的位置，使用二分查找从上自下查找树节点。

找到插入位置时，将元素插入该位置，然后进行调整，使得满足 2-3 树的特征。主要有三种情况：

  1. 插入元素到一个2节点，直接插入即可，这样节点变成3节点。
  2. 插入元素到一个3节点，该3节点的父亲是一个2节点，先将节点变成临时的4节点，然后向上分裂调整一次。
  3. 插入元素到一个3节点，该3节点的父亲是一个3节点，先将节点变成临时的4节点，然后向上分裂调整，此时父亲节点变为临时4节点，继续向上分裂调整。

如图（来自维基百科）：

2-3树和左倾红黑树 - 图2

核心在于插入3节点后，该节点变为临时4节点，然后进行分裂恢复树的特征。最坏情况为插入节点后，每一次分裂后都导致上一层变为临时4节点，直到树根节点，这样需要不断向上分裂。

临时4节点的分裂，细分有六种情况，如图：

2-3树和左倾红黑树 - 图3

与其他二叉查找树由上而下生长不同，2-3 树是从下至上的生长。

2-3 树的实现将会放在 B树 章节，我们将会在此章节实现其二叉树形式的左倾红黑树结构。

1.3. 2-3 树删除元素

删除操作就复杂得多了，请耐心阅读理解。

2-3 树的特征注定它是一棵非常完美平衡的三叉树，其所有子树也都是完美平衡，所以 2-3 树的某节点的儿子，要么都是空儿子，要么都不是空儿子。比如 2-3 树的某个节点 A 有两个儿子 B 和 C，儿子 B 和 C 要么都没有孩子，要么孩子都是满的，不然 2-3 树所有叶子节点到根节点的长度一致这个特征就被破坏了。

基于上面的现实，我们来分析删除的不同情况，删除中间节点和叶子节点。

情况1：删除中间节点

删除的是非叶子节点，该节点一定是有两棵或者三棵子树的，那么从子树中找到其最小后继节点，该节点是叶子节点，用该节点替换被删除的非叶子节点，然后再删除这个叶子节点，进入情况2。

如何找到最小后继节点，当有两棵子树时，那么从右子树一直往左下方找，如果有三棵子树，被删除节点在左边，那么从中子树一直往左下方找，否则从右子树一直往左下方找。

情况2：删除叶子节点

删除的是叶子节点，这时如果叶子节点是3节点，那么直接变为2节点即可，不影响平衡。但是，如果叶子节点是2节点，那么删除后，其父节点将会缺失一个儿子，破坏了满孩子的 2-3 树特征，需要进行调整后才能删除。

针对情况2，删除一个2节点的叶子节点，会导致父节点缺失一个儿子，破坏了 2-3 树的特征，我们可以进行调整变换，主要有两种调整：

  1. 重新分布：尝试从兄弟节点那里借值，然后重新调整节点。
  2. 合并：如果兄弟借不到值，合并节点（与父亲的元素），再向上递归处理。

看图说话：

2-3树和左倾红黑树 - 图4

如果被删除的叶子节点有兄弟是3节点，那么从兄弟那里借一个值填补被删除的叶子节点，然后兄弟和父亲重新分布调整位置。下面是重新分布的具体例子：

2-3树和左倾红黑树 - 图5

可以看到，删除 100，从兄弟那里借来一个值 80，然后重新调整父亲，兄弟们的位置。

如果兄弟们都是2节点呢，那么就合并节点：将父亲和兄弟节点合并，如果父亲是2节点，那么父亲就留空了，否则父亲就从3节点变成2节点，下面是合并的两个具体例子：

2-3树和左倾红黑树 - 图6

可以看到，删除 80，而兄弟节点 60 和父亲节点 90 都是个2节点，所以父亲下来和兄弟合并，然后父亲变为空节点。

2-3树和左倾红黑树 - 图7

可以看到，删除 70，而兄弟节点都为2节点，父亲节点为3节点，那么父亲下来和其中一个兄弟合并，然后父亲从3节点变为2节点。

但是，如果合并后，父亲节点变空了，也就是说有中间节点留空要怎么办，那么可以继续递归处理，如图：

2-3树和左倾红黑树 - 图8

中间节点是空的，那么可以继续从兄弟那里借节点或者和父亲合并，直到根节点，如果到达了根节点呢，如图：

2-3树和左倾红黑树 - 图9

递归到了根节点后，如果存在空的根节点，我们可以直接把该空节点删除即可，这时树的高度减少一层。

2-3 树的实现将会放在 B树 章节，我们将会实现其二叉树形式的左倾红黑树结构。

二、 左倾红黑树

2.1. 左倾红黑树介绍

左倾红黑树可以由 2-3 树的二叉树形式来实现。

其定义为：

  1. 根节点的链接是黑色的。
  2. 红链接均为左链接。
  3. 没有任何一个结点同时和两条红链接相连
  4. 任意一个节点到达叶子节点的所有路径，经过的黑链接数量相同，也就是该树是完美黑色平衡的。比如，某一个节点，它可以到达5个叶子节点，那么这5条路径上的黑链接数量一样。

由于红链接都在左边，所以这种红黑树又称左倾红黑树。左倾红黑树与 2-3 树一一对应，只要将左链接画平，如图：

2-3树和左倾红黑树 - 图10

2.2. 节点旋转和颜色转换

首先，我们要定义树的结构 LLRBTree ，以及表示左倾红黑树的节点 LLRBTNode：

  1. // 定义颜色
  2. const (
  3.     RED   = true
  4.     BLACK = false
  5. )
  7. // 左倾红黑树
  8. type LLRBTree struct {
  9.     Root *LLRBTNode // 树根节点
  10. }
  13. // 左倾红黑树节点
  14. type LLRBTNode struct {
  15.     Value       int64     // 值
  16.     Times       int64      // 值出现的次数
  17.     Left        *LLRBTNode // 左子树
  18.     Right       *LLRBTNode // 右子树
  19.     Color       bool       // 父亲指向该节点的链接颜色
  20. }
  22. // 新建一棵空树
  23. func NewLLRBTree() *LLRBTree {
  24.     return &LLRBTree{}
  25. }
  27. // 节点的颜色
  28. func IsRed(node *LLRBTNode) bool {
  29.     if node == nil {
  30.         return false
  31.     }
  32.     return node.Color == RED
  33. }

在节点 LLRBTNode 中，我们存储的元素字段为 Value，由于可能有重复的元素插入，所以多了一个 Times 字段，表示该元素出现几次。

当然，红黑树中的红黑颜色使用 Color 定义，表示父亲指向该节点的链接颜色。为了方便，我们还构造了一个辅助函数 IsRed()。

在元素添加和实现的过程中，需要做调整操作，有两种旋转操作，对某节点的右链接进行左旋转，或者左链接进行右旋转。

如图是对节点 h 的右链接进行左旋转：

2-3树和左倾红黑树 - 图11

代码实现如下：

  1. // 左旋转
  2. func RotateLeft(h *LLRBTNode) *LLRBTNode {
  3.     if h == nil {
  4.         return nil
  5.     }
  7.     // 看图理解
  8.     x := h.Right
  9.     h.Right = x.Left
  10.     x.Left = h
  11.     x.Color = h.Color
  12.     h.Color = RED
  13.     return x
  14. }

如图是对节点 h 的左链接进行右旋转：

2-3树和左倾红黑树 - 图12

代码实现如下：

  1. // 右旋转
  2. func RotateRight(h *LLRBTNode) *LLRBTNode {
  3.     if h == nil {
  4.         return nil
  5.     }
  7.     // 看图理解
  8.     x := h.Left
  9.     h.Left = x.Right
  10.     x.Right = h
  11.     x.Color = h.Color
  12.     h.Color = RED
  13.     return x
  14. }

由于左倾红黑树不允许一个节点有两个红链接，所以需要做颜色转换，如图：

2-3树和左倾红黑树 - 图13

代码如下：

  1. // 颜色转换
  2. func ColorChange(h *LLRBTNode) {
  3.     if h == nil {
  4.         return
  5.     }
  6.     h.Color = !h.Color
  7.     h.Left.Color = !h.Left.Color
  8.     h.Right.Color = !h.Right.Color
  9. }

旋转和颜色转换作为局部调整，并不影响全局。

2.3. 添加元素实现

每次添加元素节点时，都将该节点 Color 字段，也就是父亲指向它的链接设置为 RED 红色。

接着判断其父亲是否有两个红链接（如连续的两个左红链接或者左右红色链接），或者有右红色链接，进行颜色变换或旋转操作。

主要有以下这几种情况。

插入元素到2节点，直接让节点变为3节点，不过当右插入时需要左旋使得红色链接在左边，如图：

2-3树和左倾红黑树 - 图14

插入元素到3节点，需要做旋转和颜色转换操作，如图：

2-3树和左倾红黑树 - 图15

也就是说，在一个已经是红色左链接的节点，插入一个新节点的状态变化如下：

2-3树和左倾红黑树 - 图16

根据上述的演示图以及旋转，颜色转换等操作，添加元素的代码为：

  1. // 左倾红黑树添加元素
  2. func (tree *LLRBTree) Add(value int64) {
  3.     // 跟节点开始添加元素，因为可能调整，所以需要将返回的节点赋值回根节点
  4.     tree.Root = tree.Root.Add(value)
  5.     // 根节点的链接永远都是黑色的
  6.     tree.Root.Color = BLACK
  7. }
  9. // 往节点添加元素
  10. func (node *LLRBTNode) Add(value int64) *LLRBTNode {
  11.     // 插入的节点为空，将其链接颜色设置为红色，并返回
  12.     if node == nil {
  13.         return &LLRBTNode{
  14.             Value: value,
  15.             Color: RED,
  16.         }
  17.     }
  19.     // 插入的元素重复
  20.     if value == node.Value {
  21.         node.Times = node.Times + 1
  22.     } else if value > node.Value {
  23.         // 插入的元素比节点值大，往右子树插入
  24.         node.Right = node.Right.Add(value)
  25.     } else {
  26.         // 插入的元素比节点值小，往左子树插入
  27.         node.Left = node.Left.Add(value)
  28.     }
  30.     // 辅助变量
  31.     nowNode := node
  33.     // 右链接为红色，那么进行左旋，确保树是左倾的
  34.     // 这里做完操作后就可以结束了，因为插入操作，新插入的右红链接左旋后，nowNode节点不会出现连续两个红左链接，因为它只有一个左红链接
  35.     if IsRed(nowNode.Right) && !IsRed(nowNode.Left) {
  36.         nowNode = RotateLeft(nowNode)
  37.     } else {
  38.         // 连续两个左链接为红色，那么进行右旋
  39.         if IsRed(nowNode.Left) && IsRed(nowNode.Left.Left) {
  40.             nowNode = RotateRight(nowNode)
  41.         }
  43.         // 旋转后，可能左右链接都为红色，需要变色
  44.         if IsRed(nowNode.Left) && IsRed(nowNode.Right) {
  45.             ColorChange(nowNode)
  46.         }
  47.     }
  49.     return nowNode
  50. }

2.4. 添加元素算法分析

可参考论文： Left-leaning Red-Black Trees。

左倾红黑树的最坏树高度为 2log(n)，其中 n 为树的节点数量。为什么呢，我们先把左倾红黑树当作 2-3 树，也就是说最坏情况下沿着 2-3 树左边的节点都是3节点，其他节点都是2节点，这时树高近似 log(n)，再从 2-3 树转成左倾红黑树，当3节点不画平时，可以知道树高变成原来 2-3 树树高的两倍。虽然如此，构造一棵最坏的左倾红黑树很难。

AVL 树的最坏树高度为 1.44log(n)。由于左倾红黑树是近似平衡的二叉树，没有 AVL 树的严格平衡，树的高度会更高一点，因此查找操作效率比 AVL 树低，但时间复杂度只在于常数项的差别，去掉常数项，时间复杂度仍然是 log(n)。

我们的代码实现中，左倾红黑树的插入，需要逐层判断是否需要旋转和变色，复杂度为 log(n)，当旋转变色后导致上层存在连续的红左链接或者红色左右链接，那么需要继续旋转和变色，可能有多次这种调整操作，如图在箭头处添加新节点，出现了右红链接，要一直向上变色到根节点（实际上穿投到根节点的情况极少发生）：

2-3树和左倾红黑树 - 图17

我们可以优化代码，使得在某一层旋转变色后，如果其父层没有连续的左红链接或者不需要变色，那么可以直接退出，不需要逐层判断是否需要旋转和变色。

对于 AVL 树来说，插入最多旋转两次，但其需要逐层更新树高度，复杂度也是为 log(n)。

按照插入效率来说，很多教程都说左倾红黑树会比 AVL 树好一点，因为其不要求严格的平衡，会插入得更快点，但根据我们实际上的递归代码，两者都需要逐层向上判断是否需要调整，只不过 AVL 树多了更新树高度的操作，此操作影响了一点点效率，但我觉得两种树的插入效率都差不多。

在此，我们不再纠结两种平衡树哪种更好，因为代码实现中，两种平衡树都需要自底向上的递归操作，效率差别不大。。

2.5. 删除元素实现

删除操作就复杂得多了。对照一下 2-3 树。

  1. 情况1：如果删除的是非叶子节点，找到其最小后驱节点，也就是在其右子树中一直向左找，找到的该叶子节点替换被删除的节点，然后删除该叶子节点，变成情况2。
  2. 情况2：如果删除的是叶子节点，如果它是红节点，也就是父亲指向它的链接为红色，那么直接删除即可。否则，我们需要进行调整，使它变为红节点，再删除。

在这里，为了使得删除叶子节点时可以直接删除，叶子节点必须变为红节点。（在 2-3 树中，也就是2节点要变成3节点，我们知道要不和父亲合并再递归向上，要不向兄弟借值然后重新分布）

我们创造两种操作，如果删除的节点在左子树中，可能需要进行红色左移，如果删除的节点在右子树中，可能需要进行红色右移。

我们介绍红色左移的步骤：

要在树 h 的的左子树中删除元素，这时树 h 根节点是红节点，其儿子 b，d 节点都为黑色节点，且两个黑色节点都是2节点，都没有左红孩子，那么直接对 h 树根节点变色即可（相当于 2-3 树：把父亲的一个值拉下来合并），如图：

2-3树和左倾红黑树 - 图18

如果存在右儿子 d 是3节点，有左红孩子 e，那么需要先对 h 树根节点变色后，对右儿子 d 右旋，再对 h 树根节点左旋，最后再一次对 h 树根节点变色（相当于 2-3 树：向3节点兄弟借值，然后重新分布），如图：

2-3树和左倾红黑树 - 图19

红色左移可以总结为下图（被删除的节点在左子树，且进入的树根h一定为红节点）：

2-3树和左倾红黑树 - 图20

代码如下：

  1. // 红色左移
  2. // 节点 h 是红节点，其左儿子和左儿子的左儿子都为黑节点，左移后使得其左儿子或左儿子的左儿子有一个是红色节点
  3. func MoveRedLeft(h *LLRBTNode) *LLRBTNode {
  4.     // 应该确保 isRed(h) && !isRed(h.left) && !isRed(h.left.left)
  5.     ColorChange(h)
  7.     // 右儿子有左红链接
  8.     if IsRed(h.Right.Left) {
  9.         // 对右儿子右旋
  10.         h.Right = RotateRight(h.Right)
  11.         // 再左旋
  12.         h = RotateLeft(h)
  13.         ColorChange(h)
  14.     }
  16.     return h
  17. }

为什么要红色左移，是要保证调整后，子树根节点 h 的左儿子或左儿子的左儿子有一个是红色节点，这样从 h 的左子树递归删除元素才可以继续下去。

红色右移的步骤类似，如图（被删除的节点在右子树，且进入的树根h一定为红节点）：

2-3树和左倾红黑树 - 图21

代码如下：

  1. // 红色右移
  2. // 节点 h 是红节点，其右儿子和右儿子的左儿子都为黑节点，右移后使得其右儿子或右儿子的右儿子有一个是红色节点
  3. func MoveRedRight(h *LLRBTNode) *LLRBTNode {
  4.     // 应该确保 isRed(h) && !isRed(h.right) && !isRed(h.right.left);
  5.     ColorChange(h)
  7.     // 左儿子有左红链接
  8.     if IsRed(h.Left.Left) {
  9.         // 右旋
  10.         h = RotateRight(h)
  11.         // 变色
  12.         ColorChange(h)
  13.     }
  15.     return h
  16. }

为什么要红色右移，同样是为了保证树根节点 h 的右儿子或右儿子的右儿子有一个是红色节点，往右子树递归删除元素可以继续下去。

介绍完两种操作后，我们要明确一下到底是如何删除元素的。

我们知道 2-3 树的删除是从叶子节点开始，自底向上的向兄弟节点借值，或和父亲合并，然后一直递归到根节点。左倾红黑树参考了这种做法，但更巧妙，左倾红黑树要保证一路上每次递归进入删除操作的子树树根一定是一个3节点，所以需要适当的红色左移或右移（类似于 2-3 树借值和合并），这样一直递归到叶子节点，叶子节点也会是一个3节点，然后就可以直接删除叶子节点，最后再自底向上的恢复左倾红黑树的特征。

下面是左倾红黑树从 树h 删除元素的示例图，往 树h 左子树和右子树删除元素分别有四种情况，后两种情况需要使用到红色左移或右移，状态演变之后， 树h 才可以从左或右子树进入下一次递归：

2-3树和左倾红黑树 - 图22

可以对照着大图，继续阅读下面的左倾红黑树删除元素代码：

  1. // 左倾红黑树删除元素
  2. func (tree *LLRBTree) Delete(value int64) {
  3.     // 当找不到值时直接返回
  4.     if tree.Find(value) == nil {
  5.         return
  6.     }
  8.     if !IsRed(tree.Root.Left) && !IsRed(tree.Root.Right) {
  9.         // 左右子树都是黑节点，那么先将根节点变为红节点，方便后面的红色左移或右移
  10.         tree.Root.Color = RED
  11.     }
  13.     tree.Root = tree.Root.Delete(value)
  15.     // 最后，如果根节点非空，永远都要为黑节点，赋值黑色
  16.     if tree.Root != nil {
  17.         tree.Root.Color = BLACK
  18.     }
  19. }

首先 tree.Find(value) 找到可以删除的值时才能进行删除。

当根节点的左右子树都为黑节点时，那么先将根节点变为红节点，方便后面的红色左移或右移。

删除完节点：tree.Root = tree.Root.Delete(value) 后，需要将根节点染回黑色，因为左倾红黑树的特征之一是根节点永远都是黑色。

核心的从子树中删除元素代码如下：

  1. // 对该节点所在的子树删除元素
  2. func (node *LLRBTNode) Delete(value int64) *LLRBTNode {
  3.     // 辅助变量
  4.     nowNode := node
  5.     // 删除的元素比子树根节点小，需要从左子树删除
  6.     if value < nowNode.Value {
  7.         // 因为从左子树删除，所以要判断是否需要红色左移
  8.         if !IsRed(nowNode.Left) && !IsRed(nowNode.Left.Left) {
  9.             // 左儿子和左儿子的左儿子都不是红色节点，那么没法递归下去，先红色左移
  10.             nowNode = MoveRedLeft(nowNode)
  11.         }
  13.         // 现在可以从左子树中删除了
  14.         nowNode.Left = nowNode.Left.Delete(value)
  15.     } else {
  16.         // 删除的元素等于或大于树根节点
  18.         // 左节点为红色，那么需要右旋，方便后面可以红色右移
  19.         if IsRed(nowNode.Left) {
  20.             nowNode = RotateRight(nowNode)
  21.         }
  23.         // 值相等，且没有右孩子节点，那么该节点一定是要被删除的叶子节点，直接删除
  24.         // 为什么呢，反证，它没有右儿子，但有左儿子，因为左倾红黑树的特征，那么左儿子一定是红色，但是前面的语句已经把红色左儿子右旋到右边，不应该出现右儿子为空。
  25.         if value == nowNode.Value && nowNode.Right == nil {
  26.             return nil
  27.         }
  29.         // 因为从右子树删除，所以要判断是否需要红色右移
  30.         if !IsRed(nowNode.Right) && !IsRed(nowNode.Right.Left) {
  31.             // 右儿子和右儿子的左儿子都不是红色节点，那么没法递归下去，先红色右移
  32.             nowNode = MoveRedRight(nowNode)
  33.         }
  35.         // 删除的节点找到了，它是中间节点，需要用最小后驱节点来替换它，然后删除最小后驱节点
  36.         if value == nowNode.Value {
  37.             minNode := nowNode.Right.FindMinValue()
  38.             nowNode.Value = minNode.Value
  39.             nowNode.Times = minNode.Times
  41.             // 删除其最小后驱节点
  42.             nowNode.Right = nowNode.Right.DeleteMin()
  43.         } else {
  44.             // 删除的元素比子树根节点大，需要从右子树删除
  45.             nowNode.Right = nowNode.Right.Delete(value)
  46.         }
  47.     }
  49.     // 最后，删除叶子节点后，需要恢复左倾红黑树特征
  50.     return nowNode.FixUp()
  51. }

这段核心代码十分复杂，会用到红色左移和右移，当删除的元素小于根节点时，我们明白要在左子树中删除，如：

  1.     // 删除的元素比子树根节点小，需要从左子树删除
  2.     if value < nowNode.Value {
  3.         // 因为从左子树删除，所以要判断是否需要红色左移
  4.         if !IsRed(nowNode.Left) && !IsRed(nowNode.Left.Left) {
  5.             // 左儿子和左儿子的左儿子都不是红色节点，那么没法递归下去，先红色左移
  6.             nowNode = MoveRedLeft(nowNode)
  7.         }
  9.         // 现在可以从左子树中删除了
  10.         nowNode.Left = nowNode.Left.Delete(value)
  11.     }

递归删除左子树前：nowNode.Left = nowNode.Left.Delete(value)，要确保删除的左子树根节点是红色节点，或左子树根节点的左儿子是红色节点，才能够继续递归下去，所以使用了 !IsRed(nowNode.Left) && !IsRed(nowNode.Left.Left) 来判断是否需要红色左移。

如果删除的值不小于根节点，那么进入以下逻辑（可仔细阅读注释）：

  1.         // 删除的元素等于或大于树根节点
  3.         // 左节点为红色，那么需要右旋，方便后面可以红色右移
  4.         if IsRed(nowNode.Left) {
  5.             nowNode = RotateRight(nowNode)
  6.         }
  8.         // 值相等，且没有右孩子节点，那么该节点一定是要被删除的叶子节点，直接删除
  9.         // 为什么呢，反证，它没有右儿子，但有左儿子，因为左倾红黑树的特征，那么左儿子一定是红色，但是前面的语句已经把红色左儿子右旋到右边，不应该出现右儿子为空。
  10.         if value == nowNode.Value && nowNode.Right == nil {
  11.             return nil
  12.         }
  14.         // 因为从右子树删除，所以要判断是否需要红色右移
  15.         if !IsRed(nowNode.Right) && !IsRed(nowNode.Right.Left) {
  16.             // 右儿子和右儿子的左儿子都不是红色节点，那么没法递归下去，先红色右移
  17.             nowNode = MoveRedRight(nowNode)
  18.         }
  20.         // 删除的节点找到了，它是中间节点，需要用最小后驱节点来替换它，然后删除最小后驱节点
  21.         if value == nowNode.Value {
  22.             minNode := nowNode.Right.FindMinValue()
  23.             nowNode.Value = minNode.Value
  24.             nowNode.Times = minNode.Times
  26.             // 删除其最小后驱节点
  27.             nowNode.Right = nowNode.Right.DeleteMin()
  28.         } else {
  29.             // 删除的元素比子树根节点大，需要从右子树删除
  30.             nowNode.Right = nowNode.Right.Delete(value)
  31.         }

首先，需要先判断该节点的左子树根节点是否为红色节点 IsRed(nowNode.Left)，如果是的话需要右旋：nowNode = RotateRight(nowNode)，将红节点右旋是为了后面可以递归进入右子树。

然后，判断删除的值是否等于当前根节点的值，且其没有右节点：value == nowNode.Value && nowNode.Right == nil，如果是，那么该节点就是要被删除的叶子节点，直接删除即可。

接着，判断是否需要红色右移：!IsRed(nowNode.Right) && !IsRed(nowNode.Right.Left)，如果该节点右儿子和右儿子的左儿子都不是红色节点，那么没法递归进入右子树，需要红色右移，必须确保其右子树或右子树的左儿子有一个是红色节点。

再接着，需要判断是否找到了要删除的节点：value == nowNode.Value，找到时表示要删除的节点处于内部节点，需要用最小后驱节点来替换它，然后删除最小后驱节点。

找到最小后驱节点：minNode := nowNode.Right.FindMinValue() 后，将最小后驱节点与要删除的内部节点替换，然后删除最小后驱节点：nowNode.Right = nowNode.Right.DeleteMin()，删除最小节点代码如下：

  1. // 对该节点所在的子树删除最小元素
  2. func (node *LLRBTNode) DeleteMin() *LLRBTNode {
  3.     // 辅助变量
  4.     nowNode := node
  6.     // 没有左子树，那么删除它自己
  7.     if nowNode.Left == nil {
  8.         return nil
  9.     }
  11.     // 判断是否需要红色左移，因为最小元素在左子树中
  12.     if !IsRed(nowNode.Left) && !IsRed(nowNode.Left.Left) {
  13.         nowNode = MoveRedLeft(nowNode)
  14.     }
  16.     // 递归从左子树删除
  17.     nowNode.Left = nowNode.Left.DeleteMin()
  19.     // 修复左倾红黑树特征
  20.     return nowNode.FixUp()
  21. }

因为最小节点在最左的叶子节点，所以只需要适当的红色左移，然后一直左子树递归即可。递归完后需要修复左倾红黑树特征 nowNode.FixUp()，代码如下：

  1. // 修复左倾红黑树特征
  2. func (node *LLRBTNode) FixUp() *LLRBTNode {
  3.     // 辅助变量
  4.     nowNode := node
  6.     // 红链接在右边，左旋恢复，让红链接只出现在左边
  7.     if IsRed(nowNode.Right) {
  8.         nowNode = RotateLeft(nowNode)
  9.     }
  11.     // 连续两个左链接为红色，那么进行右旋
  12.     if IsRed(nowNode.Left) && IsRed(nowNode.Left.Left) {
  13.         nowNode = RotateRight(nowNode)
  14.     }
  16.     // 旋转后，可能左右链接都为红色，需要变色
  17.     if IsRed(nowNode.Left) && IsRed(nowNode.Right) {
  18.         ColorChange(nowNode)
  19.     }
  21.     return nowNode
  22. }

如果不是删除内部节点，依然是从右子树继续递归：

  1.     // 删除的元素比子树根节点大，需要从右子树删除
  2.     nowNode.Right = nowNode.Right.Delete(value)

当然，递归完成后还要进行一次 FixUp()，恢复左倾红黑树的特征。

删除操作很难理解，可以多多思考，红色左移和右移不断地递归都是为了确保删除叶子节点时，其是一个3节点。

PS：如果不理解自顶向下的红色左移和右移递归思路，可以更换另外一种方法，使用原先 2-3树 删除元素操作步骤来实现，一开始从叶子节点删除，然后自底向上的向兄弟借值或与父亲合并，这是更容易理解的，我们不在这里进行展示了，可以借鉴普通红黑树章节的删除实现（它使用了自底向上的调整）。

完整代码见最下面。

2.6. 删除元素算法分析

左倾红黑树删除元素需要自顶向下的递归，可能不断地红色左移和右移，也就是有很多的旋转，当删除叶子节点后，还需要逐层恢复左倾红黑树的特征。时间复杂度仍然是和树高有关：log(n)。

2.7. 查找元素等实现

查找最小值，最大值，或者某个值，代码如下：

  1. // 找出最小值的节点
  2. func (tree *LLRBTree) FindMinValue() *LLRBTNode {
  3.     if tree.Root == nil {
  4.         // 如果是空树，返回空
  5.         return nil
  6.     }
  8.     return tree.Root.FindMinValue()
  9. }
  11. func (node *LLRBTNode) FindMinValue() *LLRBTNode {
  12.     // 左子树为空，表面已经是最左的节点了，该值就是最小值
  13.     if node.Left == nil {
  14.         return node
  15.     }
  17.     // 一直左子树递归
  18.     return node.Left.FindMinValue()
  19. }
  21. // 找出最大值的节点
  22. func (tree *LLRBTree) FindMaxValue() *LLRBTNode {
  23.     if tree.Root == nil {
  24.         // 如果是空树，返回空
  25.         return nil
  26.     }
  28.     return tree.Root.FindMaxValue()
  29. }
  31. func (node *LLRBTNode) FindMaxValue() *LLRBTNode {
  32.     // 右子树为空，表面已经是最右的节点了，该值就是最大值
  33.     if node.Right == nil {
  34.         return node
  35.     }
  37.     // 一直右子树递归
  38.     return node.Right.FindMaxValue()
  39. }
  41. // 查找指定节点
  42. func (tree *LLRBTree) Find(value int64) *LLRBTNode {
  43.     if tree.Root == nil {
  44.         // 如果是空树，返回空
  45.         return nil
  46.     }
  48.     return tree.Root.Find(value)
  49. }
  51. func (node *LLRBTNode) Find(value int64) *LLRBTNode {
  52.     if value == node.Value {
  53.         // 如果该节点刚刚等于该值，那么返回该节点
  54.         return node
  55.     } else if value < node.Value {
  56.         // 如果查找的值小于节点值，从节点的左子树开始找
  57.         if node.Left == nil {
  58.             // 左子树为空，表示找不到该值了，返回nil
  59.             return nil
  60.         }
  61.         return node.Left.Find(value)
  62.     } else {
  63.         // 如果查找的值大于节点值，从节点的右子树开始找
  64.         if node.Right == nil {
  65.             // 右子树为空，表示找不到该值了，返回nil
  66.             return nil
  67.         }
  68.         return node.Right.Find(value)
  69.     }
  70. }
  72. // 中序遍历
  73. func (tree *LLRBTree) MidOrder() {
  74.     tree.Root.MidOrder()
  75. }
  77. func (node *LLRBTNode) MidOrder() {
  78.     if node == nil {
  79.         return
  80.     }
  82.     // 先打印左子树
  83.     node.Left.MidOrder()
  85.     // 按照次数打印根节点
  86.     for i := 0; i <= int(node.Times); i++ {
  87.         fmt.Println(node.Value)
  88.     }
  90.     // 打印右子树
  91.     node.Right.MidOrder()
  92. }

查找操作逻辑与通用的二叉查找树一样，并无区别。

2.8. 验证是否是一棵左倾红黑树

如何确保我们的代码实现的就是一棵左倾红黑树呢，可以进行验证：

  1. // 验证是不是棵左倾红黑树
  2. func (tree *LLRBTree) IsLLRBTree() bool {
  3.     if tree == nil || tree.Root == nil {
  4.         return true
  5.     }
  7.     // 判断树是否是一棵二分查找树
  8.     if !tree.Root.IsBST() {
  9.         return false
  10.     }
  12.     // 判断树是否遵循2-3树，也就是红链接只能在左边，不能连续有两个红链接
  13.     if !tree.Root.Is23() {
  14.         return false
  15.     }
  17.     // 判断树是否平衡，也就是任意一个节点到叶子节点，经过的黑色链接数量相同
  18.     // 先计算根节点到最左边叶子节点的黑链接数量
  19.     blackNum := 0
  20.     x := tree.Root
  21.     for x != nil {
  22.         if !IsRed(x) { // 是黑色链接
  23.             blackNum = blackNum + 1
  24.         }
  25.         x = x.Left
  26.     }
  28.     if !tree.Root.IsBalanced(blackNum) {
  29.         return false
  30.     }
  31.     return true
  32. }
  34. // 节点所在的子树是否是一棵二分查找树
  35. func (node *LLRBTNode) IsBST() bool {
  36.     if node == nil {
  37.         return true
  38.     }
  40.     // 左子树非空，那么根节点必须大于左儿子节点
  41.     if node.Left != nil {
  42.         if node.Value > node.Left.Value {
  43.         } else {
  44.             fmt.Printf("father:%#v,lchild:%#v,rchild:%#v\n", node, node.Left, node.Right)
  45.             return false
  46.         }
  47.     }
  49.     // 右子树非空，那么根节点必须小于右儿子节点
  50.     if node.Right != nil {
  51.         if node.Value < node.Right.Value {
  52.         } else {
  53.             fmt.Printf("father:%#v,lchild:%#v,rchild:%#v\n", node, node.Left, node.Right)
  54.             return false
  55.         }
  56.     }
  58.     // 左子树也要判断是否是平衡查找树
  59.     if !node.Left.IsBST() {
  60.         return false
  61.     }
  63.     // 右子树也要判断是否是平衡查找树
  64.     if !node.Right.IsBST() {
  65.         return false
  66.     }
  68.     return true
  69. }
  71. // 节点所在的子树是否遵循2-3树
  72. func (node *LLRBTNode) Is23() bool {
  73.     if node == nil {
  74.         return true
  75.     }
  77.     // 不允许右倾红链接
  78.     if IsRed(node.Right) {
  79.         fmt.Printf("father:%#v,rchild:%#v\n", node, node.Right)
  80.         return false
  81.     }
  83.     // 不允许连续两个左红链接
  84.     if IsRed(node) && IsRed(node.Left) {
  85.         fmt.Printf("father:%#v,lchild:%#v\n", node, node.Left)
  86.         return false
  87.     }
  89.     // 左子树也要判断是否遵循2-3树
  90.     if !node.Left.Is23() {
  91.         return false
  92.     }
  94.     // 右子树也要判断是否是遵循2-3树
  95.     if !node.Right.Is23() {
  96.         return false
  97.     }
  99.     return true
  100. }
  102. // 节点所在的子树是否平衡，是否有 blackNum 个黑链接
  103. func (node *LLRBTNode) IsBalanced(blackNum int) bool {
  104.     if node == nil {
  105.         return blackNum == 0
  106.     }
  108.     if !IsRed(node) {
  109.         blackNum = blackNum - 1
  110.     }
  112.     if !node.Left.IsBalanced(blackNum) {
  113.         fmt.Println("node.Left to leaf black link is not ", blackNum)
  114.         return false
  115.     }
  117.     if !node.Right.IsBalanced(blackNum) {
  118.         fmt.Println("node.Right to leaf black link is not ", blackNum)
  119.         return false
  120.     }
  122.     return true
  123. }

运行请看完整代码。

2.9. 完整程序

  1. package main
  3. import "fmt"
  5. // 左倾红黑树实现
  6. // Left-leaning red-black tree
  8. // 定义颜色
  9. const (
  10.     RED   = true
  11.     BLACK = false
  12. )
  14. // 左倾红黑树
  15. type LLRBTree struct {
  16.     Root *LLRBTNode // 树根节点
  17. }
  19. // 新建一棵空树
  20. func NewLLRBTree() *LLRBTree {
  21.     return &LLRBTree{}
  22. }
  24. // 左倾红黑树节点
  25. type LLRBTNode struct {
  26.     Value int64      // 值
  27.     Times int64      // 值出现的次数
  28.     Left  *LLRBTNode // 左子树
  29.     Right *LLRBTNode // 右子树
  30.     Color bool       // 父亲指向该节点的链接颜色
  31. }
  33. // 节点的颜色
  34. func IsRed(node *LLRBTNode) bool {
  35.     if node == nil {
  36.         return false
  37.     }
  38.     return node.Color == RED
  39. }
  41. // 左旋转
  42. func RotateLeft(h *LLRBTNode) *LLRBTNode {
  43.     if h == nil {
  44.         return nil
  45.     }
  47.     // 看图理解
  48.     x := h.Right
  49.     h.Right = x.Left
  50.     x.Left = h
  51.     x.Color = h.Color
  52.     h.Color = RED
  53.     return x
  54. }
  56. // 右旋转
  57. func RotateRight(h *LLRBTNode) *LLRBTNode {
  58.     if h == nil {
  59.         return nil
  60.     }
  62.     // 看图理解
  63.     x := h.Left
  64.     h.Left = x.Right
  65.     x.Right = h
  66.     x.Color = h.Color
  67.     h.Color = RED
  68.     return x
  69. }
  71. // 红色左移
  72. // 节点 h 是红节点，其左儿子和左儿子的左儿子都为黑节点，左移后使得其左儿子或左儿子的左儿子有一个是红色节点
  73. func MoveRedLeft(h *LLRBTNode) *LLRBTNode {
  74.     // 应该确保 isRed(h) && !isRed(h.left) && !isRed(h.left.left)
  75.     ColorChange(h)
  77.     // 右儿子有左红链接
  78.     if IsRed(h.Right.Left) {
  79.         // 对右儿子右旋
  80.         h.Right = RotateRight(h.Right)
  81.         // 再左旋
  82.         h = RotateLeft(h)
  83.         ColorChange(h)
  84.     }
  86.     return h
  87. }
  89. // 红色右移
  90. // 节点 h 是红节点，其右儿子和右儿子的左儿子都为黑节点，右移后使得其右儿子或右儿子的右儿子有一个是红色节点
  91. func MoveRedRight(h *LLRBTNode) *LLRBTNode {
  92.     // 应该确保 isRed(h) && !isRed(h.right) && !isRed(h.right.left);
  93.     ColorChange(h)
  95.     // 左儿子有左红链接
  96.     if IsRed(h.Left.Left) {
  97.         // 右旋
  98.         h = RotateRight(h)
  99.         // 变色
  100.         ColorChange(h)
  101.     }
  103.     return h
  104. }
  106. // 颜色变换
  107. func ColorChange(h *LLRBTNode) {
  108.     if h == nil {
  109.         return
  110.     }
  111.     h.Color = !h.Color
  112.     h.Left.Color = !h.Left.Color
  113.     h.Right.Color = !h.Right.Color
  114. }
  116. // 左倾红黑树添加元素
  117. func (tree *LLRBTree) Add(value int64) {
  118.     // 跟节点开始添加元素，因为可能调整，所以需要将返回的节点赋值回根节点
  119.     tree.Root = tree.Root.Add(value)
  120.     // 根节点的链接永远都是黑色的
  121.     tree.Root.Color = BLACK
  122. }
  124. // 往节点添加元素
  125. func (node *LLRBTNode) Add(value int64) *LLRBTNode {
  126.     // 插入的节点为空，将其链接颜色设置为红色，并返回
  127.     if node == nil {
  128.         return &LLRBTNode{
  129.             Value: value,
  130.             Color: RED,
  131.         }
  132.     }
  134.     // 插入的元素重复
  135.     if value == node.Value {
  136.         node.Times = node.Times + 1
  137.     } else if value > node.Value {
  138.         // 插入的元素比节点值大，往右子树插入
  139.         node.Right = node.Right.Add(value)
  140.     } else {
  141.         // 插入的元素比节点值小，往左子树插入
  142.         node.Left = node.Left.Add(value)
  143.     }
  145.     // 辅助变量
  146.     nowNode := node
  148.     // 右链接为红色，那么进行左旋，确保树是左倾的
  149.     // 这里做完操作后就可以结束了，因为插入操作，新插入的右红链接左旋后，nowNode节点不会出现连续两个红左链接，因为它只有一个左红链接
  150.     if IsRed(nowNode.Right) && !IsRed(nowNode.Left) {
  151.         nowNode = RotateLeft(nowNode)
  152.     } else {
  153.         // 连续两个左链接为红色，那么进行右旋
  154.         if IsRed(nowNode.Left) && IsRed(nowNode.Left.Left) {
  155.             nowNode = RotateRight(nowNode)
  156.         }
  158.         // 旋转后，可能左右链接都为红色，需要变色
  159.         if IsRed(nowNode.Left) && IsRed(nowNode.Right) {
  160.             ColorChange(nowNode)
  161.         }
  162.     }
  164.     return nowNode
  165. }
  167. // 找出最小值的节点
  168. func (tree *LLRBTree) FindMinValue() *LLRBTNode {
  169.     if tree.Root == nil {
  170.         // 如果是空树，返回空
  171.         return nil
  172.     }
  174.     return tree.Root.FindMinValue()
  175. }
  177. func (node *LLRBTNode) FindMinValue() *LLRBTNode {
  178.     // 左子树为空，表面已经是最左的节点了，该值就是最小值
  179.     if node.Left == nil {
  180.         return node
  181.     }
  183.     // 一直左子树递归
  184.     return node.Left.FindMinValue()
  185. }
  187. // 找出最大值的节点
  188. func (tree *LLRBTree) FindMaxValue() *LLRBTNode {
  189.     if tree.Root == nil {
  190.         // 如果是空树，返回空
  191.         return nil
  192.     }
  194.     return tree.Root.FindMaxValue()
  195. }
  197. func (node *LLRBTNode) FindMaxValue() *LLRBTNode {
  198.     // 右子树为空，表面已经是最右的节点了，该值就是最大值
  199.     if node.Right == nil {
  200.         return node
  201.     }
  203.     // 一直右子树递归
  204.     return node.Right.FindMaxValue()
  205. }
  207. // 查找指定节点
  208. func (tree *LLRBTree) Find(value int64) *LLRBTNode {
  209.     if tree.Root == nil {
  210.         // 如果是空树，返回空
  211.         return nil
  212.     }
  214.     return tree.Root.Find(value)
  215. }
  217. func (node *LLRBTNode) Find(value int64) *LLRBTNode {
  218.     if value == node.Value {
  219.         // 如果该节点刚刚等于该值，那么返回该节点
  220.         return node
  221.     } else if value < node.Value {
  222.         // 如果查找的值小于节点值，从节点的左子树开始找
  223.         if node.Left == nil {
  224.             // 左子树为空，表示找不到该值了，返回nil
  225.             return nil
  226.         }
  227.         return node.Left.Find(value)
  228.     } else {
  229.         // 如果查找的值大于节点值，从节点的右子树开始找
  230.         if node.Right == nil {
  231.             // 右子树为空，表示找不到该值了，返回nil
  232.             return nil
  233.         }
  234.         return node.Right.Find(value)
  235.     }
  236. }
  238. // 中序遍历
  239. func (tree *LLRBTree) MidOrder() {
  240.     tree.Root.MidOrder()
  241. }
  243. func (node *LLRBTNode) MidOrder() {
  244.     if node == nil {
  245.         return
  246.     }
  248.     // 先打印左子树
  249.     node.Left.MidOrder()
  251.     // 按照次数打印根节点
  252.     for i := 0; i <= int(node.Times); i++ {
  253.         fmt.Println(node.Value)
  254.     }
  256.     // 打印右子树
  257.     node.Right.MidOrder()
  258. }
  260. // 修复左倾红黑树特征
  261. func (node *LLRBTNode) FixUp() *LLRBTNode {
  262.     // 辅助变量
  263.     nowNode := node
  265.     // 红链接在右边，左旋恢复，让红链接只出现在左边
  266.     if IsRed(nowNode.Right) {
  267.         nowNode = RotateLeft(nowNode)
  268.     }
  270.     // 连续两个左链接为红色，那么进行右旋
  271.     if IsRed(nowNode.Left) && IsRed(nowNode.Left.Left) {
  272.         nowNode = RotateRight(nowNode)
  273.     }
  275.     // 旋转后，可能左右链接都为红色，需要变色
  276.     if IsRed(nowNode.Left) && IsRed(nowNode.Right) {
  277.         ColorChange(nowNode)
  278.     }
  280.     return nowNode
  281. }
  283. // 对该节点所在的子树删除最小元素
  284. func (node *LLRBTNode) DeleteMin() *LLRBTNode {
  285.     // 辅助变量
  286.     nowNode := node
  288.     // 没有左子树，那么删除它自己
  289.     if nowNode.Left == nil {
  290.         return nil
  291.     }
  293.     // 判断是否需要红色左移，因为最小元素在左子树中
  294.     if !IsRed(nowNode.Left) && !IsRed(nowNode.Left.Left) {
  295.         nowNode = MoveRedLeft(nowNode)
  296.     }
  298.     // 递归从左子树删除
  299.     nowNode.Left = nowNode.Left.DeleteMin()
  301.     // 修复左倾红黑树特征
  302.     return nowNode.FixUp()
  303. }
  305. // 左倾红黑树删除元素
  306. func (tree *LLRBTree) Delete(value int64) {
  307.     // 当找不到值时直接返回
  308.     if tree.Find(value) == nil {
  309.         return
  310.     }
  312.     if !IsRed(tree.Root.Left) && !IsRed(tree.Root.Right) {
  313.         // 左右子树都是黑节点，那么先将根节点变为红节点，方便后面的红色左移或右移
  314.         tree.Root.Color = RED
  315.     }
  317.     tree.Root = tree.Root.Delete(value)
  319.     // 最后，如果根节点非空，永远都要为黑节点，赋值黑色
  320.     if tree.Root != nil {
  321.         tree.Root.Color = BLACK
  322.     }
  323. }
  325. // 对该节点所在的子树删除元素
  326. func (node *LLRBTNode) Delete(value int64) *LLRBTNode {
  327.     // 辅助变量
  328.     nowNode := node
  329.     // 删除的元素比子树根节点小，需要从左子树删除
  330.     if value < nowNode.Value {
  331.         // 因为从左子树删除，所以要判断是否需要红色左移
  332.         if !IsRed(nowNode.Left) && !IsRed(nowNode.Left.Left) {
  333.             // 左儿子和左儿子的左儿子都不是红色节点，那么没法递归下去，先红色左移
  334.             nowNode = MoveRedLeft(nowNode)
  335.         }
  337.         // 现在可以从左子树中删除了
  338.         nowNode.Left = nowNode.Left.Delete(value)
  339.     } else {
  340.         // 删除的元素等于或大于树根节点
  342.         // 左节点为红色，那么需要右旋，方便后面可以红色右移
  343.         if IsRed(nowNode.Left) {
  344.             nowNode = RotateRight(nowNode)
  345.         }
  347.         // 值相等，且没有右孩子节点，那么该节点一定是要被删除的叶子节点，直接删除
  348.         // 为什么呢，反证，它没有右儿子，但有左儿子，因为左倾红黑树的特征，那么左儿子一定是红色，但是前面的语句已经把红色左儿子右旋到右边，不应该出现右儿子为空。
  349.         if value == nowNode.Value && nowNode.Right == nil {
  350.             return nil
  351.         }
  353.         // 因为从右子树删除，所以要判断是否需要红色右移
  354.         if !IsRed(nowNode.Right) && !IsRed(nowNode.Right.Left) {
  355.             // 右儿子和右儿子的左儿子都不是红色节点，那么没法递归下去，先红色右移
  356.             nowNode = MoveRedRight(nowNode)
  357.         }
  359.         // 删除的节点找到了，它是中间节点，需要用最小后驱节点来替换它，然后删除最小后驱节点
  360.         if value == nowNode.Value {
  361.             minNode := nowNode.Right.FindMinValue()
  362.             nowNode.Value = minNode.Value
  363.             nowNode.Times = minNode.Times
  365.             // 删除其最小后驱节点
  366.             nowNode.Right = nowNode.Right.DeleteMin()
  367.         } else {
  368.             // 删除的元素比子树根节点大，需要从右子树删除
  369.             nowNode.Right = nowNode.Right.Delete(value)
  370.         }
  371.     }
  373.     // 最后，删除叶子节点后，需要恢复左倾红黑树特征
  374.     return nowNode.FixUp()
  375. }
  377. // 验证是不是棵左倾红黑树
  378. func (tree *LLRBTree) IsLLRBTree() bool {
  379.     if tree == nil || tree.Root == nil {
  380.         return true
  381.     }
  383.     // 判断树是否是一棵二分查找树
  384.     if !tree.Root.IsBST() {
  385.         return false
  386.     }
  388.     // 判断树是否遵循2-3树，也就是红链接只能在左边，不能连续有两个红链接
  389.     if !tree.Root.Is23() {
  390.         return false
  391.     }
  393.     // 判断树是否平衡，也就是任意一个节点到叶子节点，经过的黑色链接数量相同
  394.     // 先计算根节点到最左边叶子节点的黑链接数量
  395.     blackNum := 0
  396.     x := tree.Root
  397.     for x != nil {
  398.         if !IsRed(x) { // 是黑色链接
  399.             blackNum = blackNum + 1
  400.         }
  401.         x = x.Left
  402.     }
  404.     if !tree.Root.IsBalanced(blackNum) {
  405.         return false
  406.     }
  407.     return true
  408. }
  410. // 节点所在的子树是否是一棵二分查找树
  411. func (node *LLRBTNode) IsBST() bool {
  412.     if node == nil {
  413.         return true
  414.     }
  416.     // 左子树非空，那么根节点必须大于左儿子节点
  417.     if node.Left != nil {
  418.         if node.Value > node.Left.Value {
  419.         } else {
  420.             fmt.Printf("father:%#v,lchild:%#v,rchild:%#v\n", node, node.Left, node.Right)
  421.             return false
  422.         }
  423.     }
  425.     // 右子树非空，那么根节点必须小于右儿子节点
  426.     if node.Right != nil {
  427.         if node.Value < node.Right.Value {
  428.         } else {
  429.             fmt.Printf("father:%#v,lchild:%#v,rchild:%#v\n", node, node.Left, node.Right)
  430.             return false
  431.         }
  432.     }
  434.     // 左子树也要判断是否是平衡查找树
  435.     if !node.Left.IsBST() {
  436.         return false
  437.     }
  439.     // 右子树也要判断是否是平衡查找树
  440.     if !node.Right.IsBST() {
  441.         return false
  442.     }
  444.     return true
  445. }
  447. // 节点所在的子树是否遵循2-3树
  448. func (node *LLRBTNode) Is23() bool {
  449.     if node == nil {
  450.         return true
  451.     }
  453.     // 不允许右倾红链接
  454.     if IsRed(node.Right) {
  455.         fmt.Printf("father:%#v,rchild:%#v\n", node, node.Right)
  456.         return false
  457.     }
  459.     // 不允许连续两个左红链接
  460.     if IsRed(node) && IsRed(node.Left) {
  461.         fmt.Printf("father:%#v,lchild:%#v\n", node, node.Left)
  462.         return false
  463.     }
  465.     // 左子树也要判断是否遵循2-3树
  466.     if !node.Left.Is23() {
  467.         return false
  468.     }
  470.     // 右子树也要判断是否是遵循2-3树
  471.     if !node.Right.Is23() {
  472.         return false
  473.     }
  475.     return true
  476. }
  478. // 节点所在的子树是否平衡，是否有 blackNum 个黑链接
  479. func (node *LLRBTNode) IsBalanced(blackNum int) bool {
  480.     if node == nil {
  481.         return blackNum == 0
  482.     }
  484.     if !IsRed(node) {
  485.         blackNum = blackNum - 1
  486.     }
  488.     if !node.Left.IsBalanced(blackNum) {
  489.         fmt.Println("node.Left to leaf black link is not ", blackNum)
  490.         return false
  491.     }
  493.     if !node.Right.IsBalanced(blackNum) {
  494.         fmt.Println("node.Right to leaf black link is not ", blackNum)
  495.         return false
  496.     }
  498.     return true
  499. }
  501. func main() {
  502.     tree := NewLLRBTree()
  503.     values := []int64{2, 3, 7, 10, 10, 10, 10, 23, 9, 102, 109, 111, 112, 113}
  504.     for _, v := range values {
  505.         tree.Add(v)
  506.     }
  508.     // 找到最大值或最小值的节点
  509.     fmt.Println("find min value:", tree.FindMinValue())
  510.     fmt.Println("find max value:", tree.FindMaxValue())
  512.     // 查找不存在的99
  513.     node := tree.Find(99)
  514.     if node != nil {
  515.         fmt.Println("find it 99!")
  516.     } else {
  517.         fmt.Println("not find it 99!")
  518.     }
  520.     // 查找存在的9
  521.     node = tree.Find(9)
  522.     if node != nil {
  523.         fmt.Println("find it 9!")
  524.     } else {
  525.         fmt.Println("not find it 9!")
  526.     }
  528.     tree.MidOrder()
  530.     // 删除存在的9后，再查找9
  531.     tree.Delete(9)
  532.     tree.Delete(10)
  533.     tree.Delete(2)
  534.     tree.Delete(3)
  535.     tree.Add(4)
  536.     tree.Add(3)
  537.     tree.Add(10)
  538.     tree.Delete(111)
  539.     node = tree.Find(9)
  540.     if node != nil {
  541.         fmt.Println("find it 9!")
  542.     } else {
  543.         fmt.Println("not find it 9!")
  544.     }
  546.     if tree.IsLLRBTree() {
  547.         fmt.Println("is a llrb tree")
  548.     } else {
  549.         fmt.Println("is not llrb tree")
  550.     }
  551. }

运行：

  1. find min value: &{2 0 <nil> <nil> false}
  2. find max value: &{113 0 0xc0000941e0 <nil> false}
  3. not find it 99!
  4. find it 9!
  5. 2
  6. 3
  7. 7
  8. 9
  9. 10
  10. 10
  11. 10
  12. 10
  13. 23
  14. 102
  15. 109
  16. 111
  17. 112
  18. 113
  19. not find it 9!
  20. is a llrb tree

PS：我们的程序是递归程序，如果改写为非递归形式，效率和性能会更好，在此就不实现了，理解左倾红黑树添加和删除的总体思路即可。

三、应用场景

红黑树可以用来作为字典 Map 的基础数据结构，可以存储键值对，然后通过一个键，可以快速找到键对应的值，相比哈希表查找，不需要占用额外的空间。我们以上的代码实现只有 value，没有 key:value，可以简单改造实现字典。

Java 语言基础类库中的 HashMap，TreeSet，TreeMap 都有使用到，C++ 语言的 STL 标准模板库中，map 和 set 类也有使用到。很多中间件也有使用到，比如 Nginx，但 Golang 语言标准库并没有它。

最后，上述应用场景使用的红黑树都是普通红黑树，并不是本文所介绍的左倾红黑树。

左倾红黑树作为红黑树的一个变种，只是被设计为更容易理解而已，变种只能是变种，工程上使用得更多的还是普通红黑树，所以我们仍然需要学习普通的红黑树，请看下一章节。