【数据结构】二叉排序树BST
二叉排序树
二叉排序树(Binary Sort Tree)也叫二叉搜索树(Binary Search Tree)
二叉排序树本质上还是一个二叉树，只不过在其上定义了一些规则：一个结点的左子树中所有的结点不大于该结点的值，而其右子树中的所有结点不小于该结点的值。由此规则可得BST中序遍历是有序的。
BST中定义的操作有：
minNode：某个子树中的关键字最小的结点
maxNode：某个子树中的关键字最大的结点
search：搜索某个关键字
predecessor：某个节点的前驱
successor：某个节点的后继
insert：在BST中插入一个元素
delete：在BST中删除一个元素
研究二叉排序树最主要的就是上述操作在BST中的时间复杂度为O(h)，h为树高。
相关算法
1.某棵子树中关键字最小的结点由BST的性质，沿着该结点的左分支往下走到最后一个结点
public BinaryTreeNode minNode(BinaryTreeNode node) {
while (node.lchild != null) {
node = node.lchild;
}
return node;
}2.某棵子树中关键字最大的结点
由BST的性质，沿着该结点的右分支往下走到最后一个结点
public BinaryTreeNode maxNode(BinaryTreeNode node) {
while (node.rchild != null) {
node = node.rchild;
}
return node;
}3.搜索
BST中的搜索类似于折半查找，因为BST的中序遍历就是一个有序数组。
public BinaryTreeNode search(BinaryTreeNode root, int e) {
if (e == root.data || root == null)
return root;
if (e < root.data)
return search(root.lchild, e);
else
return search(root.rchild, e);
}4.某个结点的前驱
如有左子树，那么返回左子树中的最小结点即可。
无左子树，沿着父节点往上走，知道到达这样的结点：其父节点为空(到达根)或者作为某个结点的右子树。
public BinaryTreeNode predecessor(BinaryTreeNode node) {
if (node.lchild != null)
return maxNode(node.lchild);
BinaryTreeNode parent = node.parent;
while (parent != null && parent.lchild == node) {
node = parent;
parent = node.parent;
}
return parent;
} 5.某个结点的后继和前驱的算法类似
具体思路如下
6.在BST中插入一个元素
和查找类似，只是要注意保存好父结点，x从根开始下移，直到x为空，而此时y就是他的父结点。
具体思路如下
具体的实现代码为
public void insert(BinaryTreeNode insertNode) { // O(lgn)
BinaryTreeNode p = root, parent = null;
while (p != null) {
parent = p; // 注意位置
if (insertNode.data < p.data)
p = p.lchild;
else
p = p.rchild;
} // 出循环时，p为null，parent为要插入在该节点下面
insertNode.parent = parent;
if (root == null) {
root = insertNode;
} else if (insertNode.data < parent.data) {
// 将节点插入到parent的左边
parent.lchild = insertNode;
} else {
parent.rchild = insertNode;
}
}插入结点的递归版本
这里我将跳出递归的条件设置为root.lchild/rchild == null，好处就是直接在root后面添加孩子就行了，不用再额外保存父亲结点。
public void insertRecur(BinaryTreeNode root, BinaryTreeNode insertNode) {
// 递归终止条件
if (this.root == null) {
this.root = insertNode;
return;
} else if (insertNode.data < root.data && root.lchild == null) {
root.lchild = insertNode;
insertNode.parent = root;
return;
} else if (insertNode.data >= root.data && root.rchild == null) {
root.rchild = insertNode;
insertNode.parent = root;
return;
}
// 递归的往左右孩子插入
if (insertNode.data < root.data && root.lchild != null)
insertRecur(root.lchild,insertNode);
if (insertNode.data >= root.data && root.rchild != null) {
insertRecur(root.rchild,insertNode);
}
}同时，通过插入方法也可以创建BST。只需循环的往里面插入节点即可。
7.在BST中删除一个元素
1.删除叶子结点----->仅需调整其父结点的指针
2.只有左子树或者右子树
2.1 只有左孩子：用它的左子树“代替”它。
2.2 只有右孩子：用右子树“代替”它。
3.既有左孩子又有右孩子：用它的左或右子树代替它，同时将它的右子树放在它的前驱的右子树位置。
具体情况如下图
注意上面提到的“代替”，代替并不简单的是node = node.lchild这样的一句赋值，实际上要包含以下操作：
1.如果该结点是它父结点的左孩子，那么，将他的父结点的左孩子赋值为另一个结点
2.如果该结点是它父结点的右孩子，那么，将他的父结点的右孩子赋值为另一个结点
3.最后将用来代替的那个结点的父亲设置为被代替节点的父亲
此外还要注意被替换结点没有父亲节点的情况，也就是删除根。
下面是我最开始写出来的代码，其实看起来非常的混乱
public void deleted(BinaryTreeNode node) {
if (node.lchild == null) { // 左子树为空，只需要移植右子树
// -------1.用该结点的右子树代替它-------
// node = node.rchild;
if (node.parent == null) {
root = node.rchild;
} else if (node == node.parent.lchild) {
node.parent.lchild = node.rchild;
} else {
node.parent.rchild = node.rchild;
}
if (node.rchild != null)
node.rchild.parent = node.parent;
} else if (node.rchild == null) {
// -------2.用该结点的左子树代替它-------
// node = node.lchild;
if (node.parent == null) {
root = node.lchild;
} else if (node == node.parent.lchild) {
node.parent.lchild = node.lchild;
} else {
node.parent.rchild = node.lchild;
}
if (node.lchild != null)
node.lchild.parent = node.parent;
} else {
BinaryTreeNode predecessorOfnode = predecessor(node);
// -------3.用该结点的右子树代替它-------
if (node.parent == null) {
root = node.lchild;
} else if (node.parent.lchild == node) {
node.parent.lchild = node.lchild;
} else if (node.parent.rchild == node) {
node.parent.rchild = node.lchild;
}
node.lchild.parent = node.parent;
node.rchild.parent = predecessorOfnode;
// -------4.将右子树赋值给它的前驱-------
predecessorOfnode.rchild = node.rchild;
node.rchild.parent = predecessorOfnode;
}
}上面的代码存在大量的重复，将其抽出来一个替换的方法// 用node2来替代node1
private void replace(BinaryTreeNode node1, BinaryTreeNode node2){
// node2可以为null，这样就将删除叶子结点的情况包含在里面了
if (node1.parent == null) {
root = node2;
} else if (node1 == node1.parent.lchild) {
node1.parent.lchild = node2;
} else {
node1.parent.rchild = node2;
}
if (node2 != null)
node2.parent = node1.parent;
}于是删除的方法可以写为public void delete(BinaryTreeNode node) {
if (node.lchild == null) { // 左子树为空，只需要移植右子树
replace(node, node.rchild);
} else if (node.rchild == null) {
replace(node, node.lchild);
} else {
BinaryTreeNode predecessorOfnode = predecessor(node);
replace(node, node.lchild);
predecessorOfnode.rchild = node.rchild;
node.rchild.parent = predecessorOfnode;
}
}
BST的实现
继承上一篇博客的BinaryTree类，这样就可以调用遍历算法了
public class BinarySearchTree extends BinaryTree {
// 从数组创建二叉树
@Override
public void createTree(int[] array) { // 最多是O(nlgn)
// 从一个数组创建二叉搜索树
for (int i : array) {
insertRecur(root, new BinaryTreeNode(i));
}
}
// 某个子树的最小结点
public BinaryTreeNode minNode(BinaryTreeNode node) {
while (node.lchild != null) {
node = node.lchild;
}
return node;
}
//某个子树的最大结点
public BinaryTreeNode maxNode(BinaryTreeNode node) {
while (node.rchild != null) {
node = node.rchild;
}
return node;
}
// 搜索关键字为e的结点，并返回该结点的引用
public BinaryTreeNode search(BinaryTreeNode root, int e) {
if (root == null || e == root.data) // 注意顺序
return root;
if (e < root.data)
return search(root.lchild, e);
else
return search(root.rchild, e);
}
// 插入结点，递归版本
public void insertRecur(BinaryTreeNode root, BinaryTreeNode insertNode) { // O(lgn)
if (this.root == null) {
this.root = insertNode;
return;
} else if (insertNode.data < root.data && root.lchild == null) {
root.lchild = insertNode;
insertNode.parent = root;
return;
} else if (insertNode.data >= root.data && root.rchild == null) {
root.rchild = insertNode;
insertNode.parent = root;
return;
}
if (insertNode.data < root.data && root.lchild != null)
insertRecur(root.lchild,insertNode);
if (insertNode.data >= root.data && root.rchild != null) {
insertRecur(root.rchild,insertNode);
}
}
// 插入节点，非递归版本
public void insert(BinaryTreeNode insertNode) { // O(lgn)
BinaryTreeNode p = root, parent = null;
while (p != null) {
parent = p; // 注意位置
if (insertNode.data < p.data)
p = p.lchild;
else
p = p.rchild;
} // 出循环时，p为null，parent为要插入在该节点下面
insertNode.parent = parent;
if (root == null) {
root = insertNode;
} else if (insertNode.data < parent.data) {
// 将节点插入到parent的左边
parent.lchild = insertNode;
} else {
parent.rchild = insertNode;
}
}
// 用node2来替代node1
private void replace(BinaryTreeNode node1, BinaryTreeNode node2){
// node2可以为null，这样就将删除叶子结点的情况包含在里面了
if (node1.parent == null) {
root = node2;
} else if (node1 == node1.parent.lchild) {
node1.parent.lchild = node2;
} else {
node1.parent.rchild = node2;
}
if (node2 != null)
node2.parent = node1.parent;
}
// 删除某个结点
public void delete(BinaryTreeNode node) {
if (node == null) return;
if (node.lchild == null) { // 左子树为空，只需要移植右子树
replace(node, node.rchild);
} else if (node.rchild == null) {
replace(node, node.lchild);
} else {
BinaryTreeNode predecessorOfnode = predecessor(node);
replace(node, node.lchild);
predecessorOfnode.rchild = node.rchild;
node.rchild.parent = predecessorOfnode;
}
}
// 删除某个结点
@Deprecated
public void deleted(BinaryTreeNode node) {
if (node == null) return;
if (node.lchild == null) { // 左子树为空，只需要移植右子树
// -------1.用该结点的右子树代替它-------
// node = node.rchild;
if (node.parent == null) {
root = node.rchild;
} else if (node == node.parent.lchild) {
node.parent.lchild = node.rchild;
} else {
node.parent.rchild = node.rchild;
}
if (node.rchild != null)
node.rchild.parent = node.parent;
} else if (node.rchild == null) {
// -------2.用该结点的左子树代替它-------
// node = node.lchild;
if (node.parent == null) {
root = node.lchild;
} else if (node == node.parent.lchild) {
node.parent.lchild = node.lchild;
} else {
node.parent.rchild = node.lchild;
}
if (node.lchild != null)
node.lchild.parent = node.parent;
} else {
BinaryTreeNode predecessorOfnode = predecessor(node);
// -------3.用该结点的右子树代替它-------
if (node.parent == null) {
root = node.lchild;
} else if (node.parent.lchild == node) {
node.parent.lchild = node.lchild;
} else if (node.parent.rchild == node) {
node.parent.rchild = node.lchild;
}
node.lchild.parent = node.parent;
node.rchild.parent = predecessorOfnode;
// -------4.将右子树赋值给它的前驱-------
predecessorOfnode.rchild = node.rchild;
node.rchild.parent = predecessorOfnode;
}
}
// 返回某个节点node的前驱
public BinaryTreeNode predecessor(BinaryTreeNode node) {
if (node.lchild != null)
return maxNode(node.lchild);
BinaryTreeNode parent = node.parent;
while (parent != null && parent.lchild == node) {
node = parent;
parent = node.parent;
}
return parent;
}
// 返回某个节点node的后继
public BinaryTreeNode successor(BinaryTreeNode node) {
if (node.rchild != null)
return minNode(node.rchild);
BinaryTreeNode parent = node.parent;
while (parent != null && parent.rchild == node) {
node = parent;
parent = node.parent;
}
return parent;
}
}
测试
public static void main(String[] args) {
BinarySearchTree bst = new BinarySearchTree();
int[] array = {1, 9, 2, 7, 4, 5, 3, 6, 8};
bst.createTree(array);
System.out.println("中序递归遍历");
bst.inOrder(bst.root);
System.out.println("");
System.out.println("层序遍历");
bst.levelOrderH();
bst.delete(bst.search(bst.root, 4));
System.out.println("将4删除后在中序递归遍历");
bst.inOrder(bst.root);
}
输出
中序递归遍历 1 2 3 4 5 6 7 8 9 层序遍历 1 9 2 7 4 8 3 5 6 将4删除后在中序递归遍历 1 2 3 5 6 7 8 9
上面这棵树的形态大致如下
可以清楚地看到，虽然这棵树严格满足BST的要求，但是这棵树是比较深的，而上述操作的时间复杂度直接与树的深度有关，也就是说如果创建的树高度太高，就会直接影响到BST上的操作的性能，因为上述操作的时间复杂度均为O(h)，不要想当然地认为O(h)就是O(lgn)。像上面的这棵树，我们说他是不平衡的，平衡看起来，直观感受是做右子树高度差不多。平衡的二叉排序树即BBST，它的平均深度才为O(lgn)，就能将上述操作的时间复杂度控制在O(lgn)以内。
