二叉树

二叉树的创建，添加和遍历都比较简单，而删除方面却比较繁琐。

public class BinTree<T> {
	private int n; //树中元素个数
	private BTNode<T> root;
	
	public BinTree() {
		this.n = 0;
		this.root = null;
	}
	/**
	 * 判断二叉树是否为空
	 */
	public boolean isEmpty() {
		return this.n==0? true:false;
	}
	/**
	 * 获得二叉树中结点个数
	 */
	public int getNumber() {
		return this.n;
	}
	/**
	 * 获得根结点
	 */
	public BTNode<T> getRootNode() {
		return this.root;
	}
	/**
	 * 找出key的父节点(如果树中没有该结点，则返回应该是该结点的父结点的结点)
	 */
	public BTNode<T> getParent(T key) {
		if(this.root==null) {
			return root;
		}
		BTNode<T> pointer = this.root;
		int comResult;
		int comResult1;
		while(true) {
			
			comResult1 = pointer.key.toString().compareTo(key.toString());
			//如果该值应该位于某节点的左结点，并且左结点为空
			if(pointer.left==null && comResult1>0) {
				return pointer;
			}
			//如果该值应该位于某节点的右结点，并且右结点为空
			else if(pointer.right==null && comResult1<0) {
				return pointer;
			}
			
			comResult = pointer.key.toString().compareTo(key.toString());
			if(comResult>0) { //左
				pointer = pointer.left;
			}
			else if(comResult<0) {//右
				pointer = pointer.right;
			}
			else if(comResult==0) {
				//System.out.println("树中已存在该结点!");
				return pointer.parent;
			}
		
		}
		
	}
	/**
	 * 向二叉树中添加结点(如果树中已存在该结点，则该结点将覆盖树中已有的结点)
	 * @param args
	 */
	public boolean addNode(T key) {
		if(root==null) {
			root = new BTNode<T>(key, null, null, null);
			this.n ++;
		}
		else {
			BTNode<T> node = new BTNode<T>(key, null, null, null);
			BTNode<T> parent = this.getParent(key);
//			if(parent.left!=null && parent.right!=null)
//			if(parent.left.key==key || parent.right.key==key) {
//				System.out.println(key + "添加失败,树中已存在该结点");
//				return false;
//			}
//			
			int comResult = parent.key.toString().compareTo(node.key.toString());
			if(comResult>0) { //插入结点小于其父节点
				parent.left = node;
				node.parent = parent;
			}
			else { //插入结点大于其父节点
				parent.right = node;
				node.parent = parent;
			}
		}
		return true;
	}
	/**
	 * 删除二叉树中的结点
	 */
	public boolean deleteNode(T key) {
		if(this.root==null) return false;
		BTNode<T> parent = this.getParent(key);
		int comResult = parent.key.toString().compareTo(key.toString()); //比较key与某个结点的大小(结果为-1||0||1)
		//删除的结点在parent的左子树
		if(comResult>0) {
			if(parent.left==null) {
				System.out.println("删除失败，树中没有该结点!");
				return false;
			}
			//如果删除结点的右子树不为空，将用右子树第一个结点代替删除结点
			if(parent.left.right!=null) {
				BTNode<T> right_ch = parent.left.right;
				//找到right_ch左子树的最小结点,然后将删除结点左子树加入到该结点左子树
				BTNode<T> pointer = right_ch;
				while(pointer.left!=null) {
					pointer = pointer.left;
				}
				//将删除结点的左子树加入到其右子树最小结点的左子树
				pointer.left = parent.left.left;
				parent.left = right_ch;
			}
			//删除结点的右子树为空，将左子树的第一个结点代替删除结点
			else {
				parent.left = parent.left.left;
			}
		}
		//删除的结点在parent的右子树
		else if(comResult<0) {
			if(parent.right==null) {
				System.out.println("删除失败，树中没有该结点!");
				return false;
			}
			//如果删除结点的右子树不为空，将用右子树第一个结点代替删除结点
			if(parent.right.right!=null) {
				BTNode<T> right_ch = parent.right.right;
				//找到right_ch左子树的最小结点,然后将删除结点左子树加入到该结点左子树
				BTNode<T> pointer = right_ch;
				while(pointer.left!=null) {
					pointer = pointer.left;
				}
				//将删除结点的左子树加入到其右子树最小结点的左子树
				pointer.left = parent.right.left;
				parent.right = right_ch;
			}
			//删除结点的右子树为空，将左子树的第一个结点代替删除结点
			else {
				parent.right = parent.right.left;
			}
		}
		
		return true;
	}
	/**
	 * 清空二叉树
	 */
	public void clear(BTNode<T> root) {
		if(root==null) {
			return;
		}
		clear(root.left);
		clear(root.right);
		root.key = null;
		root.left = root.right = null;
		System.gc();
	}
	/**
	 * 前序遍历
	 * @param args
	 */
	public void preOrderTravel(BTNode<T> root) {
		if(root==null) {
			return;
		}
		System.out.print(root.key + " ");
		preOrderTravel(root.left);
		preOrderTravel(root.right);
	}
	/**
	 * 中序遍历
	 * @param args
	 */
	public void inOrderTravel(BTNode<T> root) {
		if(root==null) {
			return;
		};
		inOrderTravel(root.left);
		System.out.print(root.key + " ");
		inOrderTravel(root.right);
	}
	/**
	 * 后序遍历
	 * @param args
	 */
	public void postOrderTravel(BTNode<T> root) {
		if(root==null) {
			return;
		};
		inOrderTravel(root.left);
		inOrderTravel(root.right);
		System.out.print(root.key + " ");
	}
	public static void main(String[] args) {
		BinTree<Integer> bt = new BinTree<Integer>();
		bt.addNode(2);
		bt.addNode(1);
		bt.addNode(5);
		bt.addNode(5);
		bt.addNode(3);
		bt.addNode(7);
		bt.addNode(6);
		bt.deleteNode(1);
		bt.clear(bt.root);
		bt.preOrderTravel(bt.root);
		System.out.println();
		bt.inOrderTravel(bt.root);
		System.out.println();
		bt.postOrderTravel(bt.root);

	}

}