一、二叉排序树介绍
- 二叉排序树：BST: (Binary Sort(Search) Tree), 排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。
- 特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点
二、二叉排序树的构建、遍历、删除
1. 构建
1.要求在创建是比较节点的value，大的方根节点的右边晓得方根节点的左边。
2. 若this.value > value，且如果this.left == null，则this.left = node.否则在左子树递归查找this.left.add(node)
3.若this.value < value，且如果this.right == null，则this.right = node，否则在右子树递归查找this.right.add(node)
2. 遍历
采用中序遍历，由左至右遍历整棵树
3. 删除
第一种情况:
删除叶子节点 (比如：2, 5, 9, 12)
思路
(1) 需求先去找到要删除的结点 targetNode
(2) 找到targetNode 的 父结点 parent
(3) 确定 targetNode 是 parent的左子结点 还是右子结点
(4) 根据前面的情况来对应删除
左子结点 parent.left = null
右子结点 parent.right = null;
第二种情况: 删除只有一颗子树的节点 比如 1
思路
(1) 需求先去找到要删除的结点 targetNode
(2) 找到targetNode 的 父结点 parent
(3) 确定targetNode 的子结点是左子结点还是右子结点
(4) targetNode 是 parent 的左子结点还是右子结点
(5) 如果targetNode 有左子结点
(5.1)如果 targetNode 是 parent 的左子结点
parent.left = targetNode.left;
(5.2)如果 targetNode 是 parent 的右子结点
parent.right = targetNode.left;
(6) 如果targetNode 有右子结点
(6.1) 如果 targetNode 是 parent 的左子结点
parent.left = targetNode.right;
(6.2) 如果 targetNode 是 parent 的右子结点
parent.right = targetNode.right情况三 ： 删除有两颗子树的节点. (比如：7, 3，10 )
思路
(1) 需求先去找到要删除的结点 targetNode
(2) 找到targetNode 的 父结点 parent
(3) 从targetNode 的右子树找到最小的结点
(4) 用一个临时变量，将 最小结点的值保存 temp = 11
(5) 删除该最小结点
(6) targetNode.value = temp
三、代码
/**
* @Description 二叉排序树
* @Author Meng
* @Versions
* @Date 2021-07-27-12:33
*/
public class BinarySortTreeDome {
public static void main(String[] args) {
int[] array = {7, 3, 10, 12, 5, 1, 9, 2};
BinarySortTree binarySortTree = new BinarySortTree();
// 构造BST树
for (int i : array) {
binarySortTree.add(new Node(i));
}
// 测试中序遍历
// binarySortTree.infixSort(binarySortTree.getRoot());
/**
* 测试搜索
*/
// Node root = binarySortTree.getRoot();
// Node search = root.search(9);
// System.out.println(search);
// Node node = root.parentSearch(9);
// System.out.println(node);
// binarySortTree.delNode(12);
// binarySortTree.delNode(5);
// binarySortTree.delNode(10);
// binarySortTree.delNode(2);
// binarySortTree.delNode(3);
// binarySortTree.delNode(9);
binarySortTree.delNode(1);
// binarySortTree.delNode(7);
System.out.println("root=" + binarySortTree.getRoot());
System.out.println("删除结点后");
binarySortTree.infixSort(binarySortTree.getRoot());
}
}
// 创建二叉排序树
class BinarySortTree {
private Node root;
public Node getRoot() {
return root;
}
public void add(Node node) {
if (root == null) {
root = node;
} else {
root.add(node);
}
}
public void infixSort(Node node) {
if (node == null) {
return;
} else {
node.infixSort();
}
}
//查找要删除的结点
public Node search(int value) {
if (root == null) {
return null;
} else {
return root.search(value);
}
}
//查找父结点
public Node parentSearch(int value) {
if (root == null) {
return null;
} else {
return root.parentSearch(value);
}
}
//1. 返回的 以node 为根结点的二叉排序树的最小结点的值
//2. 删除node 为根结点的二叉排序树的最小结点
/**
* @param node 传入的结点(当做二叉排序树的根结点)
* @return 返回的 以node 为根结点的二叉排序树的最小结点的值
*/
public int delRightTreeMin(Node node) {
Node target = node;
//循环的查找左子节点，就会找到最小值
while (target.left != null) {
target = target.left;
}
//这时 target就指向了最小结点
//删除最小结点
delNode(target.value);
return target.value;
}
/**
* @param value
*/
public void delNode(int value) {
if (root == null) {
return;
} else {
// 删除的节点
Node targetNode = search(value);
if (targetNode == null) {
System.out.println("没有找到要删除的节点~~~");
return;
}
if (root.left == null && root.right == null) { // 若根节点没有左子节点和右子节点，那么也就不会有父节点了，直接将根节点置为null
root = null;
return;
}
// 待删除节点的父节点
Node parentNode = parentSearch(value);
// 若待删除的节点时叶子节点---叶子节点下面没有其他节点
if (targetNode.left == null && targetNode.right == null) {
if (parentNode.left != null && parentNode.left.value == value) {
parentNode.left = null;
}
if (parentNode.right != null && parentNode.right.value == value) {
parentNode.right = null;
}
} else if (targetNode.left != null && targetNode.right != null) {
int i = delRightTreeMin(targetNode.right);
targetNode.value = i;
} else { // 待删除的节点有左子节点或右子节点
// 若待删除的节点是parentNode的左节点
if (parentNode.left.value == targetNode.value) {
// 且待删除的节点有左子节点
if (targetNode.left != null) {
parentNode.left = targetNode.left;
}
// 或者待删除节点有右子节点
if (targetNode.right != null) {
parentNode.left = targetNode.right;
}
}
// 若待删除的节点是parentNode的右节点
if (parentNode.right.value == targetNode.value) {
// 且待删除的节点有左子节点
if (targetNode.left != null) {
parentNode.right = targetNode.left;
}
// 或者待删除节点有右子节点
if (targetNode.right != null) {
parentNode.right = targetNode.right;
}
}
}
}
}
}
class Node {
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
}
/**
* 搜索vale对应节点的父节点
*
* @param value 要找到的结点的值
* @return 返回的是要删除的结点的父结点，如果没有就返回null
*/
public Node parentSearch(int value) {
if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {
return this;
} else {
if (this.left != null && value < this.value) {
return this.left.parentSearch(value);
} else if (this.right != null && value > this.value) {
return this.right.parentSearch(value);
} else {
return null;
}
}
}
/**
* 搜索节点
*
* @param value 具体的值
* @return
*/
public Node search(int value) {
if (this.value == value) {
return this;
}
if (this.value > value) {
if (this.left != null) {
return this.left.search(value);
} else {
return null;
}
} else if (this.value < value) {
if (this.right != null) {
return this.right.search(value);
} else {
return null;
}
} else {
return null; // 表示没有找到
}
}
/**
* 二叉排序树添加节点
*
* @param node
*/
public void add(Node node) {
// 判断传进来的节点是否为空
if (node == null) {
return;
}
if (this.value > node.value) {
// 向左子树找插入位置
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 infixSort() {
// 先遍历左子树
if (this.left != null) {
this.left.infixSort();
}
System.out.println(this);
// 在遍历右子树
if (this.right != null) {
this.right.infixSort();
}
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
}
京公网安备 11010502036488号