二叉树基本操作—Java实现

package muyanmoyang.data.BTree;

/**
* 二叉树的节点
* @author hadoop
*
*/
class BtNode {
String data ;
BtNode lchild ;
BtNode rchild ;
public BtNode(String data, BtNode lchild, BtNode rchild) {
super();
this.data = data;
this.lchild = lchild;
this.rchild = rchild;
}
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
public BtNode getLchild() {
return lchild;
}
public void setLchild(BtNode lchild) {
this.lchild = lchild;
}
public BtNode getRchild() {
return rchild;
}
public void setRchild(BtNode rchild) {
this.rchild = rchild;
}
}

<pre name="code" class="java">package muyanmoyang.data.BTree;

import java.awt.List;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Stack;

public class BTree {
static BtNode root = initTree() ;
public static void main(String[] args) {
//初始化
BtNode bt = initTree() ;
//先序遍历二叉树
System.out.print("\n先序遍历:");
preOrder(bt) ;                  // 先序遍历
System.out.print("\n先序遍历(非递归):");
preOrderWithoutRecursion(bt) ;  // 先序遍历(非递归)
System.out.print("\n中序遍历:");
inOrderWithoutRecursion(bt);    // 中序遍历
System.out.print("\n后序遍历:");
postOrder(bt) ;					// 后序遍历
System.out.print("\n层次遍历:");
levelOrder(bt) ;                // 层次遍历
System.out.print("\n二叉树的深度:" + getDepthOfBTree(bt));
System.out.print("\n二叉树的节点个数:" + getNumOfNodes(bt));

// 求指定节点的parent节点
System.out.print("\n查询双亲节点，请输入以下节点中的一个: ");
levelOrder(bt) ;
System.out.println();
try{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = br.readLine() ;
BtNode parent = parent(str);
System.out.println("所求双亲为:" + parent.data);
}catch(NullPointerException e){
System.out.println("没有这个节点");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

// 查找指定的节点
BtNode findNode = findNode(bt,"G") ;
BtNode parent2 = parent(findNode.data);
System.out.println("所求双亲为:" + parent2.data);
}
/*
* 初始化树
*/
private static BtNode initTree(){
BtNode aBtNode = new BtNode("A", null, null);
BtNode bBtNode = new BtNode("B", null, null);
BtNode cBtNode = new BtNode("C", null, null);
BtNode dBtNode = new BtNode("D", null, null);
BtNode eBtNode = new BtNode("E", null, null);
BtNode fBtNode = new BtNode("F", null, null);
BtNode gBtNode = new BtNode("G", null, null);
BtNode hBtNode = new BtNode("H", null, null);

aBtNode.setLchild(bBtNode);
aBtNode.setRchild(cBtNode);
bBtNode.setLchild(dBtNode);
bBtNode.setRchild(eBtNode);
cBtNode.setLchild(fBtNode);
cBtNode.setRchild(gBtNode);
fBtNode.setRchild(hBtNode);
return  aBtNode ;
}
/*
*  先序遍历
*/
private static void preOrder(BtNode bt){
if(bt == null){
return ;
}else{
System.out.print(bt.data + "、") ;
if(bt.lchild != null){
preOrder(bt.lchild) ;
}
if(bt.rchild != null){
preOrder(bt.rchild) ;
}
}
}

/*
*  先序遍历 (非递归)
*/
private static void preOrderWithoutRecursion(BtNode bt){
if(bt == null){
return ;
}
Stack<BtNode> stack = new Stack<BtNode>() ;
BtNode p = bt ;
while(p!=null || !stack.isEmpty()){
if(p!=null){
System.out.print(p.data + "、");
stack.push(p) ;
p = p.lchild ;
}else{
p = stack.pop() ;
p = p.rchild ;
}
}
}
/*
*  中序遍历 (非递归实现)
*/
private static void inOrderWithoutRecursion(BtNode bt){
if(bt == null){
return ;
}
Stack<BtNode> stack = new Stack<BtNode>() ;
BtNode p = bt ;
while(p!=null || !stack.isEmpty()){
if(p != null){
stack.push(p) ;
p = p.lchild ;
}else
{
p = stack.pop() ;
System.out.print(p.data + "、");
p = p.rchild ;
}
}
}
/*
*  后序遍历 (双栈实现)
*/
private static void postOrder(BtNode bt){
if(bt == null){
return ;
}
Stack<BtNode> stack = new Stack<BtNode>() ;
Stack<BtNode> out = new Stack<BtNode>() ;
BtNode p = bt ;
while(p!=null || !stack.isEmpty()){
if(p != null){
stack.push(p);
out.push(p);
p = p.rchild ;
}else{
p = stack.pop().lchild ;
}
}
while (!out.isEmpty()) {
p = out.pop() ;
System.out.print(p.data + "、");
}
}

/*
* 层次遍历
*/
private static void levelOrder(BtNode bt){
if(bt == null){
return ;
}
LinkedList queue = new LinkedList() ;
queue.add(bt) ;
while(!queue.isEmpty()){
BtNode tmpNode = (BtNode) queue.remove(0) ;
System.out.print(tmpNode.data + "、");
if(tmpNode.lchild != null){
queue.add(tmpNode.lchild) ;
}
if(tmpNode.rchild != null){
queue.add(tmpNode.rchild);
}
}
}

/*
* 求二叉树的深度（递归实现）
*/
private static int getDepthOfBTree(BtNode bt){
if(bt == null){
return 0 ;
}
int a , b ;
a = getDepthOfBTree(bt.lchild) ;
b = getDepthOfBTree(bt.rchild) ;
return (a > b ? a : b) + 1 ;
}

/*
*  求二叉树的节点个数(递归实现)
*/
private static int getNumOfNodes(BtNode bt){
if(bt == null){
return 0 ;
}
return getNumOfNodes(bt.lchild) + getNumOfNodes(bt.rchild) + 1 ;
}

/*
*  求双亲节点
*/
private static BtNode parent(String elem){
return (root==null || root.data.equals(elem))? null : parent(root,elem) ;
}
private static BtNode parent(BtNode subTree, String elem) {
if(subTree == null){
return null ;
}
if((subTree.lchild!=null && subTree.lchild.data.equals(elem)) || (subTree.rchild!= null && subTree.rchild.data.equals(elem))){
return subTree ;
}
BtNode p ;
if((p=parent(subTree.lchild, elem))!=null){
return p ;
}else
return parent(subTree.rchild, elem) ;
}
/*
* 在释放某个结点时，该结点的左右子树都已经释放，  所以应该采用后续遍历，当访问某个结点时将该结点的存储空间释放
*/
private static void removeSubTree(BtNode subTree){
if(subTree != null){
removeSubTree(subTree.lchild);
removeSubTree(subTree.rchild);
subTree = null ;
}
}

/*
*  查找指定节点，输入节点的data，返回节点的BtNode对象
*/
private static BtNode findNode(BtNode bt,String findData){
BtNode findResultNode = null ;
if(bt == null){
return null ;
}
if(bt.data.equals(findData)){
return bt ;
}
if(bt.lchild != null){
findResultNode = findNode(bt.lchild, findData) ;
if(findResultNode!=null)
return findResultNode ;
}
if(bt.rchild != null){
findResultNode = findNode(bt.rchild, findData) ;
if(findResultNode!=null)
return findResultNode ;
}
return null ;
}
}