二叉排序树（JAVA实现）

基本介绍：
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]