《算法导论》二叉查找树的实现

二叉查找树（Binary Search Tree，BST）也是一种支持多种动态集合操作（查找、最大最小值、插入、删除）的数据结构，基本操作的时间和树的高度成正比。

基于BST的变型如红黑树、平衡AVL树，可以保证各个基本操作的最坏情况下依然能保证好性能。

根据定义，二叉查找树的根节点值大于或等于其左子树的根节点值，小于或等于右子树的根节点值。因此，中序遍历BST能得到升序排好序的所有关键字。（参照排序的约定，树节点的取值也叫关键字key）

BST所有操作代码的实现在Github/Algorithm/Binary Tree/BST

中序遍历BST

遍历一棵n个节点的BST的时间代价为Theta(n)，因此可以在O(n)内按序输出n个节点的树的所有关键字。

最小堆则不能在O(n)时间内完成，因为两棵子树的根节点相对大小不确定，无法保证按大小顺序输出。建堆时间代价是O(n)，如果可以利用堆的性质在O(n)时间内按顺序输出关键字，那么就可以得到O(n)的排序算法。然而基于比较的排序算法有下界Omega(nlogn)时间复杂度。（《算法导论》习题12.1-2）

递归实现

def inorder_tree(root):    if root != None:        inorder_tree(root.left)        print root.val        inorder_tree(root.right)    return

可以借助栈给出中序遍历的非递归实现（《算法导论》习题12.1-3）

def inorder_tree(root):    result = []    stack = []    while root != None or len(stack):        if root != None:            stack.append(root)            root = root.left        else:            root = stack.pop() # after left subtree            result.append(root.val)            root = root.right    return result

---

查找操作

BST的查找操作类似于二分查找，时间代价为O(h)，h为树的高度。这里给出递归和迭代的实现：

def search_1(root, key):    if root == None or key == root.val:        return root    elif key < root.val:        return search_1(root.left, key)    else:        return search_1(root.right, key)def search_2(root, key):    while root and root.val != key:        if key < root.val:            root = root.left        else:            root = root.right    return root

返回BST中最大值和最小值的节点：

def minimum(root):    while root.left:        root = root.left    return rootdef maximum(root):    while root.right:        root = root.right    return root

---

前驱节点和后继节点

而有时候需要求BST特定节点的前一个节点（前驱）或后一个节点（后继），可以作为在插入或删除BST中节点的子操作。

在BST中，比当前节点的关键值小的节点即前驱结点（predecessor），不小于当前节点关键值的节点即后继节点（successor）。

def successor(node):    if node.right:        return minimum(node.right)    p = node.parent    while p and node == p.right:        node = p        p = node.parent    return p

例如求后继节点的代码：
- 如果当前结点有右子节点，它的后继必然是右子节点为根的子树的最左下角的节点（即该子树的最小值节点）
- 否则，就在上一级节点（父节点）继续搜索，直到找到某个节点是它的父节点的左孩子，返回该节点的父节点。（右上方第一个，node == p.left）

def predecessor(node):    if node.left:        return maximum(node.left)    p = node.parent    while p and node == p.left:        node = p        p = node.parent    return p   

而求前驱结点的过程和后继的相反：
- 如果当前节点有左子节点，则它的前驱必然是左子树的最右下角的节点
- 否则，就在上一级节点（父节点）继续搜索，直到找到某个节点是它父节点的右孩子，返回该节点的父节点。（左上方第一个，node == p.right）

定理：对于高度为h的BST，动态集合操作查找、最大、最小值、前驱、后继的时间复杂度均为O(h)。

《算法导论》相关习题的证明

• 12.2-5：如果BST某个节点有两个子节点，则其后继没有左节点，前驱没有右节点。
• 12.2-6：在关键字均不相同的BST中，如果某个节点的右子树为空，它又有后继；那么后继是当前节点的最低祖先，且后继的左孩子也是当前节点的祖先。
• 12.2-7：中序遍历BST的另一种实现：用minimum找到最小元素，然后调用n-1次successor找后继，时间复杂度Theta(n)

---

插入&删除操作

对BST插入或者删除节点，一般都会引起整个BST的结构变化，需要调整结构以维持BST的性质（和最大/小堆需要维护类似）。BST插入和删除节点的操作也是O(h)。

插入

def insert(root, key):    node = root    new_node = TreeNode(key)    while node:        p = node        if new_node.val < node.val:            node = node.left        else:            node = node.right    new_node.parent = p    if p == None:        root = new_node    elif new_node.val < p.val:        p.left = new_node    else:        p.right = new_node

主要步骤：从根节点开始，沿着树下降，指针node跟踪当前路径，p指针记录node的父节点，直到node到达叶节点位置，这个位置则是新加入new_node插入的位置。

---

相关题目

• Leetcode 96，Unique Binary Search Trees，https://leetcode.com/problems/unique-binary-search-trees
• Leetcode 95，Unique Binary Search Trees II，https://leetcode.com/problems/unique-binary-search-trees-ii
• Leetcode 98，Validate Binary Search Trees，https://leetcode.com/problems/validate-binary-search-tree
• Leetcode 99，Recover Binary Search Tree，https://leetcode.com/problems/recover-binary-search-tree
• Leetcode 108，
  Convert Sorted Array to Binary Search Tree，https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree
• Leetcode 109，Convert Sorted List to Binary Search Tree，https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree
• Leetcode 173，
  Binary Search Tree Iterator，https://leetcode.com/problems/binary-search-tree-iterator

Reference

• 《算法导论》第12章