查找二叉树(插入、删除、查找)实现

public class SearchTree {
	private TreeNode root;

	public SearchTree() {
	}

	// 中序遍历（递归）
	public void midOrder(TreeNode node) {
		if (node == null) {
			return;
		}
		// 对该节点继续进行左右子节点的遍历
		// 先输出根节点，因为这是前序遍历，根左右
		midOrder(node.lchild);
		System.out.println("二叉树节点 : " + node.data);
		midOrder(node.rchild);
	}

	public TreeNode putTreeNode(int key) {
		TreeNode node = null;
		TreeNode parent = null;
		if (root == null) {
			node = new TreeNode(0, key);
			root = node;
		}
		// 如果根节点已经存在,就要开始判断了
		node = root;
		while (node != null) {
			parent = node;
			if (key > node.data) {
				// 获取右节点
				node = node.rchild;
			} else if (key < node.data) {
				// 获取左节点
				node = node.lchild;
			} else {
				// 相等的话，就啥也不做
				return node;
			}
		}
		// 如果跳出了循环，代表这个节点不存在，需要创建
		node = new TreeNode(0, key);
		// 找到此时node的父节点
		if (key > parent.data) {
			parent.rchild = node;
		} else if (key < parent.data) {
			parent.lchild = node;
		}
		node.parent = parent;
		return node;
	}

	// 删除节点
	public void deleteNode(int key) {
		TreeNode node = searchNode(key);
		if (node == null) {
			throw new RuntimeException("查找该节点不存在！！");
		}
		delete(node);
	}

	public void delete(TreeNode node) {
		if (node == null) {
			throw new RuntimeException("删除该节点不存在！！");
		}
		TreeNode parent = node.parent;
		// 要删除的节点无后代，直接删除
		if (node.lchild == null && node.rchild == null) {
			if (parent.lchild == node) {
				parent.lchild = null;
			} else if (parent.rchild == node) {
				parent.rchild = null;
			}
			return;
		}
		// 被删除节点有左无右
		if (node.lchild != null && node.rchild == null) {
			if (parent.lchild == node) {
				parent.lchild = node.lchild;
			} else if (parent.rchild == node) {
				parent.rchild = node.lchild;
			}
			return;
		}
		// 被删除节点有右无左
		if (node.lchild == null && node.rchild != null) {
			if (parent.rchild == node) {
				parent.rchild = node.rchild;
			} else if (parent.lchild == node) {
				parent.lchild = node.rchild;
			}
			return;
		}
		// 被删除节点左右孩子都有
		// 获取该节点的后继节点
		TreeNode next = getNextNode(node);// 45
		delete(next);
		node.data = next.data;
	}

	/**
	 * @param node
	 *            查找后继节点
	 * @return
	 */
	public TreeNode getNextNode(TreeNode node) {
		if (node == null) {
			return null;
		}
		if (node.rchild != null) {
			// 找某节点最小关键字节点(左树找最大)
			return getMinTreeNode(node.rchild);
		}
		return null;
	}

	private TreeNode getMinTreeNode(TreeNode node) {
		// 一直找左孩子
		if (node == null) {
			return null;
		}
		TreeNode parent = null;
		while (node != null) {
			parent = node;
			node = node.lchild;
		}
		return parent;
	}

	// 查找节点
	public TreeNode searchNode(int key) {
		if (root == null) {
			return null;
		}
		TreeNode node = root;
		while (node != null) {
			if (key > node.data) {
				node = node.rchild;
			} else if (key < node.data) {
				node = node.lchild;
			} else {
				return node;
			}
		}
		// 跳出了上面循环的话，就代表没有该节点。。。
		return null;
	}

	public class TreeNode {
		private int index;
		private int data;
		private TreeNode lchild;
		private TreeNode rchild;
		private TreeNode parent;

		public TreeNode(int index, int data) {
			this.index = index;
			this.data = data;
		}

	}

	public static void main(String[] args) {
		SearchTree searchTree = new SearchTree();
		int[] array = { 50, 30, 15, 45, 60, 55, 70, 58 };
		for (int data : array) {
			searchTree.putTreeNode(data);
		}
		searchTree.midOrder(searchTree.root);
		System.out.println("============");
		searchTree.deleteNode(60);
		searchTree.midOrder(searchTree.root);
	}
}