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

最新推荐文章于 2022-04-22 11:23:37 发布

原创最新推荐文章于 2022-04-22 11:23:37 发布 · 466 阅读

0 ·

CC 4.0 BY-SA版权

算法笔记专栏收录该内容

9 篇文章

订阅专栏

本文详细介绍了二叉查找树（BST）的基本概念及其变种，包括红黑树和AVL树，并探讨了BST的各种操作，如查找、插入、删除等的时间复杂度。此外，还介绍了如何通过中序遍历来获取有序关键字。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

二叉查找树（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 root

def 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插入的位置。