二叉查找树（Binary Search Tree），或者是一颗空树，或者是具有下列性质的二叉树：
1、若它的左子树不空，则其左子树上的所有结点的值均小于它根结点的值；
2、若它的右子树不空，则其右子树上的所有结点的值均大于它根结点的值；
3、它的左、右子树也分别为二叉查找树。
实现代码如下：重点是理解插入和删除后树的重新调整
package cn.hm;
/**
* @author fjssharpsword 2016-7-20
* 实现一个二叉查找树的功能，可以进行动态插入、删除关键字；
* 查询给定关键字、最小关键字、最大关键字；转换为有序列表(用于排序)
*/
import java.util.ArrayList;
import java.util.List;
public class BinarySearchTree {
// 树的根结点
private TreeNode root = null;
// 遍历结点列表
private List<TreeNode> nodelist = new ArrayList<TreeNode>();
//定义树结构
private class TreeNode {
private int key;
private TreeNode leftChild;
private TreeNode rightChild;
private TreeNode parent;
public TreeNode(int key, TreeNode leftChild, TreeNode rightChild, TreeNode parent) {
this.key = key;
this.leftChild = leftChild;
this.rightChild = rightChild;
this.parent = parent;
}
public int getKey() {
return key;
}
public String toString() {
String leftkey = (leftChild == null ? "" : String.valueOf(leftChild.key));
String rightkey = (rightChild == null ? "" : String .valueOf(rightChild.key));
return "(" + leftkey + " , " + key + " , " + rightkey + ")";
}
}
/**
* isEmpty: 判断二叉查找树是否为空；若为空，返回 true ，否则返回 false .
*
*/
public boolean isEmpty() {
if (root == null) {
return true;
} else {
return false;
}
}
/**
* TreeEmpty: 对于某些二叉查找树操作(比如删除关键字)来说，若树为空，则抛出异常。
*/
public void TreeEmpty() throws Exception {
if (isEmpty()) {
throw new Exception("树为空!");
}
}
/**
* search: 在二叉查找树中查询给定关键字
*
* @param key 给定关键字
* @return 匹配给定关键字的树结点
*/
public TreeNode search(int key) {
TreeNode pNode = root;
while (pNode != null && pNode.key != key) {
if (key < pNode.key) {
pNode = pNode.leftChild;
} else {
pNode = pNode.rightChild;
}
}
return pNode;
}
/**
* minElemNode: 获取二叉查找树中的最小关键字结点
*
* @return 二叉查找树的最小关键字结点 ，一直向左
* @throws Exception 若树为空，则抛出异常
*/
public TreeNode minElemNode(TreeNode node) throws Exception {
if (node == null) {
throw new Exception("树为空！");
}
TreeNode pNode = node;
while (pNode.leftChild != null) {
pNode = pNode.leftChild;
}
return pNode;
}
/**
* maxElemNode: 获取二叉查找树中的最大关键字结点
*
* @return 二叉查找树的最大关键字结点 ，一直向右
* @throws Exception 若树为空，则抛出异常
*/
public TreeNode maxElemNode(TreeNode node) throws Exception {
if (node == null) {
throw new Exception("树为空！");
}
TreeNode pNode = node;
while (pNode.rightChild != null) {
pNode = pNode.rightChild;
}
return pNode;
}
/**
* successor: 获取给定结点在中序遍历顺序下的后继结点
* @param node 给定树中的结点
* @return 若该结点存在中序遍历顺序下的后继结点，则返回其后继结点；否则返回 null
* @throws Exception
*/
public TreeNode successor(TreeNode node) throws Exception {
if (node == null) {
return null;
}
// 若该结点的右子树不为空，则其后继结点就是右子树中的最小关键字结点
if (node.rightChild != null) {
return minElemNode(node.rightChild);
}
// 若该结点右子树为空
TreeNode parentNode = node.parent;
while (parentNode != null && node == parentNode.rightChild) {
node = parentNode;
parentNode = parentNode.parent;
}
return parentNode;
}
/**
* precessor: 获取给定结点在中序遍历顺序下的前趋结点
* @param node 给定树中的结点
* @return 若该结点存在中序遍历顺序下的前趋结点，则返回其前趋结点；否则返回 null
* @throws Exception
*/
public TreeNode precessor(TreeNode node) throws Exception {
if (node == null) {
return null;
}
// 若该结点的左子树不为空，则其前趋结点就是左子树中的最大关键字结点
if (node.leftChild != null) {
return maxElemNode(node.leftChild);
}
// 若该结点左子树为空
TreeNode parentNode = node.parent;
while (parentNode != null && node == parentNode.leftChild) {
node = parentNode;
parentNode = parentNode.parent;
}
return parentNode;
}
/**
* insert: 将给定关键字插入到二叉查找树中
* 插入后要调整二叉查找树左小右大结构
* @param key 给定关键字
*/
public void insert(int key) {
TreeNode parentNode = null;
TreeNode newNode = new TreeNode(key, null, null, null);
TreeNode pNode = root;
if (root == null) {
root = newNode;
return;
}
while (pNode != null) {
parentNode = pNode;
if (key < pNode.key) {
pNode = pNode.leftChild;
} else if (key > pNode.key) {
pNode = pNode.rightChild;
} else {
// 树中已存在匹配给定关键字的结点，则什么都不做直接返回
return;
}
}
if (key < parentNode.key) {
parentNode.leftChild = newNode;
newNode.parent = parentNode;
} else {
parentNode.rightChild = newNode;
newNode.parent = parentNode;
}
}
/**
* delete: 从二叉查找树中删除匹配给定关键字相应的树结点
*
* @param key 给定关键字
*/
public void delete(int key) throws Exception {
TreeNode pNode = search(key);
if (pNode == null) {
throw new Exception("树中不存在要删除的关键字!");
}
delete(pNode);
}
/**
* delete: 从二叉查找树中删除给定的结点.
*
* @param pNode 要删除的结点 前置条件： 给定结点在二叉查找树中已经存在
* 删除后要调整二叉查找树，满足左小右大结构
* @throws Exception
*/
private void delete(TreeNode pNode) throws Exception {
if (pNode == null) {
return;
}
if (pNode.leftChild == null && pNode.rightChild == null) { // 该结点既无左孩子结点，也无右孩子结点
TreeNode parentNode = pNode.parent;
if (pNode == parentNode.leftChild) {
parentNode.leftChild = null;
} else {
parentNode.rightChild = null;
}
pNode=null;
return;
}
if (pNode.leftChild == null && pNode.rightChild != null) { // 该结点左孩子结点为空，右孩子结点非空
TreeNode parentNode = pNode.parent;
TreeNode rightNode=pNode.rightChild;
if (pNode == parentNode.leftChild) {
rightNode.parent = parentNode;
parentNode.leftChild = rightNode;
} else {
rightNode.parent = parentNode;
parentNode.rightChild = rightNode;
}
pNode=null;
return;
}
if (pNode.leftChild != null && pNode.rightChild == null) { // 该结点左孩子结点非空，右孩子结点为空
TreeNode parentNode = pNode.parent;
TreeNode leftNode=pNode.leftChild;
if (pNode == parentNode.leftChild) {
leftNode.parent = parentNode;
parentNode.leftChild = leftNode;
} else {
leftNode.parent = parentNode;
parentNode.rightChild = leftNode;
}
pNode=null;
return;
}
if(pNode.leftChild != null && pNode.rightChild != null){// 该结点左右孩子结点均非空
TreeNode successorNode = successor(pNode);
pNode.key = successorNode.key;
delete(successorNode);
}
}
/**
* inOrderTraverseList: 获得二叉查找树的中序遍历结点列表
*
* @return 二叉查找树的中序遍历结点列表
*/
public List<TreeNode> inOrderTraverseList() {
if (nodelist != null) {
nodelist.clear();
}
inOrderTraverse(root);
return nodelist;
}
/**
* inOrderTraverse: 对给定二叉查找树进行中序遍历
*
* @param root 给定二叉查找树的根结点
*/
private void inOrderTraverse(TreeNode root) {
if (root != null) {
inOrderTraverse(root.leftChild);
nodelist.add(root);
inOrderTraverse(root.rightChild);
}
}
/**
* toStringOfOrderList: 获取二叉查找树中关键字的有序列表
*
* @return 二叉查找树中关键字的有序列表
*/
public String toStringOfOrderList() {
StringBuilder sbBuilder = new StringBuilder(" [ ");
for (TreeNode p : inOrderTraverseList()) {
sbBuilder.append(p.key);
sbBuilder.append(" ");
}
sbBuilder.append("]");
return sbBuilder.toString();
}
/**
* 获取该二叉查找树的字符串表示
*/
public String toString() {
StringBuilder sbBuilder = new StringBuilder(" [ ");
for (TreeNode p : inOrderTraverseList()) {
sbBuilder.append(p.toString());
sbBuilder.append(" ");
}
sbBuilder.append("]");
return sbBuilder.toString();
}
public TreeNode getRoot() {
return root;
}
public static void testNode(BinarySearchTree bst, TreeNode pNode) throws Exception {
System.out.println("本结点: " + pNode);
System.out.println("前趋结点: " + bst.precessor(pNode));
System.out.println("后继结点: " + bst.successor(pNode));
}
public static void testTraverse(BinarySearchTree bst) {
System.out.println("二叉树遍历：" + bst.toString());
System.out.println("二叉查找树转换为有序列表: " + bst.toStringOfOrderList());
}
public static void main(String[] args) {
try {
BinarySearchTree bst = new BinarySearchTree();
//插入
System.out.println("查找树是否为空？ " + (bst.isEmpty() ? "是" : "否"));
int[] keys = new int[] { 52,18,69,32,10,2,7,72,86,98,100,5,1020,789,13,15 };
for (int key : keys) {
bst.insert(key);
}
System.out.println("查找树是否为空？ " + (bst.isEmpty() ? "是" : "否"));
//找最小结点
TreeNode minkeyNode = bst.minElemNode(bst.getRoot());
System.out.println("最小关键字： " + minkeyNode.getKey());
testNode(bst, minkeyNode);
//找最大结点
TreeNode maxKeyNode = bst.maxElemNode(bst.getRoot());
System.out.println("最大关键字： " + maxKeyNode.getKey());
testNode(bst, maxKeyNode);
//根结点
System.out.println("根结点关键字： " + bst.getRoot().getKey());
testNode(bst, bst.getRoot());
//遍历二叉树
testTraverse(bst);
//删除一个结点
bst.delete(100);
testTraverse(bst);
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
}
} 执行结果如下：
查找树是否为空？ 是
查找树是否为空？ 否
最小关键字： 2
本结点: ( , 2 , 7)
前趋结点: null
后继结点: ( , 5 , )
最大关键字： 1020
本结点: (789 , 1020 , )
前趋结点: ( , 789 , )
后继结点: null
根结点关键字： 52
本结点: (18 , 52 , 69)
前趋结点: ( , 32 , )
后继结点: ( , 69 , 72)
二叉树遍历： [ ( , 2 , 7) ( , 5 , ) (5 , 7 , ) (2 , 10 , 13) ( , 13 , 15) ( , 15 , ) (10 , 18 , 32) ( , 32 , ) (18 , 52 , 69) ( , 69 , 72) ( , 72 , 86) ( , 86 , 98) ( , 98 , 100) ( , 100 , 1020) ( , 789 , ) (789 , 1020 , ) ]
二叉查找树转换为有序列表: [ 2 5 7 10 13 15 18 32 52 69 72 86 98 100 789 1020 ]
二叉树遍历： [ ( , 2 , 7) ( , 5 , ) (5 , 7 , ) (2 , 10 , 13) ( , 13 , 15) ( , 15 , ) (10 , 18 , 32) ( , 32 , ) (18 , 52 , 69) ( , 69 , 72) ( , 72 , 86) ( , 86 , 98) ( , 98 , 1020) ( , 789 , ) (789 , 1020 , ) ]
二叉查找树转换为有序列表: [ 2 5 7 10 13 15 18 32 52 69 72 86 98 789 1020 ]