Swift 数据结构 - 二叉搜索树(Binary Search Tree, BST)

二叉搜索树的定义

左子树节点的值都小于根节点的值，右子树节点的值都大于根节点的值

二叉搜索树的性质

若任意节点的左子树不空，则左子树所有节点的值小于根节点的值

若任意节点的右子树不空，则左子树所有节点的值大于根节点的值

任意节点的左右子树也为二叉搜索树

没有键值相等的节点

代码

public class BinarySearchTree<T: Comparable> {
    private(set) public var value: T
    private(set) public var parent: BinarySearchTree?
    private(set) public var left: BinarySearchTree?
    private(set) public var right: BinarySearchTree?
    
    public init(value: T) {
        self.value = value
    }
    /// 是否是根节点
    public var isRoot: Bool {
        return parent == nil
    }
    /// 是否是叶节点
    public var isLeaf: Bool {
        return left == nil && right == nil
    }
    /// 是否是左子节点
    public var isLeftChild: Bool {
        return parent?.left === self
    }
    /// 是否是右子节点
    public var isRightChild: Bool {
        return parent?.right === self
    }
    /// 是否有左子节点
    public var hasLeftChild: Bool {
        return left != nil
    }
    /// 是否有右子节点
    public var hasRightChild: Bool {
        return right != nil
    }
    /// 是否有子节点
    public var hasAnyChild: Bool {
        return hasLeftChild || hasRightChild
    }
    /// 是否左右两个子节点都有
    public var hasBothChildren: Bool {
        return hasLeftChild && hasRightChild
    }
    /// 当前节点包括子树中的所有节点总数
    public var count: Int {
        return (left?.count ?? 0) + 1 + (right?.count ?? 0)
    }
}

此类仅描述单个节点而不是整个树。它是泛型类型，因此节点可以存储任何类型的数据。它还包含了 left 和 right 子节点以及一个 parent节点的引用。

基本操作

插入新节点

执行插入时，我们首先将新值与根节点进行比较。如果新值较小，我们采取左分支; 如果更大，我们采取右分支。我们沿着这条路向下走，直到找到一个我们可以插入新值的空位。

  public func insert(value: T) {
    if value < self.value {
      if let left = left {
        left.insert(value: value)
      } else {
        left = BinarySearchTree(value: value)
        left?.parent = self
      }
    } else {
      if let right = right {
        right.insert(value: value)
      } else {
        right = BinarySearchTree(value: value)
        right?.parent = self
      }
    }
  }

为方便起见，让我们添加一个以数组的方式初始化的方法，这个方法为数组中所有元素调用insert()：

  public convenience init(array: [T]) {
    precondition(array.count > 0)
    self.init(value: array.first!)
    for v in array.dropFirst() {
      insert(value: v)
    }
  }

现在可以简单的使用：

let tree = BinarySearchTree<Int>(array: [7, 2, 5, 10, 9, 1])

搜索树

要在树中查找值，我们执行与插入相同的步骤：

如果该值小于当前节点，则选择左分支。
如果该值大于当前节点，则选择右分支。
如果该值等于当前节点，我们就找到了它！

像大多数树操作一样，这是递归执行的，直到找到我们正在查找的内容或查完要查看的所有节点。

  public func search(value: T) -> BinarySearchTree? {
    if value < self.value {
      return left?.search(value)
    } else if value > self.value {
      return right?.search(value)
    } else {
      return self  // found it!
    }
  }

测试搜索：

tree.search(value: 5)
tree.search(value: 2)
tree.search(value: 7)
tree.search(value: 6)   // nil

遍历树

有时您需要查看所有节点而不是仅查看一个节点。

遍历二叉树有三种方法：

中序（或深度优先，In-order/depth-first）：首先查看节点的左子节点，然后查看节点本身，最后查看其右子节点。
前序（Pre-order）：首先查看节点本身，然后查看其左右子节点。
后序（Post-order）：首先查看左右子节点并最后处理节点本身。

遍历树的过程也是递归的，如果按 中序遍历 二叉搜索树，它会查看所有节点，并且结果是有序的。

三种不同的方法，如下：

//中序遍历
  public func traverseInOrder(process: (T) -> Void) {
    left?.traverseInOrder(process: process)
    process(value)
    right?.traverseInOrder(process: process)
  }
//前序遍历
  public func traversePreOrder(process: (T) -> Void) {
    process(value)
    left?.traversePreOrder(process: process)
    right?.traversePreOrder(process: process)
  }
//后序遍历
  public func traversePostOrder(process: (T) -> Void) {
    left?.traversePostOrder(process: process)
    right?.traversePostOrder(process: process)
    process(value)
  }

要打印出从低到高排序的树的所有值，您可以编写：

tree.traverseInOrder { value in print(value) }

还可以在树中添加map()和filter()方法。例如，这是map按中序遍历树的实现：

  public func map(formula: (T) -> T) -> [T] {
    var a = [T]()
    if let left = left { a += left.map(formula: formula) }
    a.append(formula(value))
    if let right = right { a += right.map(formula: formula) }
    return a
  }

一个非常简单的如何使用map()的例子：

  public func toArray() -> [T] {
    return map { $0 }
  }

这会将树的内容重新转换为已排序的数组：

tree.toArray()       // [1, 2, 5, 7, 9, 10]

调试输出

extension BinarySearchTree: CustomStringConvertible {
  public var description: String {
    var s = ""
    if let left = left {
      s += "(\(left.description)) <- "
    }
    s += "\(value)"
    if let right = right {
      s += " -> (\(right.description))"
    }
    return s
  }
}

当你执行print(tree)时，你应该得到：

((1) <- 2 -> (5)) <- 7 -> ((9) <- 10)

image.png

删除节点

删除节点很容易。不过删除节点后，需要将节点替换为左侧最大的子节点或右侧的最小子节点。这样，树在删除节点后仍然排序

//移除一个节点
  @discardableResult public func remove() -> BinarySearchTree? {
    let replacement: BinarySearchTree?

    // 当前节点的替换可以是左侧最大的替换  或者
    // 右边最小的那个
    if let right = right {
      replacement = right.minimum()
    } else if let left = left {
      replacement = left.maximum()
    } else {
      replacement = nil
    }

    replacement?.remove()

    // 将替换放置在当前节点的位置
    replacement?.right = right
    replacement?.left = left
    right?.parent = replacement
    left?.parent = replacement
    reconnectParentTo(node:replacement)

    // 当前节点不再是树的一部分，因此请清理它。
    parent = nil
    left = nil
    right = nil

    return replacement
  }
//重新设置一个节点
  private func reconnectParentTo(node: BinarySearchTree?) {
    if let parent = parent {
      if isLeftChild {
        parent.left = node
      } else {
        parent.right = node
      }
    }
    node?.parent = parent
  }

返回节点最小值和最大值的函数：

  public func minimum() -> BinarySearchTree {
    var node = self
    while let next = node.left {
      node = next
    }
    return node
  }

  public func maximum() -> BinarySearchTree {
    var node = self
    while let next = node.right {
      node = next
    }
    return node
  }

深度和高度

回想一下节点的高度是到最低叶节点的距离。我们可以用以下函数来计算：

  public func height() -> Int {
    if isLeaf {
      return 0
    } else {
      return 1 + max(left?.height() ?? 0, right?.height() ?? 0)
    }
  }

计算节点的深度，即到根节点的距离。

  public func depth() -> Int {
    var node = self
    var edges = 0
    while let parent = node.parent {
      node = parent
      edges += 1
    }
    return edges
  }

它沿着 parent 指针向上逐步穿过树，直到我们到达根节点（即parent为nil）。这需要 O(h) 时间。

检查树是否是有效的二叉搜索树：

  public func isBST(minValue minValue: T, maxValue: T) -> Bool {
    if value < minValue || value > maxValue { 
        return false
     }
    let leftBST = left?.isBST(minValue: minValue, maxValue: value) ?? true
    let rightBST = right?.isBST(minValue: value, maxValue: maxValue) ?? true
    return leftBST && rightBST
  }

使用如下：

if let node1 = tree.search(1) {
  tree.isBST(minValue: Int.min, maxValue: Int.max)  // true
  node1.insert(100)                                 // EVIL!!!
  tree.search(100)                                  // nil
  tree.isBST(minValue: Int.min, maxValue: Int.max)  // false
}

在非根节点上调用insert()将二分搜索树变为无效树

根节点的值为7，因此值为100的节点必须位于树的右侧分支中。但是，您不是插入根，而是插入树左侧分支中的叶节点。所以新的100节点在树中的错误位置！

结果，tree.search(100)给出 nil。

转载文章

二叉搜索树(Binary Search Tree, BST)