二叉树的先序中序后序遍历 （递归和非递归）

• 二叉树的结构

package Tree;

public class TreeNode {
   int val=0;
   TreeNode left=null;
   TreeNode right=null;
   public TreeNode(int val) {
       this.val=val;
   }


}

二叉树遍历的代码：

package Tree;

import java.util.LinkedList;
import java.util.Stack;

public class BinaryTree {



    //创建二叉树 
     public void createBinTree(TreeNode root,int count){  

         LinkedList<TreeNode>list=new LinkedList<TreeNode>();
         list.add(root);
         for(int i=2;i<count;i++){  
            TreeNode leftNode = new TreeNode(i);  
            TreeNode rightNode = new TreeNode(++i); 
            TreeNode tree=list.pop();
            tree.left=leftNode;  
            tree.right=rightNode;  
            list.add(tree.left);
            list.add(tree.right);
            }
        }




     //先序遍历   递归实现
     public void preOrderTree(TreeNode root){

         if(root!=null){
         System.out.print(root.val);
         preOrderTree(root.left);
         preOrderTree(root.right);
         }



     }

     //先序遍历  非递归实现
     public String nonRecPreOrder(TreeNode root){
         StringBuilder sb=new StringBuilder();
         LinkedList<TreeNode> stack=new LinkedList<TreeNode>();//jdk5之后  尽量少用Stack，使用LinkList  完全可以替代Stack  且效率比Stack高  
         while(root!=null||stack.size()>0){
             while(root!=null){
                 sb.append(root.val);
                 stack.offerFirst(root);//压栈
                 root=root.left;
             }

             root=stack.pop();//出栈

             root=root.right;


         }

         return sb.toString();
     }


     //中序遍历  递归实现  
     public void InOrderTree(TreeNode root){
         StringBuilder sb=new StringBuilder();
         if(root!=null){
             InOrderTree(root.left);
             System.out.print(root.val);
             InOrderTree(root.right);

         }

     }
     //中序遍历  非递归的形式
     public String nonRecInOrderTree(TreeNode root){
         StringBuilder sb=new StringBuilder();
         LinkedList<TreeNode> stack=new LinkedList<TreeNode>();
        while(root!=null||stack.size()>0){
         while(root!=null){
             stack.offerFirst(root);
             root=root.left;
         }
         root=stack.pop();
         sb.append(root.val);
         root=root.right;
        }

        return sb.toString();
     }
     //后续遍历  递归实现
     public void postOrderTree(TreeNode root){

         if(root!=null){
             postOrderTree(root.left);
             postOrderTree(root.right);
             System.out.print(root.val);

         }

     }


     //后序遍历  非递归实现
    public String nonRecpostOrderTree(TreeNode root){
        StringBuilder sb=new StringBuilder();
        LinkedList<TreeNode>stack=new LinkedList<TreeNode>();
        TreeNode node=null;
        while(root!=null){
            //若节点有左孩子则将节点压栈
            while(root.left!=null){
                stack.offerFirst(root);
                root=root.left;
            }//最终得出  叶子节点  没有左孩子


            //节点不为空  且  节点没有右孩子 或者节点的右孩子已经遍历 
            while(root!=null&&(root.right==null||root.right==node)){
                sb.append(root.val);
                node=root;
                if(stack.isEmpty()){
                    return sb.toString();
                }
                root=stack.pop();

            }


            //如果以上不符合条件  说明有右子树   所以要将当前节点压栈  指针移到 右边子树上
            stack.offerFirst(root);
            root=root.right;

        }


        return sb.toString();
    }

     //判断两个二叉树  是否是  属于子树的关系
     public boolean HasSubtree(TreeNode root1,TreeNode root2) {
            String tree1=PreOrder(root1);
            String tree2=PreOrder(root2);
            if(tree1.equals("")||tree2.equals("")){
                return false;
            }
            if(tree1.length()>=tree2.length()){
                if(tree1.contains(tree2))
                    return true;
            }else{
                if(tree2.contains(tree1))
                    return true;
            }

            return false; 
        }

       public String PreOrder(TreeNode p){  
            Stack<TreeNode> stack=new Stack<TreeNode>();  
            TreeNode node=p;
            StringBuilder sb=new StringBuilder();
            while(node!=null||stack.size()>0){  
                while(node!=null){  
                    sb.append(node.val);  
                    stack.push(node);  
                    node=node.left;  
                }  
               if(stack.size()>0){  
                    node=stack.pop();  
                    node=node.right;  
                }   
            }

             return sb.toString();
        }  




     public static void main(String[]args){
         BinaryTree BT=new BinaryTree();
         TreeNode root=new TreeNode(1);
         BT.createBinTree(root,7);

        System.out.println("---------------先序遍历---------------递归 "); 
        BT.preOrderTree(root);
        System.out.println("");
        System.out.println("非递归");
        System.out.println(BT.nonRecPreOrder(root));
       System.out.println("---------------中序遍历----------------递归");
       BT.InOrderTree(root);
       System.out.println("");
       System.out.println("非递归");
       System.out.println(BT.nonRecInOrderTree(root));

       System.out.println("---------------后序遍历------------------递归");
       BT.postOrderTree(root);
       System.out.println(" ");
       System.out.println("非递归");
       System.out.println(BT.nonRecpostOrderTree(root));


     }


}