1. 定义
设 x 是BST中的一个节点,
若 y 是 x 的左子树中的任一节点, 则 y.data x.data ;
若 y 是 x 的右子树中的任一节点, 则 y.data x.data .
由定义可知, 对BST进行中序遍历可得到一个有序数列.
首先定义BST的节点: 除左右孩子外, 还包含一个指向父亲节点的指针.
class BSTNode(object):
def __init__(self, data=None, left=None, right=None, p=None):
self.data = data
self.left = left
self.right = right
self.p = p
2. 插入
- 从根节点开始逐层比较, 找到合适的叶节点 pre 作为待插节点 x 的父亲节点.
- 特殊情况: 空树. 此时将 x 作为根节点即可.
class BinarySearchTree(AbstractCollection):
def __init__(self, source_collection=None):
self._root = None
super().__init__(source_collection)
# 1. 插入
def add(self, data):
x = BSTNode(data)
self._insert(x)
def _insert(self, x):
pre, probe = None, self._root
while probe != None:
pre = probe
if x.data < probe.data:
probe = probe.left
else:
probe = probe.right
x.p = pre
if pre is None:
self._root = x
elif x.data < pre.data:
pre.left = x
else:
pre.right = x
self._size += 1
3. 遍历
- 深度遍历(前中后序): 递归实现.
- 广度遍历(层级): 借助辅助队列, 实现逐层(从左至右)遍历. 关于链式队列和栈的实现, 参考此文.
- iter实现为前序遍历的非递归版本.
# 2. 遍历
def inorder_tree_walk(self, x=False):
if x is False:
x = self._root
if x is not None:
yield from self.inorder_tree_walk(x.left)
yield x.data
yield from self.inorder_tree_walk(x.right)
def preorder_tree_walk(self, x=False):
if x is False:
x = self._root
if x is not None:
yield x.data
yield from self.inorder_tree_walk(x.left)
yield from self.inorder_tree_walk(x.right)
def postorder_tree_walk(self, x=False):
if x is False:
x = self._root
if x is not None:
yield from self.inorder_tree_walk(x.left)
yield from self.inorder_tree_walk(x.right)
yield x.data
def levelorder_tree_walk(self):
if self.is_empty():
return
queue = LinkedQueue()
queue.add(self._root)
while not queue.is_empty():
node = queue.pop()
yield node.data
if node.left != None:
queue.add(node.left)
if node.right != None:
queue.add(node.right)
def __iter__(self):
if self.is_empty():
return
stack = LinkedStack()
stack.push(self._root)
while not stack.is_empty():
node = stack.pop()
yield node.data
if node.right != None:
stack.push(node.right)
if node.left != None:
stack.push(node.left)
4. 查找
- 最值: 最小值位于最左边节点, 最大值位于最右边节点.
- 后继: 若有右子树, 则返回右子树中的最小节点; 否则, 迭代的寻找某个祖先节点, 直至满足当前节点是其父节点的左孩子, 返回父节点.
- 前驱: 与寻找后继节点的算法完全对称.
# 3. 查找: in, max, min, successor, predecessor
def __contains__(self, data):
return self._find(data) != None
def max_data(self):
return self._max(self._root).data
def min_data(self):
return self._min(self._root).data
def _min(self, node):
if self.is_empty():
raise KeyError('The tree is empty.')
while node.left != None:
node = node.left
return node
def _max(self, node):
if self.is_empty():
raise KeyError('The tree is empty.')
while node.right != None:
node = node.right
return node
def _find(self, data):
probe = self._root
while probe != None and probe.data != data:
if data < probe.data:
probe = probe.left
else:
probe = probe.right
return probe
def _successor(self, x):
"""找某个节点的后继: 若有右子树, 则返回其右子树的最小节点; 否则, 迭代找其某个祖先节点, 直至满足当前节点是其父的left, 返回其父"""
if x.right != None:
return self._min(x.right)
else:
y = x.p
while y != None and x != y.left:
x = y
y = y.p
return y
def _predecessor(self, x):
"""找某个节点的前驱: _successor的对称操作"""
if x.left != None:
return self._max(x.left)
else:
y = x.p
while y != None and x != y.right:
x = y
y = y.p
return y
5. 删除
Case 1: x 没有孩子节点, 直接删除.
Case 2: x 仅有一个孩子(子树), 将该子树上移替换掉 x .
-
Case 3: x 有两个孩子, 在子树 x.right 中找到 x 的后继节点 y (显然 y 没有左孩子), 让 y 占据 x 的位置. 此时可能出现两种情况:
(1) y 是 x 的右孩子. 此时直接将 y 上移替换掉 x .
(2) y 非 x 的右孩子. 此时取出 y , 将 y 的右孩子上移至 y 的位置, 然后取出子树 x.right , 并让其成为 y 的右孩子, 演变成情形(1), 重复(1)的操作. 如图所示:
(1) y.p == x
(2) y.p != x 子树替换子程序_tranplant(u, v): 用子树 v 替换子树 u .
# 4. 删除
def remove(self, data):
x = self._find(data)
if x is None:
raise KeyError("Data is not in the tree.")
if x.left is None:
self._transplant(x, x.right)
elif x.right is None:
self._transplant(x, x.left)
else:
y = self._successor(x)
if y.p != x: # (2)
self._transplant(y, y.right)
y.right = x.right
y.right.p = y
self._transplant(x, y)
y.left = x.left
y.left.p = y
def _transplant(self, u, v):
if u.p is None:
self._root = v
elif u is u.p.left:
u.p.left = v
else:
u.p.right = v
if v != None:
v.p = u.p
6. 时间复杂度
遍历的时间复杂度是 .
插入删除查找的时间复杂度都是 .
建树的时间复杂度是 .
其中 n 是节点总数, h是树的高度, 显然,
所以普通的二叉搜索树并不能保证 logn 级的查找速度.
另外, 快速排序的过程可以想象成构建一棵二叉搜索树, 故复杂度等价.
