二叉树的四种遍历（递归、非递归）

1、递归遍历

 class TreeNode {
          int val;
          TreeNode left;
          TreeNode right;
          TreeNode(int x) { val = x; }
      }

/**
      * 先序遍历
      * @param root
      */
     public void printFirstTree(TreeNode root){
         if(root!=null){
             System.out.print(root.val);
             printFirstTree(root.left);
             printFirstTree(root.right);
         }
     }

     /**
      * 中序遍历
      * @param root
      */
     public void printMidTree(TreeNode root){
         if(root!=null){
             printMidTree(root.left);
             System.out.print(root.val);
             printMidTree(root.right);
         }
     }

     /**
      * 后序遍历
      * @param root
      */
     public void printLastTree(TreeNode root){
         if(root!=null){
             printLastTree(root.left);
             printLastTree(root.right);
             System.out.print(root.val);
         }
     }

2、非递归遍历

 /**
      * 先序非递归遍历
      * @param root
      */
     public void printFirstTree2(TreeNode root){
         Stack<TreeNode> s = new Stack<TreeNode>();
         while( root != null || !s.isEmpty()){
             while( root != null){
                 System.out.print(root.val);
                 s.push(root);
                 root = root.left;
             }
             if(!s.isEmpty()){
                 root = s.pop();
                 root = root.right;
             }
         }
     }

     /**
      * 中序非递归遍历
      * @param root
      */
     public void printMidTree2(TreeNode root){
         Stack<TreeNode> s = new Stack<TreeNode>();
         while(root != null || !s.isEmpty()){
             while( root != null){
                 s.push(root);
                 root = root.left;
             }
             if(!s.isEmpty()){
                 root = s.pop();
                 System.out.print(root.val);
                 root = root.right;
             }
         }
     }


    // 后序遍历非递归     
        public  void printLastTree2(TreeNode root) {    
            Stack<TreeNode> s = new Stack<TreeNode>();    
            Stack<Integer> s2 = new Stack<Integer>();    
            Integer i = new Integer(1);                     //0表示对应位置上的节点还没有遍历过右节点，1表示已经遍历过
            while (root != null || !s.empty()) {    
                while (root != null) {      //这个while找到最深处的左节点
                    s.push(root);    
                    s2.push(new Integer(0));                    //0 表示该节点的右节点还没有遍历
                    root = root.left;    
                }    
                while (!s.empty() && s2.peek().equals(i)) {    //判断栈s最上面节点的【右节点】是否已经遍历过
                    s2.pop();    
                    System.out.print(s.pop().val);    
                }    

                if (!s.empty()) {                           //取出s最上面的节点，遍历右节点，并将该节点的标志 从0修改成1
                    s2.pop();    
                    s2.push(new Integer(1));    
                    root = s.peek();    
                    root = root.right;    
                }    
            }    
        }  

     /**
      * 层次遍历
      * @param pre
      * @param in
      * @return
      */
     public void printLevelTree(TreeNode root){
         if(root == null) return;
         ArrayDeque<TreeNode> deque = new ArrayDeque<TreeNode>();
         deque.add(root);
         TreeNode current = null;
         while(!deque.isEmpty()){
             current = deque.poll();
             System.out.print(current.val);
             if(current.left!=null) deque.add(current.left);
             if(current.right!=null)deque.add(current.right);
         }

     }