java数据结构之二叉树

1。 二叉树接口

public interface BinaryTreeInterface<T> {

public T getRootData();

public int getHeight();

public int getNumberOfRoot();

public void clear();

public void setTree(T rootData); // 用rootData设置树

public void setTree(T rootData,BinaryTreeInterface<T> left,BinaryTreeInterface<T> right); //设置树，用左右子节点

}

2 节点类

package com.jimmy.impl;

public class BinaryNode<T> {

private T data;

private BinaryNode<T> left; //左子节点

private BinaryNode<T> right; //右子节点

public BinaryNode(){

this(null);

}

public BinaryNode(T data){

this(data,null,null);

}

public BinaryNode(T data,BinaryNode<T> left,BinaryNode<T> right){

this.data=data;

this.left=left;

this.right=right;

}

public T getData()

{

return data;

}

public void setData(T data)

{

this.data= data;

}

public BinaryNode<T> getLeft() {

return left;

}

public void setLeft(BinaryNode<T> left) {

this.left = left;

}

public BinaryNode<T> getRight() {

return right;

}

public void setRight(BinaryNode<T> right) {

this.right = right;

}

public boolean hasLeft()

{return left!=null;

}

public boolean hasRight()

{return right!=null;

}

public boolean isLeaf()

{return (left==null)&&(right==null);

}

public int getHeight()

{

return getHeight(this);

}

public int getHeight(BinaryNode<T> node)

{

int h=0;

if(node!=null)

h=1+Math.max(node.getHeight(node.left),node.getHeight(node.right));

return h;

}

public int getNumOfNodes(){

int lnum=0,rnum=0;

if(left!=null)

lnum=left.getNumOfNodes();

if(right!=null)

rnum=right.getNumOfNodes();

return lnum+rnum+1;

}

}

3.二叉树实现

package com.jimmy.impl;

import java.util.Stack;

import com.jimmy.BinaryTreeInterface;

public class Binarytree<T> implements BinaryTreeInterface<T> {

private BinaryNode<T> root; //只要一个数据节点就够了

// 构造空树

public Binarytree(){

root=null;

}

// 用rootData构造树（有个根）

public Binarytree(T rootdata){

root=new BinaryNode<T>(rootdata) ;

}

// 用其他树构造树

public Binarytree(T rootdata,Binarytree<T> leftTree,Binarytree<T> rightTree){

root=new BinaryNode<T>(rootdata) ;

if(leftTree!=null){

root.setLeft(leftTree.root);

}

if(rightTree!=null){

root.setRight(rightTree.root);

}

}

// 用rootData设置树（有个根）

@Override

public void setTree(T rootData) {

root=new BinaryNode<T>(rootData) ;

}

// 用其他树设置树

public void setTree(T rootData, BinaryTreeInterface<T> left,BinaryTreeInterface<T> right) {

root=new BinaryNode<T>(rootData) ;

Binarytree leftTree=null;

Binarytree rightTree=null;

if((leftTree=(Binarytree)left)!=null){

root.setLeft(leftTree.root);

}

if((rightTree=(Binarytree)right)!=null){

root.setRight(rightTree.root);

}

}

@Override

public void clear() {

root=null;

}

@Override

public int getHeight() {

// TODO Auto-generated method stub

return root.getHeight();

}

@Override

public int getNumberOfRoot() {

// TODO Auto-generated method stub

return 0;

}

@Override

public T getRootData() {

if (root!=null)

return root.getData();

else

return null;

}

public BinaryNode<T> getRoot() {

return root;

}

public void setRoot(BinaryNode<T> root) {

this.root = root;

}

public int getNumOfNodes(){

return root.getNumOfNodes();

}

public void inOrderTraverse(){

inOrderTraverse(root);

}

//用栈方法遍历

public void inOrderStackTraverse(){

Stack<BinaryNode> stack=new Stack<BinaryNode>();

BinaryNode cur=root;

//stack.push(root);

while(!stack.isEmpty()||(cur!=null)){

while(cur!=null)

{

stack.push(cur);

cur=cur.getLeft();

}

if(!stack.isEmpty())

{

BinaryNode tmp=stack.pop();

if(tmp!=null)

{System.out.println(tmp.getData());

cur=tmp.getRight();

}

}

}

}

// 递归遍历

public void inOrderTraverse(BinaryNode<T> node){

if(node!=null)

{inOrderTraverse(node.getLeft());

System.out.println(node.getData());

inOrderTraverse(node.getRight());

}

}

public static void main(String[] args) {

Binarytree<String> t=new Binarytree<String>();

Binarytree<String> t8=new Binarytree<String>("8");

Binarytree<String> t7=new Binarytree<String>("7");

t.setTree("6",t7,t8); //用t7,t8设置树t

t.inOrderStackTraverse();

System.out.println(t.getHeight());

}

}