AVD二叉查找树

二叉查找树是树；

二叉查找树是子节点最多=2的树；

二叉查找树是子节点最多=2且节点可以比较大小的树；

二叉查找树是子节点最多=2且节点可以比较大小，并且节点的左子树中的所有节点小于该节点的树；

二叉查找树是子节点最多=2且节点可以比较大小，并且节点的左子树中的所有节点小于该节点，且节点的右子树中的左右节点大于该节点的树；

二叉查找树是子节点最多=2且节点可以比较大小，并且节点的左子树中的所有节点小于该节点，且节点的右子树中的左右节点大于该节点，且没有相等节点的树；

下面给出二叉查找树的java实现

元素的数据结构：

package com.avd.binarysearchtree;

public class Element implements Comparable<Element> {

	private int eleSize;
	
	public Element(){
		this(0);
	}
	public Element(int eleSize){
		this.eleSize = eleSize;
	}
	public int getEleSize(){
		return eleSize;
	}
	public void setEleSize(int eleSize){
		this.eleSize = eleSize;
	}
	
	@Override
	public int compareTo(Element o) {
		
		if(eleSize < o.getEleSize()) return -1;
		else if(eleSize > o.getEleSize()) return 1;
		else return 0;
	}

}

树节点的数据结构

package com.avd.binarysearchtree;

public class BinaryNode<Element> {
	
	private Element ele;
	private BinaryNode<Element> left;
	private BinaryNode<Element> right;
	
	public BinaryNode(Element ele){
		this(ele,null,null);
	}
	public BinaryNode(Element ele,BinaryNode<Element> left, BinaryNode<Element> right){
		this.ele = ele;
		this.left = left;
		this.right = right;
	}
	public Element getEle() {
		return ele;
	}
	public void setEle(Element ele) {
		this.ele = ele;
	}
	public BinaryNode<Element> getLeft() {
		return left;
	}
	public void setLeft(BinaryNode<Element> left) {
		this.left = left;
	}
	public BinaryNode<Element> getRight() {
		return right;
	}
	public void setRight(BinaryNode<Element> right) {
		this.right = right;
	}

}

二叉查找树的方法实现

package com.avd.binarysearchtree;

import com.avd.binarysearchtree.BinaryNode;
import com.avd.binarysearchtree.Element;

public class BinarySearchTree {

	private BinaryNode<Element> root;
	
	public BinarySearchTree(){
		this(null);
	}
	public BinarySearchTree(BinaryNode<Element> bN){
		root = bN;
	}
	
	public boolean isEmpty(){
		return root == null;
	}
	
	public void makeEmpty(){
		root = null;
	}
	
	public boolean contain(Element ele){
		return contain(ele,root);
	}
	
	public void insert(Element ele){
		contain(ele,root);
	}
	
	public Element findMin(){
		return findMin(root).getEle();
	}
	
	public Element findMax(){
		return findMax(root).getEle();
	}
	
	public void remove(Element ele){
		remove(ele,root);
	}
	
	private boolean contain(Element ele, BinaryNode<Element> bN){
		if(bN == null) return false;
		int compResult = ele.compareTo(bN.getEle());
		if(compResult < 0) return contain(ele,bN.getLeft());
		else if(compResult > 0) return contain(ele,bN.getRight());
		else return true;
		/**
		 * contain方法两个出口
		 * 1、bN==null说明不存在ele，此时返回false；
		 * 2、compResult==0，找到ele返回true；
		 */
	}
	
	private BinaryNode<Element> findMin(BinaryNode<Element> bN){
		if(bN == null) return bN;
		if(bN.getLeft() != null) return findMin(bN.getLeft());
		return bN;
		/**
		 * findMin的递归算法需要注意两点
		 * 出口：
		 * findMin的出口为bN.getLift()==null，此时bN即是最小的节点；
		 * 第二点：
		 * 由于bN的左节点为null的时候将返回bN，因此第一个if判断条件针对的是传入的节点即根节点为null的情况，此时将返回bN即null指针
		 * 
		 */
	}
	
	private BinaryNode<Element> findMax(BinaryNode<Element> bN){
		if(bN != null)
			while(bN.getRight() != null)
				bN = bN.getRight();
		return bN;
		/**
		 * 功能和findMin类似
		 * findMin的非递归算法实现，不解释
		 */
	}
	
	private BinaryNode<Element> remove(Element ele, BinaryNode<Element> bN){
		
		if(bN == null) return bN;
		
		int compResult = ele.compareTo(bN.getEle());
		
		if(compResult < 0) bN.setLeft(remove(ele,bN.getLeft()));//沿左子树查找待删除的节点
		else if(compResult > 0) bN.setRight(remove(ele,bN.getRight()));//沿右子树查找待删除的节点
		else if(bN.getLeft() != null && bN.getRight() != null){//匹配节点成功，待删除节点包含左右子树
			bN.setEle(findMin(bN.getRight()).getEle());
			bN.setRight(remove(bN.getEle(),bN.getRight()));
		}else return bN.getLeft() != null ? bN.getLeft() : bN.getRight();//匹配节点成功，待删除节点最多有一个子节点
		
		return bN;
		
		/**
		 * remove是树操作中相对比较难的方法
		 * 树删除操作有三种情况：
		 * 1、删除节点是叶子节点，此种情况最为简单，直接删除即可；
		 * 2、删除节点不是叶子节点，且只有一个子节点，这种情况相对简单，通过将删除节点的父节点的指针指向其子节点即可；
		 * 3、删除节点不是叶子节点，且有两个子节点，这种情况最为复杂，需要通过两步解决：
		 * 		a、将匹配节点修改为其右子树的最小节点；
		 * 		b、删除其右子树的最小节点；
		 */
		
	}
	
}