数据结构—排序二叉树

介绍：

二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。是数据结构中的一类。在一般情况下，查询效率比链表结构要高。对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。

特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点

例如： (7, 3, 10, 12, 5, 1, 9) ，对应的二叉排序树为：

package com.xawl.tree.BinarySortTree;

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(); // 1, 2, 3, 5, 7, 9, 10, 12
		
	    binarySortTree.delNode(3);
		
		System.out.println("删除结点后");
		binarySortTree.infixOrder();
	}
	
}

//创建二叉排序树
class BinarySortTree {
	private Node root;
	
	public Node getRoot() {
		return root;
	}
	
	//添加结点的方法
	public void add(Node node) {
		if(root == null) {
			root = node;//如果root为空则直接让root指向node
		} else {
			root.add(node);
		}
	}
	//中序遍历
	public void infixOrder() {
		if(root != null) {
			root.infixOrder();
		} else {
			System.out.println("二叉排序树为空，不能遍历");
		}
	}
	
	//查找要删除的结点
	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);
		}
	}
	
	/**
	 * 删除结点
	* @Description 
	* @param value
	 */
	public void delNode(int value) {
		if(root == null) return;
		
		//需求先去找到要删除的结点  targetNode
		Node targetNode = search(value);
		if(targetNode == null) return ;
		
		//如果当前这颗二叉排序树只有一个结点(因为targetNode不为null)，所有root就是目标节点
		if(root.left == null && root.right == null){
			root = null;
			return;
		}
		
		//找到targetNode的父结点(能跑到这里说明targetNode一定有父节点)
		Node parent = searchParent(value);
		
		//①删除的结点是叶子结点
		if(targetNode.left == null && targetNode.right == null){
			//判断targetNode 是父结点的左子结点，还是右子结点
			if(parent.left != null && parent.left.value == value){
				parent.left = null;
			}else if(parent.right != null && parent.right.value == value){
				parent.right = null;
			}
			return;
		}
		
		//②删除的节点有两颗子树
		if(targetNode.left != null && targetNode.right != null){
			int minVal = delRightTreeMin(targetNode.right);
			targetNode.value = minVal;
			return;
		}
		
		//③删除的节点有一颗子树
		if((targetNode.left == null && targetNode.right != null) ||
				(targetNode.left != null && targetNode.right == null)){
			
			//如果要删除的结点有左子结点 
			if(targetNode.left != null){
				if(parent != null){
					//如果 targetNode 是 parent 的左子结点
					if(parent.left.value == value){
						parent.left = targetNode.left;
					}else{
						parent.right = targetNode.left;
					}
				}else root = targetNode.left;
			}
			
			//如果要删除的结点有右子结点 
			if(targetNode.right != null){
				if(parent != null){
					//如果 targetNode 是 parent 的左子结点
					if(parent.left.value == value){
						parent.left = targetNode.right;
					}else{
						parent.right = targetNode.right;
					}
				}else root = targetNode.right;
			}	
		}	
	}
	
	/**
	 * 删除node 为根结点的二叉排序树的最小结点
	* @Description 
	* @param node
	* @return 以node 为根结点的二叉排序树的最小结点的值
	 */
	public int delRightTreeMin(Node node) {
		Node target = node;
		//循环的查找左子节点，就会找到最小值
		while(target.left != null){
			target = target.left;
		}
		//此时遍历到的节点时叶子节点
		delNode(target.value);
		return target.value;		
	}
}


//创建Node结点
class Node {
	int value;
	Node left;
	Node right;
	
	public Node(int value) {			
		this.value = value;
	}
	
	//添加节点
	public void add(Node node) {
		if(node == null) return;
		
		//判断要添加的节点与当前节点的大小
		if(node.value < this.value){
			//判断当前节点的左子节点是否为null
			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);
			}
		}
	}
	
	/**
	 * 查找要删除的节点
	* @Description 
	* @param value
	* @return
	 */
	public Node search(int value) {
		if(value == this.value){//当前节点就是目标节点
			return this;
		} else if(value < this.value ){//查找的值小于当前结点，向左子树递归查找
			//如果左子节点为空就返回null
			if(this.left == null) return null;
			
			return this.left.search(value);
		} else {//如果查找的值不小于当前结点，向右子树递归查找
			//如果右子节点为空就返回null
			if(this.right == null) return null;
			
			return this.right.search(value);
		}
	}
	
	/**
	 * 查找要删除结点的父结点
	* @Description 
	* @param value
	* @return
	 */
	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; //找不到父节点
			}
		}
	}
	
	@Override
	public String toString() {
		return "Node [value=" + value + "]";
	}
	
	//中序遍历
	public void infixOrder() {
		if(this.left != null) {
			this.left.infixOrder();
		}
		System.out.println(this);
		if(this.right != null) {
			this.right.infixOrder();
		}
	}
}