Java 实现二叉树

主要实现 了二叉树的创建和三种不同方式的递归各非递归的实现，返回节点的父结点，着重强调非 递归的实现思路

import java.util.Stack;

public class BinaryTree {
private TreeNode root=null;
public BinaryTree() {
// TODO Auto-generated constructor stub
root=new TreeNode("A");
}
/*
* 创建一棵二叉树
*               A
*      B               C
*  D      E               F
*                                 G
*/
public void  createBinTree(TreeNode root) {
TreeNode  newNodeB=new TreeNode("B");
TreeNode  newNodeC=new TreeNode("C");
TreeNode  newNodeD=new TreeNode("D");
TreeNode  newNodeE=new TreeNode("E");
TreeNode  newNodeF=new TreeNode("F");
TreeNode  newNodeG=new TreeNode("G");
root.leftChild=newNodeB;
root.rightChild=newNodeC;
newNodeB.leftChild=newNodeD;
newNodeB.rightChild=newNodeE;
newNodeC.rightChild=newNodeF;
newNodeF.rightChild=newNodeG;

}
//是否为空
public boolean  isEmpty() {
return root==null;
}

public int  height() {
return height(root);
}
public int size() {
return size(root);
}
private int size(TreeNode subTree) {
// TODO Auto-generated method stub
if (subTree==null) {
return 0;
}
else {
return 1+size(subTree.leftChild)+size(subTree.rightChild);
}
}
//使用递归树的高度
private int height(TreeNode subTree) {
// TODO Auto-generated method stub
if (subTree==null) {
return 0;
}
else {
int i=height(subTree.leftChild);
int j=height(subTree.rightChild);
return Math.max(1+i,1+j);
}
}
//返回双亲结点
public TreeNode  getParent(TreeNode element) {
return (root==null ||root==element) ?null:parent(root, element);
}
private TreeNode parent(TreeNode subTree, TreeNode element) {
// TODO Auto-generated method stub
if (subTree==null) {
return null;
}
if (subTree.leftChild==element||subTree.rightChild==element)
return subTree;
TreeNode p;
//在左子树中查找
if ((p=parent(subTree.leftChild, element))!=null)
{
return p;
}else {
return parent(subTree.rightChild, element);
}

}
//先序遍历
public void preOrder(TreeNode subTree) {
if (subTree!=null) {
visted(subTree);
preOrder(subTree.leftChild);
preOrder(subTree.rightChild);
}
}
//先序遍历非递归，输出AAA和BBB帮助理解非递归的实现思路。
public void  nrpreOrder(TreeNode subTree) {
Stack<TreeNode> stack=new Stack<TreeNode>();
TreeNode node=root;
while(node!=null||stack.size()>0)
{
while (node!=null) {
System.out.println(node.data);
stack.push(node);
node=node.leftChild;
System.out.println("AAA");
}
node=stack.pop();
node=node.rightChild;
System.out.println("BBB");
}
}
//中序遍历
public void  inOrder(TreeNode subTree) {
if (subTree!=null) {
inOrder(subTree.leftChild);
visted(subTree);
inOrder(subTree.rightChild);
}
}
//中序遍历(非递归) ， 输出AAA和BBB帮助理解非递归的实现思路。
public void nrInOrderTraverse() {

Stack<TreeNode> stack = new Stack<TreeNode>();
TreeNode node = root;
while (node != null ||stack.size()>0) {
//如果左子树不为空
while (node != null) {
stack.push(node);
node = node.leftChild;
System.out.println("AAA");
}
node = stack.pop();
System.out.println(node.data);
node = node.rightChild;
System.out.println("BBB");
}

}
//后序遍历
public void  postOrder(TreeNode subTree) {
if (subTree!=null) {
postOrder(subTree.leftChild);
postOrder(subTree.rightChild);
visted(subTree);
}
}
//后序遍历非递归实现
public void  nrpostOrder(TreeNode subTree) {
Stack<TreeNode> stack = new Stack<TreeNode>();
TreeNode node = root;
TreeNode preNode = null;//表示最近一次访问的节点
//左子树入栈
while (node != null || !stack.isEmpty()) {
while (node != null) {
stack.push(node);
node = node.leftChild;
}
node = stack.peek();
if (node.rightChild == null || node.rightChild == preNode) {
System.out.println(node.data);
node = stack.pop();
preNode = node;
node = null;
} else {
node = node.rightChild;
}
}
}
//得到节点的左节点
public TreeNode getLeftChildNode(TreeNode element) {
return (element!=null) ?element.leftChild:null;
}
//得到节点的右节点
public TreeNode getRightChildNode(TreeNode element) {
return (element!=null) ?element.rightChild:null;
}
//访问节点的值
public void  visted(TreeNode subTree) {
subTree.isVisted=true;
System.out.println(subTree.data);
}
//销毁二叉树
public void  destory(TreeNode subTree) {
if (subTree!=null) {
destory(subTree.leftChild);       //销毁左子树
destory(subTree.rightChild);      //销毁右子树
subTree=null;

System.out.println("ddd");
}
}
/*
* 二叉树的节点数据结构
*/
class TreeNode
{
private String data=null;
private boolean isVisted=false;
private TreeNode leftChild=null;
private TreeNode rightChild=null;
public TreeNode() {
// TODO Auto-generated constructor stub
}
public TreeNode(String data) {
// TODO Auto-generated constructor stub
this.data=data;
this.leftChild=null;
this.rightChild=null;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
BinaryTree binaryTree=new BinaryTree();
binaryTree.createBinTree(binaryTree.root);
System.out.println(binaryTree.height());
System.out.println(binaryTree.size());
System.out.println("先序遍历");
binaryTree.preOrder(binaryTree.root);
System.out.println("先序遍历非递归实现");
binaryTree.nrpreOrder(binaryTree.root);
System.out.println("中序遍历");
binaryTree.inOrder(binaryTree.root);
System.out.println("中序遍历非递归实现");
binaryTree.nrInOrderTraverse();
System.out.println("后序遍历");
binaryTree.postOrder(binaryTree.root);
System.out.println("后序遍历非递归实现");
binaryTree.nrpostOrder(binaryTree.root);
System.out.println("返回D节点的父节点");
TreeNode node=binaryTree.root.leftChild.leftChild;
TreeNode parentnode=binaryTree.getParent(node);
System.out.println(parentnode.data);

}

}