Java实现二叉排序树的创建与删除

二叉排序树的概念

所谓二叉排序树，又称二叉查找树，用我自己的话说就是所有节点的左子节点均小于符节点，右子节点均大于父节点。类似与二分法，他的好处就是提高了查找的效率

二叉排序树的删除

一.删除叶子节点
1）根据值找到要删除的节点 target
2）找到target的父节点 parent（便于删除）
3）判断target是parent的左子节点还是右子节点
4）根据情况删除

二.删除只有一颗子树的节点
1）根据值找到要删除的节点 target
2）找到target的父节点 parent（便于删除）
3）判断target是parent的左子节点还是右子节点
4）确定target有左子节点还是右子节点
5）如果target有左子节点
5.1 如果target是parent的左子节点
parent.left=target.left;
5.2 如果target是parent的右子节点
parent.right=target.left;
6) 如果target有右子节点
6.1 如果target是parent的左子节点
parent.left=target.right;
6.2 如果target是parent的右子节点
parent.right=target.right;

三.删除有两颗子树的节点
1）根据值找到要删除的节点 target
2）找到target的父节点 parent（便于删除）
3）从target的右子树找到最小的节点
4）保存最小节点的值temp
5）删除最小的节点
6）target.value=temp

好像有点乱的样子哈哈哈哈哈哈哈，好了废话不多说直接上代码把，博主真困了

package SearchTree;

public class Searchtree {

	public static void main(String[] args) {
		int[] arr={7,3,10,12,5,1,9,2};
		BinarySortTree binarytree=new BinarySortTree();
		for(int i=0;i<arr.length;i++){
			binarytree.add(new Node(arr[i]));
		}
		System.out.println("删除前");
		binarytree.Oreder();
		binarytree.delNode(1);
		System.out.println("删除后");
		binarytree.Oreder();
		//System.out.println(binarytree.Seachparent(4));
	}

}


//创建二叉树
class BinarySortTree{
	private Node root;
	
	
	
	//找到要删除的节点
	public Node Search(int value){
		if(root==null){
			return null;
		}else{
			return root.Search(value);
		}
	}
	
	//找到要删除的父节点
	public Node Seachparent(int value){
		if(root==null){
			return null;
		}else{
			return root.SearchParent(value);
		}
	}
	
	
	//用于删除左右两颗子树的节点
	/**
	 * 找到该节点最小的节点，并将其删除
	 * @param node 传入的节点
	 * @return 返回以node节点为根节点的最小节点的值
	 */
	public int delMin(Node node){
		Node target =node;
		while(target.left!=null){
			target=target.left;
		}
		delNode(target.value);
		return target.value;
	}
	//删除节点
	public void delNode(int value){
		if(root==null){
			return;
		}else{
			//首先找到要删除的节点
			Node target=Search(value);
			if(target==null){
				return;
			}
			//如果这棵树只有一个节点
			if(root.left==null&&root.right==null){
				root=null;
				return;
			}
			//找到父节点
			Node parent=Seachparent(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=delMin(target.right);
				target.value=min;
			}else{//删除只有一棵子树的节点
				if(target.left!=null){
					//如果要删除的节点有左子节点
					if(parent!=null){
						if(parent.left.value==value){
							parent.left=target.left;
						}else{
							parent.right=target.left;
						}
					}else{
						root=target.left;
					}
				}else{//删除的节点有右子节点
					if(parent!=null){
						if(parent.left.value==value){
							parent.left=target.right;
						}else{
							parent.right=target.right;
						}
					}else{
						root=target.right;
					}
				}
				
			}
		}
	}
	
	
	
	
	//创建节点
	public void add(Node node){
		if(root==null){
			root=node;
		}else{
			root.add(node);
		}
	}
	
	//中序遍历
	public void Oreder(){
		if(root!=null){
			root.Order();
		}else{
			System.out.println("节点为空");
		}
	}
}



//创建节点
class Node{
	int value;
	Node left;
	Node right;
	
	public Node(int value){
		this.value=value;
	}
	public int getValue() {
		return value;
	}
	public void setValue(int value) {
		this.value = value;
	}
	@Override
	public String toString() {
		return "Node [value=" + value + "]";
	}
	
	
	//找到要删除的节点
	public Node Search(int value){
		if(this.value==value){
			return this;
		}else if(value<this.value){
			if(this.left==null){
				return null;
			}else{
				return this.left.Search(value);
			}
		}else{
			if(this.right==null){
				return null;
			}else{
				return this.right.Search(value);
			}
		}
	}
	
	
	//找到要删除节点的父节点
	public Node SearchParent(int value){
		if((this.left!=null&&this.left.value==value)||
				(this.right!=null&&this.right.value==value)){
			return this;
		}else{
			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;
			}
		}
	}
	
	//添加节点
	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 Order(){
		if(this.left!=null){
			this.left.Order();
		}
		System.out.println(this);

		if(this.right!=null){
			this.right.Order();
		}
	}
	
	
}