从零单刷数据结构（Java描述）（二十四）——二叉树结点的删除

二叉树结点的删除需要考虑如果要删除的不是叶子节点则需要递归删除整个子树。

//定义一棵二叉树
public class BinaryTree {
	public TreeNode root;

	// 设置根结点
	public void setRoot(TreeNode root) {
		this.root = root;
	}

	// 获取根结点
	public TreeNode getRoot() {
		return root;
	}
	//前序遍历
	public void frontShow() {
		if(root!=null)
		root.frontShow();
	}
	//中序遍历
	public void middleShow() {
		if(root!=null)
		root.middleShow();
	}
	//后序遍历
	public void backShow() {
		if(root!=null)
		root.backShow();
	}
	
	//前序查找
	public TreeNode frontSearch(int i) {
		return root.frontSearch(i);
	}
	
	//删除一个子树
	public void delete(int i) {
		// TODO Auto-generated method stub
		if(root.value==i)
			root=null;
		else 
			root.delete(i);
	}

}

//树结点
public class TreeNode {
	// 结点的权
	int value;
	// 左儿子
	TreeNode lNode;
	// 右儿子
	TreeNode rNode;

	public TreeNode(int value) {
		this.value = value;
	}

	// 设置左儿子
	public void setlNode(TreeNode lNode) {
		this.lNode = lNode;
	}

	// 设置右儿子
	public void setrNode(TreeNode rNode) {
		this.rNode = rNode;
	}

	// 前序遍历
	public void frontShow() {
		// 先遍历当前结点的内容
		System.out.print(value+" ");
		// 左结点
		if (lNode != null)
			lNode.frontShow();
		// 右结点
		if (rNode != null)
			rNode.frontShow();
	}
	
	//中序遍历
	public void middleShow() {
		//左结点
		if(lNode!=null)
			lNode.middleShow();
		//根结点
		System.out.print(value+" ");
		//右结点
		if(rNode!=null)
			rNode.middleShow();
	}

	public void backShow() {
		//左结点
		if(lNode!=null)
			lNode.backShow();
		//右结点
		if(rNode!=null)
			rNode.backShow();
		//根结点
		System.out.print(value+" ");
	}
	
	//前序查找
	public TreeNode frontSearch(int i) {
		TreeNode target=null;
		//对比当前结点的值
		if(this.value==i) {
			return this;
		}else {
		//当前结点的值不是要查找的结点
		//查找左儿子
			if(lNode!=null) {
				//有可能可以查到，也可以查不到，查不到的话，target还是一个null
				target=lNode.frontSearch(i);
			}
			//如果不为空，说明在左儿子中已经找到
			if(target!=null) {
				return target;
			}
			//查找右儿子
			if(rNode!=null) {
				target=rNode.frontSearch(i);
			}
		}
		return target;
	}
	//删除一个子树
	public void delete(int i) {
		TreeNode parent=this;
		//判断左儿子
		if(parent.lNode!=null && parent.lNode.value==i) {
			parent.lNode=null;
			return;
		}
		//判断右儿子
		if(parent.rNode!=null && parent.rNode.value==i) {
			parent.rNode=null;
			return;
		}
		//递归检查并删除左儿子
		parent=lNode;
		if(parent!=null)
			parent.delete(i);
		//递归检查并删除右儿子
		parent=rNode;
		if(parent!=null) 
			parent.delete(i);
	}
}

//测试类
public class TestBinaryTree {
	public static void main(String[] args) {

		// 创建一棵树
		BinaryTree b = new BinaryTree();
		// 创建根结点
		TreeNode root = new TreeNode(1);
		// 把根结点赋给树
		b.setRoot(root);
		// 创建左结点
		TreeNode rootL = new TreeNode(2);
		// 把新创建的结点设置为根结点的子结点
		root.setlNode(rootL);
		// 创建右结点
		TreeNode rootR = new TreeNode(3);
		// 把新创建的结点设置为根结点的子结点
		root.setrNode(rootR);
		// 为第二层的左结点创建两个子结点
		rootL.setlNode(new TreeNode(4));
		rootL.setrNode(new TreeNode(5));
		// 为第二层的左结点创建两个子结点
		rootR.setlNode(new TreeNode(6));
		rootR.setrNode(new TreeNode(7));
		
		//删除结点前前序遍历
		//输出：1 2 4 5 3 6 7 
		b.frontShow();
		System.out.println();
		System.out.println("============================");
		b.delete(5);
		//删除结点后
		//输出：1 2 4 3 6 7 
		b.frontShow();
	}

}