搜尋二叉樹（Binary Tree）java實現

 

package source.datastruct_algorithm;

import java.util.Stack;

class BaseObj{
public BaseObj(String key) {
this.key = key;
}
String key;
}
//節點
class Node<T extends BaseObj>{
 T obj;
Node<T> leftNode;
Node<T> rightNode;
public Node(T obj) {
this.obj = obj;
}
}
//二叉樹類
public class SearchTree<T extends BaseObj> {
private Node<T> root;
//根據執行的關鍵字尋找節點
public Node<T> find(String key){
Node<T> cur_node = root;
while(!key.equals(cur_node.obj.key)){
if(key.compareTo(cur_node.obj.key)<0){
cur_node = cur_node.leftNode;
}
else{
cur_node = cur_node.rightNode;
}
if(cur_node == null){
return null;
}
}
return cur_node;
}
//插入節點
public void insert(Node<T> newnode){
if(root == null)root = newnode;
else{
Node<T> cur_node = root;
Node<T> cur_parent;
while(true){
cur_parent = cur_node;

if(newnode.obj.key.compareTo(cur_node.obj.key)<0){
cur_node = cur_node.leftNode;
if(cur_node == null){
cur_parent.leftNode = newnode;
return;
}
}else{
cur_node = cur_node.rightNode;
if(cur_node == null){
cur_parent.rightNode = newnode;
return;
}
}
}
}
}
//中序遍曆
public void midOrder(Node<T> node){
if(node !=null){
midOrder(node.leftNode);
System.out.print(node.obj.key +" ");
midOrder(node.rightNode);
}
}
//前序走訪
public void preOrder(Node<T> node){
if(node !=null){
System.out.print(node.obj.key +" ");
preOrder(node.leftNode);
preOrder(node.rightNode);
}
}
//後續遍曆
public void nextOrder(Node<T> node){
if(node !=null){
nextOrder(node.leftNode);
nextOrder(node.rightNode);
System.out.print(node.obj.key +" ");
}
}
//取得關鍵字最小的節點
public Node<T> getMin(){
Node<T> cur_node,last_node = null;
cur_node = root;
while(cur_node !=null){
last_node = cur_node;
cur_node = cur_node.leftNode;
}
return last_node;
}
//取得關鍵字最大的節點
public Node<T> getMax(){
Node<T> cur_node,last_node = null;
cur_node = root;
while(cur_node !=null){
last_node = cur_node;
cur_node = cur_node.rightNode;
}
return last_node;
}
//根據關鍵字刪除節點
public boolean delede(String key){
Node<T> cur_node,parent_node = null;
boolean isleft = true;
cur_node = root;
//find the node need to del
while(!key.equals(cur_node.obj.key)){
parent_node = cur_node;
if(key.compareTo(cur_node.obj.key) >0){
isleft = true;
cur_node = cur_node.leftNode;
}
else{
isleft = false;
cur_node = cur_node.rightNode;
}
if(cur_node == null){
return false;
}
}
//execute del if don't have childnode
if(cur_node.leftNode == null && cur_node.rightNode == null){
if(cur_node == root){
root = null;
}
else if(isleft){
parent_node.leftNode = null;
}else{
parent_node.rightNode = null;
}
}else if(cur_node.leftNode == null){
if(cur_node == root){
root = cur_node.rightNode;
}else if(isleft){
parent_node.leftNode = cur_node.rightNode;
}else{
parent_node.rightNode = cur_node.rightNode;
}
}else if(cur_node.rightNode == null){
if(cur_node == root){
root = cur_node.leftNode;
}else if(isleft){
parent_node.leftNode = cur_node.leftNode;
}else{
parent_node.rightNode = cur_node.leftNode;
}
}else{
Node<T> insteadNode = getInsteadNode(cur_node);
if(cur_node.obj.key.equals(root.obj.key)){
root = insteadNode;
}
else if(isleft){
parent_node.leftNode = insteadNode;
}else{
parent_node.rightNode = insteadNode;
}
insteadNode.leftNode = cur_node.leftNode;
}
return true;

}

//尋找科技補充的後繼節點
private Node<T> getInsteadNode(Node<T> delNode){
Node<T> instead_parent = null,instead = null,cur_node = delNode.rightNode;
while(cur_node!=null){
instead_parent = instead;
instead = cur_node;
cur_node = cur_node.leftNode;
}

if(instead!=delNode.rightNode){
instead_parent.leftNode = instead.rightNode;
instead.rightNode = delNode.rightNode;
}
return instead;
}
//以樹形顯示整個樹
public void display(){
Stack<Node<T>> globalstack = new Stack<Node<T>>();
globalstack.push(root);
int nblanks =32;
boolean isEmpty = false;
while(isEmpty == false){
Stack<Node<T>> localStack = new Stack<Node<T>>();
isEmpty = true;
for(int j=0;j<nblanks;j++){
System.out.println(" ");
}
while(globalstack.isEmpty() == false){
Node<T> node = globalstack.pop();
if(node !=null){
System.out.print(node.obj.key);
localStack.push(node.leftNode);
localStack.push(node.rightNode);
if(node.leftNode != null || node.rightNode != null){
isEmpty = false;
}
}else{
System.out.print("-");
localStack.push(null);
localStack.push(null);
}
for(int i=0;i<nblanks*2+2;i++){
System.out.print(" ");
}
}
System.out.println();
nblanks/=2;
while(localStack.isEmpty()==false){
globalstack.push(localStack.pop());
}

}

}
public static void main(String[] args){
SearchTree<BaseObj> tree = new SearchTree<BaseObj>();
Node<BaseObj> nodeone = new Node<BaseObj>(new BaseObj("a"));
Node<BaseObj> nodeone1 = new Node<BaseObj>(new BaseObj("z"));
Node<BaseObj> nodeone2 = new Node<BaseObj>(new BaseObj("g"));
Node<BaseObj> nodeone3 = new Node<BaseObj>(new BaseObj("f"));
Node<BaseObj> nodeone4 = new Node<BaseObj>(new BaseObj("q"));
Node<BaseObj> nodeone5 = new Node<BaseObj>(new BaseObj("h"));
Node<BaseObj> nodeone6 = new Node<BaseObj>(new BaseObj("m"));
Node<BaseObj> nodeone7 = new Node<BaseObj>(new BaseObj("b"));
Node<BaseObj> nodeone8 = new Node<BaseObj>(new BaseObj("j"));
Node<BaseObj> nodeone9 = new Node<BaseObj>(new BaseObj("l"));
Node<BaseObj> nodeone10 = new Node<BaseObj>(new BaseObj("c"));

Node<BaseObj> nodeone11 = new Node<BaseObj>(new BaseObj("A"));
Node<BaseObj> nodeone12 = new Node<BaseObj>(new BaseObj("H"));
Node<BaseObj> nodeone13 = new Node<BaseObj>(new BaseObj("f"));
Node<BaseObj> nodeone14 = new Node<BaseObj>(new BaseObj("u"));
Node<BaseObj> nodeone15 = new Node<BaseObj>(new BaseObj("x"));
Node<BaseObj> nodeone16 = new Node<BaseObj>(new BaseObj("w"));
Node<BaseObj> nodeone17 = new Node<BaseObj>(new BaseObj("s"));
Node<BaseObj> nodeone18 = new Node<BaseObj>(new BaseObj("i"));
Node<BaseObj> nodeone19 = new Node<BaseObj>(new BaseObj("k"));
tree.insert(nodeone);
tree.insert(nodeone2);

tree.insert(nodeone14);
tree.insert(nodeone15);
tree.insert(nodeone16);
tree.insert(nodeone17);

tree.insert(nodeone3);
tree.insert(nodeone4);
tree.insert(nodeone11);
tree.insert(nodeone12);
tree.insert(nodeone13);
tree.insert(nodeone5);
tree.insert(nodeone6);
tree.insert(nodeone7);
tree.insert(nodeone8);
tree.insert(nodeone9);
tree.insert(nodeone10);
tree.insert(nodeone19);
tree.insert(nodeone18);
tree.insert(nodeone1);
tree.display();

tree.delede("a");
tree.midOrder(tree.root);

}
}

二叉樹在資料結構中兼顧了有序數組的尋找效率和列表中插入刪除效率。是一個不錯的選擇.該二叉樹為非平衡二叉樹實現。下次繼續平衡二叉樹實現。

轉載：http://blog.csdn.net/maomaolingyu/archive/2010/11/18/6018710.aspx