二叉排序树基本介绍：
二叉排序树（BST）: (Binary Sort(Search) Tree), 对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。
特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点
比如针对前面的数据 (7, 3, 10, 12, 5, 1, 9，2) ，对应的二叉排序树为：
算法分析：
二叉排序树创建和遍历：
一个数组创建成对应的二叉排序树，并使用中序遍历二叉排序树：
1）、this.value>node.value成立，则判断this.left是否为空，为空则this=node,否则递归实现元素的增加(this.left.infixOrder())
2）、this.value>node.value成立，则判断this.right是否为空，为空则this=node,否则递归实现元素的增加(this.right.infixOrder())
二叉排序树结点的删除：
第一种情况:删除叶子节点 (比如：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
详细代码：
package BinarySortTree;
/**
* @ClassName: BinarySortTreeDemo
* @Description: 二叉排序树的创建，以及结点的查找和删除
* @author Golven
* @date 2019年10月27日
*
*/
public class BinarySortTreeDemo {
public static void main(String[] args) {
int[] arr = { 7, 3, 10, 12, 5, 1, 9 ,2};
BinarySortTree binarySortTree = new BinarySortTree();
for (int i = 0; i < arr.length; i++) {
binarySortTree.add(new Node(arr[i]));
}
System.out.println("删除前：");
binarySortTree.infixOrder();
// binarySortTree.delete(2);//测试删除无子树的结点
// binarySortTree.delete(1);//测试删除有一个子树的结点
binarySortTree.delete(7);//测试删除时有连个子树的结点
System.out.println("删除后：");
binarySortTree.infixOrder();
}
}
//创建二叉树
class BinarySortTree {
private Node root;
// 向二叉树中添加元素
public void add(Node node) {
if (root == null) {
root = node;
} else {
root.add(node);
}
}
// 中序遍历二叉树
public void infixOrder() {
if (root == null) {
System.out.println("树为空");
} else {
root.infixOrder();
}
}
// 查找结点
public Node search(int value) {
if (root == null) {
return null;
} else {
return root.search(value);
}
}
// 查找要删除结点的父节点
public Node searchParent(int value) {
if (root == null) {
return null;
} else {
return root.searchParent(value);
}
}
// 删除结点
public void delete(int value) {
if(root==null) {
return;
}
else {
//找到要删除的结点
Node target = search(value);
//没有找到要删除的结点
if(target == null) {
return;
}
//找到的结点为root并且左右两节点为空
if(root.left==null&&root.right==null) {
root = null;
return;
}
//找到结点的父节点
Node parent = searchParent(value);
//如果要删除的是叶结点
if(target.left==null&&target.right==null) {
//判断要删除的结点时父节点的左子节点还是右子节点
if(parent.left!=null&&parent.left.value==value) {
parent.left=null;
}else if(parent.right!=null&&parent.right.value==value)
parent.right=null;
}
else if(target.left!=null&&target.right!=null) {
//相当于把有删除的结点的右结点作为一个根结点，构成一个新的二叉树，然后在其中找到最小的数替换要删掉的数
int min = delRightTreeMin(target.right);
target.value=min;//将最小的值赋值给target
}else {
//要删除的结点只有一颗子树
//如果target有左子节点
if(target.left!=null) {
if(parent!=null) {
if(parent.left.value==target.value) {
parent.left=target.left;
}else
parent.right=target.left;
}
else {
root = target.left;
}
}
//target有右子节点
else if(target.right!=null) {
if(parent!=null) {
if(parent.left.value==target.value) {
parent.left=target.right;
}else {
parent.right=target.right;
}
}
else {
root = target.right;
}
}
}
}
}
/**
*
* @Title: delRightTreeMin
* @Description: 找到要删除结点右子树中最小的结点
* @param @param node 要删除的结点的右结点
* @param @return 参数
* @return int 以node为根结点的二叉树的最小的值
*/
public int delRightTreeMin(Node node) {
Node temp = node;
while(temp.left!=null) {
temp = temp.left;
}
delete(temp.value);//删除这个最小的结点
return temp.value;
}
}
//创建二叉树的结点类
class Node {
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
}
@Override
public String toString() {
return "Node [value=" + value + "]";
}
public void add(Node node) {
if (node == null) {
return;
}
if (this.value > node.value) {// 要添加的node的值小于当前树的根节点的值
if (this.left == null) {// 判断this的左节点是否为空
this.left = node;// 为空就直接赋给左节点
} else {
// 开始从当前结点的左节点递归
this.left.add(node);
}
} else {// 如果node大与this
if (this.right == null) {// 判断当前结点的右节点是否为空
this.right = node;
} else {
// 从右节点开始递归
this.right.add(node);
}
}
}
// 中序遍历二叉树
public void infixOrder() {
if (this.left != null) {
this.left.infixOrder();
}
System.out.println(this);
if (this.right != null) {
this.right.infixOrder();
}
}
// 查找要删除的结点
/**
*
* @Title: search
* @Description: 查找要删除的结点
* @param @param value 要删除的值
* @param @return 参数
* @return Node 返回类型
*/
public Node search(int value) {
if (this.value == value)
return this;
else if (value < this.value) {
if (this.left == null) {
return null;
}
return this.left.search(value);
} else {
if (this.right == null) {
return null;
}
return this.right.search(value);
}
}
/**
*
* @Title: searchParent
* @Description: 查找要删除结点的父节点
* @param @param value 要找的结点的值
* @param @return 参数 要删除的节点的父节点
* @return Node 返回类型
*/
public Node searchParent(int value) {
if ((this.left != null &&this.left.value == value ) || (this.right != null &&this.right.value == value )) {
return this;
} else {
// 判断要要查找的value如果小于this.value，并且this.left!=null
if ((value < this.value && this.left != null))
return this.left.searchParent(value);// 向左子树递归查找
else if (value > this.value && this.right != null) {
return this.right.searchParent(value);// 向右子树递归查找
} else
return null;
}
}
}