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

    }

}