二叉排序树 java_二叉查找树的Java实现

转自：http://blog.csdn.net/lovesqcc/article/details/6246615

为了克服对树结构编程的恐惧感，决心自己实现一遍二叉查找树，以便掌握关于树结构编程的一些技巧和方法。以下是基本思路：

[1] 关于容器与封装。封装，是一种非常重要的系统设计思想；无论是面向过程的函数，还是面向对象的对象，都是实现抽象和封装的技术手段。要使系统更加安全更具可维护性，就应当将封装思想谨记心中。容器是封装思想的绝好示例。用户对容器的印象应该简洁地表达为：A. 可以存入指定的东西； B. 可以取出所期望的东西。 而至于这容器中究竟有什么机关，藏的是毒蛇还是黄金，都是对用户不可见的。二叉查找树就是这样一个容器。面向对象编程中，为实现树结构，自然要对树结点对象进行建模。这里采用了内部类；外部类对二叉查找树进行建模，而树结点作为内部类实现。

[2] 本程序尽量实现一个比较实用的二叉查找树，其中包括动态的插入、删除操作；查询给定关键字、最小关键字、最大关键字；获取二叉树的有序列表(用于排序)等。因为我希望以后还能用到这个容器的，而不仅仅是编程练习。二叉查找树操作的大部分算法参考了《算法导论2》第12章内容，删除操作略显笨拙。程序中有错误之处，欢迎指出。

[3]  程序如下：

/**

* @author shuqin1984  2011-3-13

*

* 此程序实现一个二叉查找树的功能，可以进行动态插入、删除关键字；

* 查询给定关键字、最小关键字、最大关键字；转换为有序列表(用于排序)

*

*

*/

package datastructure.tree;

import java.util.ArrayList;

import java.util.List;

publicclassBinarySearchTree {

// 树的根结点

privateTreeNode root =null;

// 遍历结点列表

privateList nodelist =newArrayList();

privateclassTreeNode {

privateintkey;

privateTreeNode leftChild;

privateTreeNode rightChild;

privateTreeNode parent;

publicTreeNode(intkey, TreeNode leftChild, TreeNode rightChild, TreeNode parent) {

this.key = key;

this.leftChild = leftChild;

this.rightChild = rightChild;

this.parent = parent;

}

publicintgetKey() {

returnkey;

}

publicString toString()

{

String leftkey = (leftChild == null?"": String.valueOf(leftChild.key));

String rightkey = (rightChild == null?"": String.valueOf(rightChild.key));

return"("+ leftkey +" , "+ key +" , "+ rightkey +")";

}

}

/**

* isEmpty: 判断二叉查找树是否为空；若为空，返回 true ，否则返回 false .

*

*/

publicboolean isEmpty()

{

if(root ==null) {

returntrue;

} else{

returnfalse;

}

}

/**

* TreeEmpty: 对于某些二叉查找树操作(比如删除关键字)来说，若树为空，则抛出异常。

*/

publicvoidTreeEmpty() throws Exception

{

if(isEmpty()) {

thrownewException("树为空!");

}

}

/**

* search: 在二叉查找树中查询给定关键字

* @param key 给定关键字

* @return 匹配给定关键字的树结点

*/

publicTreeNode search(intkey)

{

TreeNode pNode = root;

while(pNode !=null&& pNode.key != key) {

if(key 

pNode = pNode.leftChild;

}

else{

pNode = pNode.rightChild;

}

}

returnpNode;

}

/**

* minElemNode: 获取二叉查找树中的最小关键字结点

* @return 二叉查找树的最小关键字结点

* @throws Exception 若树为空，则抛出异常

*/

publicTreeNode minElemNode(TreeNode node) throws Exception

{

if(node ==null) {

thrownewException("树为空！");

}

TreeNode pNode = node;

while(pNode.leftChild !=null) {

pNode = pNode.leftChild;

}

returnpNode;

}

/**

* maxElemNode: 获取二叉查找树中的最大关键字结点

* @return 二叉查找树的最大关键字结点

* @throws Exception 若树为空，则抛出异常

*/

publicTreeNode maxElemNode(TreeNode node) throws Exception

{

if(node ==null) {

thrownewException("树为空！");

}

TreeNode pNode = node;

while(pNode.rightChild !=null) {

pNode = pNode.rightChild;

}

returnpNode;

}

/**

* successor: 获取给定结点在中序遍历顺序下的后继结点

* @param node 给定树中的结点

* @return 若该结点存在中序遍历顺序下的后继结点，则返回其后继结点；否则返回 null

* @throws Exception

*/

publicTreeNode successor(TreeNode node) throws Exception

{

if(node ==null) {

returnnull;

}

// 若该结点的右子树不为空，则其后继结点就是右子树中的最小关键字结点

if(node.rightChild !=null) {

returnminElemNode(node.rightChild);

}

// 若该结点右子树为空

TreeNode parentNode = node.parent;

while(parentNode !=null&& node == parentNode.rightChild) {

node = parentNode;

parentNode = parentNode.parent;

}

returnparentNode;

}

/**

* precessor: 获取给定结点在中序遍历顺序下的前趋结点

* @param node 给定树中的结点

* @return 若该结点存在中序遍历顺序下的前趋结点，则返回其前趋结点；否则返回 null

* @throws Exception

*/

publicTreeNode precessor(TreeNode node) throws Exception

{

if(node ==null) {

returnnull;

}

// 若该结点的左子树不为空，则其前趋结点就是左子树中的最大关键字结点

if(node.leftChild !=null) {

returnmaxElemNode(node.leftChild);

}

// 若该结点左子树为空

TreeNode parentNode = node.parent;

while(parentNode !=null&& node == parentNode.leftChild) {

node = parentNode;

parentNode = parentNode.parent;

}

returnparentNode;

}

/**

* insert: 将给定关键字插入到二叉查找树中

* @param key 给定关键字

*/

publicvoidinsert(intkey)

{

TreeNode parentNode = null;

TreeNode newNode = newTreeNode(key,null,null,null);

TreeNode pNode = root;

if(root ==null) {

root = newNode;

return;

}

while(pNode !=null) {

parentNode = pNode;

if(key 

pNode = pNode.leftChild;

}

elseif(key > pNode.key) {

pNode = pNode.rightChild;

} else{

// 树中已存在匹配给定关键字的结点，则什么都不做直接返回

return;

}

}

if(key 

parentNode.leftChild = newNode;

newNode.parent = parentNode;

}

else{

parentNode.rightChild = newNode;

newNode.parent = parentNode;

}

}

/**

* insert: 从二叉查找树中删除匹配给定关键字相应的树结点

* @param key 给定关键字

*/

publicvoiddelete(intkey) throws Exception

{

TreeNode pNode = search(key);

if(pNode ==null) {

thrownewException("树中不存在要删除的关键字!");

}

delete(pNode);

}

/**

* delete: 从二叉查找树中删除给定的结点.

* @param pNode 要删除的结点

*

* 前置条件： 给定结点在二叉查找树中已经存在

* @throws Exception

*/

privatevoiddelete(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;

}

return;

}

if(pNode.leftChild ==null&& pNode.rightChild !=null) {// 该结点左孩子结点为空，右孩子结点非空

TreeNode parentNode = pNode.parent;

if(pNode == parentNode.leftChild) {

parentNode.leftChild = pNode.rightChild;

pNode.rightChild.parent = parentNode;

}

else{

parentNode.rightChild = pNode.rightChild;

pNode.rightChild.parent = parentNode;

}

return;

}

if(pNode.leftChild !=null&& pNode.rightChild ==null) {// 该结点左孩子结点非空，右孩子结点为空

TreeNode parentNode = pNode.parent;

if(pNode == parentNode.leftChild) {

parentNode.leftChild = pNode.leftChild;

pNode.rightChild.parent = parentNode;

}

else{

parentNode.rightChild = pNode.leftChild;

pNode.rightChild.parent = parentNode;

}

return;

}

// 该结点左右孩子结点均非空，则删除该结点的后继结点，并用该后继结点取代该结点

TreeNode successorNode = successor(pNode);

delete(successorNode);

pNode.key = successorNode.key;

}

/**

* inOrderTraverseList: 获得二叉查找树的中序遍历结点列表

* @return 二叉查找树的中序遍历结点列表

*/

publicList inOrderTraverseList()

{

if(nodelist !=null) {

nodelist.clear();

}

inOrderTraverse(root);

returnnodelist;

}

/**

* inOrderTraverse: 对给定二叉查找树进行中序遍历

* @param root 给定二叉查找树的根结点

*/

privatevoidinOrderTraverse(TreeNode root)

{

if(root !=null) {

inOrderTraverse(root.leftChild);

nodelist.add(root);

inOrderTraverse(root.rightChild);

}

}

/**

* toStringOfOrderList: 获取二叉查找树中关键字的有序列表

* @return 二叉查找树中关键字的有序列表

*/

publicString toStringOfOrderList()

{

StringBuilder sbBuilder = newStringBuilder(" [ ");

for(TreeNode p: inOrderTraverseList()) {

sbBuilder.append(p.key);

sbBuilder.append(" ");

}

sbBuilder.append("]");

returnsbBuilder.toString();

}

/**

* 获取该二叉查找树的字符串表示

*/

publicString toString()

{

StringBuilder sbBuilder = newStringBuilder(" [ ");

for(TreeNode p: inOrderTraverseList()) {

sbBuilder.append(p);

sbBuilder.append(" ");

}

sbBuilder.append("]");

returnsbBuilder.toString();

}

publicTreeNode getRoot() {

returnroot;

}

publicstaticvoidtestNode(BinarySearchTree bst, TreeNode pNode) throws Exception {

System.out.println("本结点: "+ pNode);

System.out.println("前趋结点: "+ bst.precessor(pNode));

System.out.println("后继结点: "+ bst.successor(pNode));

}

publicstaticvoidtestTraverse(BinarySearchTree bst) {

System.out.println("二叉树遍历："+ bst);

System.out.println("二叉查找树转换为有序列表: "+ bst.toStringOfOrderList());

}

publicstaticvoidmain(String[] args)

{

try{

BinarySearchTree bst = newBinarySearchTree();

System.out.println("查找树是否为空？ "+ (bst.isEmpty() ?"是":"否"));

int[] keys =newint[] {15, 6, 18, 3, 7, 13, 20, 2, 9, 4};

for(intkey: 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);

System.out.println("****************************** ");

System.out.println("查找 7 : "+ (bst.search(7) !=null?"查找成功!":"查找失败，不存在该关键字!"));

bst.delete(7);

System.out.println("查找 7 : "+ (bst.search(7) !=null?"查找成功!":"查找失败，不存在该关键字!"));

System.out.println("查找 12 : "+ (bst.search(12) !=null?"查找成功!":"查找失败，不存在该关键字!"));

bst.insert(12);

System.out.println("查找 12 : "+ (bst.search(12) !=null?"查找成功!":"查找失败，不存在该关键字!"));

testTraverse(bst);

System.out.println("****************************** ");

bst.insert(16);

bst.delete(6);

bst.delete(4);

testTraverse(bst);

} catch(Exception e) {

System.out.println(e.getMessage());

e.printStackTrace();

}

}

}