基本介绍:
BST(Binary Sort Tree),对于二叉排序树的任何非叶子节点,要求左子节点的值比当前节点小,右子节点的值比当前节点的值大
注意:如果有相同的值,可以将该节点放在左子节点或右子节点
删除节点:
1、删除叶子节点
(1)先找到要删除的节点 targetNode
(2)找到targetNode的父节点parent
(3)确定targetNode是parent的左子节点还是右子节点
(4)根据前面的情况对应删除
左子节点: parent.left=null
右子节点:parent.right=null
2、删除只有一颗子树的节点
(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有右子节点
5、1如果targetNode是parent的左子节点 parent.left=targetNode.right
5、2如果targetNode是parent的右子节点 parent.right=targetNode.right
3、删除有两颗子树的节点
(1)先找到要删除的节点 targetNode
(2)找到targetNode的父节点parent
(3)从targetNode的右子树找到最小的节点
(4)用一个临时变量。将最小的节点保存到temp
(5)删除这个最小的节点
(6)targetNode.value=temp
代码实现:
public class BinaryTreeSort {
public static void main(String[] args) {
// TODO 自动生成的方法存根
int[] arr= {7,3,10,12,5,1,9,2};
binarySortTree bst=new binarySortTree();
for(int i=0;i<arr.length;i++) {
bst.add(new Node(arr[i]));
}
System.out.println("删除前中序遍历为:");
bst.infixOrder();
bst.delNode(7);
System.out.println("删除后中序遍历为:");
bst.infixOrder();
}
}
//创建二叉排序树
class binarySortTree{
private Node root;
//添加节点的方法
public void add(Node node) {
if(root==null) {
root=node;
}else {
root.add(node);
}
}
//查找要删除的节点
public Node searchNode(int value) {
if(root==null) {
return null;
}else {
return root.searchNode(value);
}
}
//查找要删除节点的父节点
public Node searchParent(int value) {
if(root==null) {
return null;
}else {
return root.searchParent(value);
}
}
//删除节点
public void delNode(int value) {
if(root==null) {
return;
}else {
//先找到要删除的节点
Node targetNode=searchNode(value);
//如果没有要删除的节点
if(targetNode==null) {
return;
}
//如果发现只有root这一个节点
if(root.left==null&&root.right==null) {
root=null;
return;
}
//查找要删除节点的父节点
Node parent=searchParent(value);
//如果要删除的节点为叶子节点
if(targetNode.left==null&&targetNode.right==null) {
//判断targetNode是parent的左子节点还是右子节点
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(targetNode.left!=null&&targetNode.right==null) {
if(parent==null) {
root=targetNode.left;
}else {
//如果要删除的节点为只有一颗左子树的节点
if(parent.left!=null&&parent.left.value==value) {
//如果要删除的节点在父节点的左边
parent.left=targetNode.left;
}else if(parent.right!=null&&parent.right.value==value) {
//如果删除的节点在父节点的右边
parent.right=targetNode.left;
}
}
}else if(targetNode.right!=null&&targetNode.left==null) {
if(parent==null) {
root=targetNode.right;
}else{
//如果要删除的节点为只有一颗右子树的节点
if(parent.left!=null&&parent.left.value==value) {
parent.left=targetNode.right;
}else if(parent.right!=null&&parent.right.value==value) {
parent.right=targetNode.right;
}
}
}else {
//要删除的节点为非叶子节点
//从targetNode的右子树找到最小的值
//创建一个辅助节点
Node tempNode=targetNode;
if(targetNode.right!=null) {
targetNode=targetNode.right;
while(targetNode.left!=null) {
targetNode=targetNode.left;
}
}
//定义一个变量存储最小的值
int temp=targetNode.value;
delNode(targetNode.value);
tempNode.value=temp;
}
}
}
//中序遍历
public void infixOrder() {
if(root!=null) {
root.infixOrder();
}else {
System.out.println("当前二叉排序树为空");
}
}
}
class Node{
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
}
@Override
public String toString() {
return "Node [value=" + value + "]";
}
//编写一个查找要删除的节点的方法
public Node searchNode(int value) {
if(this.value==value) {
return this;
}else if(value<this.value){
if(this.left!=null) {
//向左遍历查找
return this.left.searchNode(value);
}else {
return null;
}
}else {
if(this.right!=null) {
//向右遍历查找
return this.right.searchNode(value);
}else {
return null;
}
}
}
//编写一个查找要删除的节点的父节点的方法
public Node searchParent(int value) {
//当前节点就是要删除节点的父节点
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;
}
}
}
//编写一个在末尾添加节点的方法
public void add(Node node) {
if(node==null) {
return;
}
if(node.value<this.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 infixOrder() {
if(this.left!=null) {
this.left.infixOrder();
}
System.out.println(this);
if(this.right!=null) {
this.right.infixOrder();
}
}
}
测试结果:
删除前中序遍历为:
Node [value=1]
Node [value=2]
Node [value=3]
Node [value=5]
Node [value=7]
Node [value=9]
Node [value=10]
Node [value=12]
删除后中序遍历为:
Node [value=1]
Node [value=3]
Node [value=5]
Node [value=9]
Node [value=10]
Node [value=12]