二叉排序树的增删改操作(修改删除)

树节点

public class BinaryTreeNode {
	String name, value;
	BinaryTreeNode parent, right, left;

	public BinaryTreeNode(BinaryTreeNode parent, BinaryTreeNode right,
			BinaryTreeNode left, String name, String value) {
		this.parent = parent;
		this.right = right;
		this.left = left;
		this.name = name;
		this.value = value;
	}
}

操作树

import java.util.ArrayList;
import java.util.List;

public class BinaryTree {
	private BinaryTreeNode root;

	public List<String> res = new ArrayList<String>();

	public void add(StudentBean bean) {
		root = insert(bean, root, null);
	}

	public void remove(StudentBean bean) {
		BinaryTreeNode node = getNode(bean, root);
		if (node == null) {
			return;
		}
		// 左右子树为空
		if (node.left == null && node.right == null) {
			if (node == root) {
				root = null;
			} else {
				if (node.parent.left == node) {
					node.parent.left = null;
				} else {
					node.parent.right = null;
				}
			}
		} else if (node.left == null && node.right != null) {
			if (node == root) {
				root = node.right;
			} else {
				if (node.parent.left == node) {
					node.parent.left = node.right;
				} else {
					node.parent.right = node.right;
				}
			}
		} else if (node.left != null && node.right == null) {
			if (node == root) {
				root = node.left;
			} else {
				if (node.parent.left == node) {
					node.parent.left = node.left;
				} else {
					node.parent.right = node.left;
				}
			}
		} else {
			BinaryTreeNode leftMaxNode = node.left;
			while (leftMaxNode.right != null) {
				leftMaxNode = leftMaxNode.right;
			}
			leftMaxNode.parent.right = null;
			leftMaxNode.parent = node.parent;
			if (node.parent.left == node) {
				node.parent.left = leftMaxNode;
			} else {
				node.parent.right = leftMaxNode;
			}
			leftMaxNode.left = node.left;
			leftMaxNode.right = node.right;
		}
		node = null;
	}

	public void update(StudentBean bean) {
		BinaryTreeNode node = getNode(bean, root);
		if (node != null) {
			node.value = bean.getsClass();
		}
	}

	public List<String> printTree() {
		res.clear();
		inOrder(root);
		return res;
	}

	private BinaryTreeNode inOrder(BinaryTreeNode node) {
		if (node != null) {
			inOrder(node.left);
			// System.out.println("name=" + node.name + ", class=" +
			// node.value);
			res.add("name=" + node.name + ", class=" + node.value);
			inOrder(node.right);
		}
		return node;
	}

	private BinaryTreeNode insert(StudentBean bean, BinaryTreeNode node,
			BinaryTreeNode parent) {
		if (node == null) {
			node = new BinaryTreeNode(parent, null, null, bean.getsName(),
					bean.getsClass());
		} else {
			int greater = bean.getsName().compareTo(node.name);
			if (greater < 0) {
				node.left = insert(bean, node.left, node);
			} else if (greater > 0) {
				node.right = insert(bean, node.right, node);
			}
		}
		return node;
	}

	private BinaryTreeNode getNode(StudentBean bean, BinaryTreeNode tree) {
		BinaryTreeNode node = tree;
		while (node != null) {
			int greater = bean.getsName().compareTo(node.name);
			if (greater < 0) {
				node = node.left;
			} else if (greater > 0) {
				node = node.right;
			} else {
				return node;
			}
		}
		return null;
	}

}