二叉查找（排序）树的分析与实现

package com.wxisme.binarysearchtree;

import java.util.Scanner;
/**
 * 二叉查找（排序）树的实现
 * @time 2015/8/16 12:02
 * @author wxisme
 * @param <T>
 */
public class BinarySearchTree<T extends Comparable> {
	
	private class TreeNode {
		private T data;
		private TreeNode left;
		private TreeNode right;
		private TreeNode parent;
		
		public TreeNode() {}
		
		public TreeNode(T data) {
			this.data = data;
			this.left = null;
			this.right = null;
			this.parent = null;
		}
		
	}
	
	private TreeNode root;
	private int nodeCount;
	private int depth;
	public BinarySearchTree() {}
	
	public BinarySearchTree(T data) {
		root = new TreeNode(data);
	}
	/**
	 * 添加元素
	 * @param data
	 */
	public void add(T data) {
		TreeNode node = new TreeNode(data);
		if(root == null) {
			root = node;
		}
		else {
			addSearch(node, root);
		}
		nodeCount ++;
	}
	
	public void addSearch(TreeNode node, TreeNode root) {
		if(node.data.compareTo(root.data)<=0) {
			if(root.left == null) {
				root.left = node;
				node.parent = root;
				return;
			}
			else {
				addSearch(node, root.left);
			}
		}
		else {
			if(root.right == null) {
				root.right = node;
				node.parent = root;
				return;
			}
			else {
				addSearch(node, root.right);
			}
		}
	}
	/**
	 * 查找节点
	 * @param data
	 * @return
	 */
	public TreeNode search(T data) {
		TreeNode it = root;
		if(it == null) {
			System.out.println("树为空！");
			return null;
		}
		else {
			while(it != null) {
				if(data.compareTo(it.data)<0) {
					it = it.left;
				}
				else if(data.compareTo(it.data)>0) {
					it =it.right;
				}
				else {
					return it;
				}
				
			}
		}
		return null;
	}
	/**
	 * 删除元素
	 * @param data
	 */
	public void remove(T data) {
		TreeNode node = search(data);
		if(node == null) {
			System.out.println("不存在此节点！");
			return ;
		}
		//左右子树均为空
		if(node.left==null && node.right==null) {
			if(root == node) {
				root = null;
			}
			else {
				if(node == node.parent.left) {
					node.parent.left = null;
				}
				else {
					node.parent.right = null;
				}
				node.parent = null;
			}
		}
		//左子树不为空，右子树为空
		else if(node.left!=null && node.right==null) {
			if(root == node) {
				root = node.left;
				root.parent = null;
			}
			else {
				if(node == node.parent.left) {
					node.parent.left = node.left;
					node.left.parent = node.parent;
					node.left = null;
					node.parent = null;
				}
				else {
					node.parent.right = node.left;
					node.left.parent = node.parent;
					node.left = null;
					node.parent = null;
				}
			}
		}
		//右子树不为空，左子树为空
		else if(node.left==null && node.right!=null) {
			if(root == node) {
				root = node.right;
				root.parent = null;
			}
			else {
				if(node == node.parent.left) {
					node.parent.left = node.right;
					node.right.parent = node.parent;
					node.right = null;
					node.parent = null;
				}
				else {
					node.parent.right = node.right;
					node.right.parent = node.parent;
					node.right = null;
					node.parent = null;
				}
			}
		}
		//左右子树均不为空
		else {
			//左子树中值最大的节点
			TreeNode leftMaxNode = node.left;
			while(leftMaxNode.right != null) {
				leftMaxNode = leftMaxNode.right;
			}
			//将左子树中值最大的节点移到要删除的节点的位置上来。
			leftMaxNode.parent.right = null;
			leftMaxNode.parent = node.parent;
			if(node == node.parent.left) {
				node.parent.left = leftMaxNode;
			}
			else {
				node.parent.right = leftMaxNode;
			}
			leftMaxNode.left = node.left;
			leftMaxNode.right = node.right;
			//释放要删除的节点的引用
			node.parent = node.left = node.right = null;
		}
		nodeCount --;
	}
	/**
	 * 节点的个数
	 * @return
	 */
	public int size() {
		return nodeCount;
	}
	/**
	 * 销毁树
	 */
	public void destroy() {
		root = null;
		nodeCount = 0;
	}
	/**
	 * 中序遍历树
	 */
	public void traversal() {
		System.out.print("中序遍历：");
		inOrderTraversal(root);
		System.out.println();
	}
	public void inOrderTraversal(TreeNode root) {
		if(root == null) {
			return ;
		}
		inOrderTraversal(root.left);
		System.out.print(root.data);
		inOrderTraversal(root.right);
	}
	/**
	 * 测试
	 * @param args
	 */
	public static void main(String[] args) {
		BinarySearchTree<Integer> tree = new BinarySearchTree<Integer>();
		Scanner scan = new Scanner(System.in);
		for(int i=0; i<10; i++) {
			tree.add(scan.nextInt());
		}
		tree.traversal();
		System.out.print("删除节点：");
		tree.remove(scan.nextInt());
		tree.traversal();
		System.out.println("节点的个数：" + tree.size());
		System.out.println("销毁树");
		tree.destroy();
		System.out.println("节点的个数：" + tree.size()); 
	}
}