目录
关于二叉排序树的基本概念以及迭代构建，可参考上篇：算法其实很简单—二叉排序树的构建
1. 二叉排序树删除节点思路
二叉排序树的删除情况比较复杂，大概分为四种情况（以下图为参考）：
1.1 删除只有一个节点
直接让root == null
1.2 删除子节点
比如上图中的2、5、9、12
- 找到需要删除的节点，targetNode
- 找到需要删除节点的父节点，parentNode
- 判断targetNode是parentNode的左子节点还是右子节点
- 如果是左子节点，则parentNode.left = null，如果为右子节点，则parentNode.right = null
1.3 删除只有一个子节点的父节点
比如上图中的1
- 找到需要删除的节点，targetNode
- 找到需要删除节点的父节点，parentNode
- 如果parentNode为null，直接让root节点指向左子节点或者右子节点
- 判断targetNode是parentNode的左子节点还是右子节点
- 如果targetNode是parentNode的左子节点且targetNode只有左子节点，则parentNode.left = targetNode.left；如果targetNode是parentNode的左子节点且targetNode只有右子节点，则parentNode.left = targetNode.right
- 如果targetNode是parentNode的右子节点且targetNode只有左子节点，则parentNode.right= targetNode.left；如果targetNode是parentNode的右子节点且targetNode只有右子节点，则parentNode.right= targetNode.right
1.4 删除有两个子节点的父节点
比如上图中的3、7、10
- 找到需要删除的节点，targetNode
- 找到需要删除节点的父节点，parentNode
- 从targetNode的右子树中找到最小的子节点
- 用一个临时变量保存，temp
- 删除最下的子节点
- targetNode.value = temp
2.代码实现
/**
* @author 浪子傑
* @version 1.0
* @date 2020/5/31
*/
public class BinarySearchTreeDemo {
public static void main(String[] args) {
BinarySearchTree binarySearchTree = new BinarySearchTree();
int[] arr = {7, 3, 10, 12, 5, 1, 9, 2};
for (int i : arr) {
Node node = new Node(i);
binarySearchTree.add(node);
}
binarySearchTree.infixOrder();
binarySearchTree.delete(2);
binarySearchTree.delete(5);
binarySearchTree.delete(9);
binarySearchTree.delete(1);
binarySearchTree.delete(7);
binarySearchTree.delete(3);
binarySearchTree.delete(12);
binarySearchTree.delete(110);
System.out.println("删除后~~~~~~~~~~~" + binarySearchTree.root);
binarySearchTree.infixOrder();
}
}
class BinarySearchTree {
Node root;
/**
* 删除节点
*
* @param value
*/
public void delete(int value) {
// 如果父节点为null，直接返回
if (root == null) {
return;
} else {
Node targetNode = search(value);
// 如果要删除的节点为null，直接返回
if (targetNode == null) {
return;
}
// 如果父节点的左右节点都为null，说明只有一个节点，直接将root设为null即可
if (root.left == null && root.right == null) {
root = null;
return;
}
Node parentNode = searchParent(value);
// 如果要删除节点的左右节点都为null，说明该要删除的节点为子节点
if (targetNode.left == null && targetNode.right == null) {
// 如果父节点的左子节点不为null并且是要删除的节点，则将父节点的左子节点设为null
// 如果父节点的右子节点不为null并且是要删除的节点，则将父节点的右子节点设为null
if (parentNode.left != null && parentNode.left.value == value) {
parentNode.left = null;
} else if (parentNode.right != null && parentNode.right.value == value) {
parentNode.right = null;
}
} else if (targetNode.left != null && targetNode.right != null) {
// 如果要删除的左右子节点都不为null，则查找要删除节点右子节点的最小值，删除最小节点并将值赋给要删除节点
int treeMin = delRightTreeMin(targetNode.right);
System.out.println("最小的为---" + treeMin);
targetNode.value = treeMin;
} else {
// 如果要删除的节点左右子节点有一个为null
// 如果要删除的子节点为root节点
if (parentNode == null) {
// 如果左子节点不为null，则将左子节点赋给root
// 否则将右子节点赋给root
if (targetNode.left != null) {
root = targetNode.left;
} else {
root = targetNode.right;
}
}else if (parentNode.left.value == value) {
// 如果要删除的节点为parentNode的左子节点
// 如果要删除的节点的左子节点不为null，则将parentNode的左子节点指向要删除节点的左子节点
// 否则则指向要删除节点的右子节点
if (targetNode.left != null) {
parentNode.left = targetNode.left;
} else {
parentNode.left = targetNode.right;
}
} else {
if (targetNode.right != null) {
parentNode.right = targetNode.right;
} else {
parentNode.right = targetNode.left;
}
}
}
}
}
/**
* 返回以node节点为根节点的二叉排序树的最小值
* @param node
* @return
*/
public int delRightTreeMin(Node node) {
Node target = node;
while (target.left != null) {
target = target.left;
}
delete(target.value);
return target.value;
}
/**
* 查找要删除的节点
*
* @param value
* @return
*/
public Node search(int value) {
if (root == null) {
return null;
} else {
return root.search(value);
}
}
/**
* 查询要删除的父节点
*
* @param value
* @return
*/
public Node searchParent(int value) {
if (root == null) {
return null;
} else {
return root.searchParent(value);
}
}
/**
* 添加子节点
*
* @param node
*/
public void add(Node node) {
if (root == null) {
root = node;
} else {
root.add(node);
}
}
/**
* 中序遍历
*/
public void infixOrder() {
if (root != null) {
root.middleOrder();
} else {
System.out.println("当前root为空");
}
}
}
class Node {
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
}
/**
* 查询要删除的节点
*
* @param value
* @return
*/
public Node search(int value) {
// 如果要查找的值==当前节点的值，返回当前节点
// 如果要查找的值 < 当前节点，则向该节点的左子树查找
// 否则向该节点的右子树查找
if (this.value == value) {
return this;
} else if (value < this.value) {
// 如果该节点的左子节点为null，直接返回null
if (this.left == null) {
return null;
}
return this.left.search(value);
} else {
if (this.right == null) {
return null;
}
return this.right.search(value);
}
}
/**
* 查找要删除节点的父节点
*
* @param value
* @return
*/
public Node searchParent(int value) {
// 如果当前节点的子节点不为空，并且当前节点子节点的值 == value，则返回当前节点
// 如果当前节点的左子节点不为null，并且当前节点的值 > value，则向该节点的左子节点遍历
// 如果当前节点的右子节点不为null，并且当前节点的值不> value，则向该节点的右子节点遍历
// 否则没有找到，返回null
if ((this.left != null && this.left.value == value) ||
(this.right != null && this.right.value == value)) {
return this;
} else if (this.left != null && this.value > value) {
return this.left.searchParent(value);
} else if (this.right != null && this.value <= value) {
return this.right.searchParent(value);
} else {
return null;
}
}
/**
* 添加节点
*
* @param node
*/
public void add(Node node) {
// 如果该节点为null，直接返回
if (node == null) {
return;
}
// add的节点小于当前节点，说明应该在当前节点的左边
// 否则放在当前节点的右边
if (node.value < this.value) {
// 如果当前节点的左边没有子节点，则直接把add节点放在当前节点的左子节点
// 否则的话，遍历当前左子节点，直到找到合适位置
if (this.left == null) {
this.left = node;
} else {
this.left.add(node);
}
} else {
if (this.right == null) {
this.right = node;
} else {
this.right.add(node);
}
}
}
/**
* 中序遍历
*/
public void middleOrder() {
if (this.left != null) {
this.left.middleOrder();
}
System.out.println(this);
if (this.right != null) {
this.right.middleOrder();
}
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
}