java版二叉查找树的简单实现增加/删除

二叉查找树的定义

百度随便一搜一大堆,但是总结起来就是:
如果树不为空,那么它左子树上的值一定小于根节点,右子树的值一定大于根节点的值,同时它的每个子树也是二叉查找树

就拿上面的这个图片来说,就是一个标准的二叉查找树,对每个根节点来说,它左子树的任何一个值都小于根节点的值,而其右子树的任何一个节点的值都大于根节点的值
如: 根节点8,它左子树的任何节点值1,3,4,6,7都要小于8
而它右子树的节点值10,13,14都要大约8

对于根节点3来说,它左子树的值1 要小于3
它右子树的值4,6,7要大于3

二叉查找树的一般属性

public class TreeNode{
AnyType data;
TreeNode left;
TreeNode right;
}

本次以简单的int型作为节点值来说明二叉查找树的特性

public class TreeNode {

	private int data;
	private TreeNode left;
	private TreeNode right;
	
	public TreeNode(){}
	
	public TreeNode(int data){
		this.data=data;
		left=null;
		right=null;
	}
}

增加一个节点

若要增加一个节点,
1 首先判断根节点在不在,根节点不在的话,那加的这个节点就是根节点
2 根节点存在,那么判断增加的节点的值和根节点值得大小,用以判断是在左子树上加还是在右子树上加

/**
	 * 新增一个节点值
	 * @author 天河
	 * @param data 要新增的节点的值
	 * @param node 与新增值比较的节点,用以判断新增的值是其左子树或右子树
	 */
	public void add(int data,TreeNode node) {
		//若根节点为空,则增加的这个节点为根节点
		if(node==null) {
			node=new TreeNode(data);
		}else {
			//用本次增加的节点的值与每次循环的节点做比较,以此来判断要增加的节点是在其左子树还是右子树
			int flag=compareTo(data,node);
			
			if(flag<0) {  //该值小于节点值,要放在节点的左子树上
				if(node.left==null) { //若节点左子树上为空,那么直接新建一个节点,新建的节点的值就是data
					node.left=new TreeNode(data);
				}else {  //若左子树不为空,则继续比较增加的值与其左子树的值大小,递归算法
					add(data,node.left);
				}
			}else {
				if(node.right==null) {  //若右子树为空,那么直接新建一个节点,新建节点的值就是data
					node.right=new TreeNode(data);
				}else { //若右子树不为空,那么继续比较data与其右子树的大小,递归算法
					add(data,node.right);
				}
			}
		}
	}

先序遍历

先讲一下二叉树的先序遍历规则:先从根节点开始,再到左子树,最后到右子树
就以上图为例,
先序遍历的结果为:8,3,1,6,4,7,10,14,13
顺便再多说一下中序遍历,顺序为左中右,那么上图遍历结果将是
中序遍历:1,3,4,6,7,8,10,13,14 可以思考下为什么是这个结果

//先序遍历
	public void preOrder(TreeNode node){
		if(node!=null) {
			System.out.println(node.data);
			preOrder(node.left);
			preOrder(node.right);
		}
	}

删除节点 --最重要的

删除节点时,有多种情况需要考虑

1. 当删除的节点没有左右子树时,直接将节点赋值为null
2. 当左右子树只有一个时,删除了该节点,那么要将其父节点指向其子节点
3. 当左右子树都有时,要注意
   从二叉查找树的特性来讲,一定要使删除后的树同样符合二叉查找树的特点,因此有2中办法,
   1 从要删除的节点的左子树中找到一个最大值,来替代这个删除的节点
   2 从要删除的节点的右子树中,找到一个最小值,来替代这个节点
   不管从左子树找还是从右子树找,都要时时刻刻记住二叉查找树的特性

/**
	 * @author 天河
	 * @param data 要删除的节点的值
	 * @param node 每次要与删除值比较的节点
	 * @return 返回被删除的节点
	 */
	public TreeNode remove(int data,TreeNode node) {
		if(node==null) {
		}else {
			int flag=compareTo(data,node);
			//如果flag小,说明在node的左边,继续找
			if(flag<0) {
				remove(data,node.left);
			}else if(flag>0) {
				//flag大于0,说明data所在的可能在node的右侧
				remove(data,node.right);
			}else if(node.left!=null&&node.right!=null) {
				//说明要删除的节点有左右子树
				//1 找到右子树的最小值
				TreeNode minNode=findMin(node.right);
				//2 仅仅将值替换
				node.data=minNode.data;
				//3 找到最小值所在的节点,删掉
				node.right=remove(node.data,minNode);
			}else {
				//找到相等的节点,其不同时含左右双子树,或者其仅仅是个叶子节点
				//或者是因为上一步替换了原先要删除的节点的值而要删除此节点
				node=(node.left==null)?node.right:node.left;
			}
						
		}
		return node;
	}

/**
	 * 查找最小值
	 * @param node
	 * @return
	 */
	public TreeNode findMin(TreeNode node) {
		if(node.left!=null) {
			node=findMin(node.left);
		}
		return node;
	}

测试代码

最后可以写一个测试代码来测试下上面的内容
先根据图片上的二叉查找树,来生成

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a={8,3,1,6,4,7,10,14,13};;
		TreeNode root=new TreeNode(a[0]);
		//生成二叉查找树
		for(int i=1;i<a.length;i++) {
			root.add(a[i], root);
		}
		//先序遍历
		root.preOrder(root);
		//删除节点3
		root.remove(3, root);
		System.out.println("-------------------");
		//先序遍历打印树的内容
		root.preOrder(root);
	}
}