数据结构之树（三）二叉树

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);

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());
	}
}


}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.二叉树实现