二叉树的遍历合集（递归和非递归）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */

1.前序遍历
（1）递归：

class Solution {
    List<Integer> list = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        if(root == null){
            return new ArrayList<>();
        }
        list.add(root.val);
        preorderTraversal(root.left);
        preorderTraversal(root.right);
        return list;
    }
}

（2）非递归

class Solution {
   
    public List<Integer> preorderTraversal(TreeNode root) {
        if(root == null){
            return new ArrayList<>();
        }
         List<Integer> list = new ArrayList<>();
         Stack<TreeNode> stack = new Stack<>();
      
         TreeNode cur = root;
        while(!stack.isEmpty()||cur!=null){
            if(cur != null){
                stack.push(cur);
                list.add(cur.val);
                cur = cur.left;
            }else{
                cur = stack.pop();
                cur = cur.right;
            }
        }
 
        return list;
    }
}

2.中序遍历：
（1）递归

class Solution {
    
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        inorderTraversal(root,res);
        return res;
        
    }
    public void inorderTraversal(TreeNode root,List<Integer> res) {
        if(root == null){
            return ;
        }
        inorderTraversal(root.left,res);
        res.add(root.val);
        inorderTraversal(root.right,res);
        
    }

}
（2）非递归

class Solution {
    
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
       Stack<TreeNode> stack = new Stack();
        TreeNode cur  = root; 
       while(!stack.isEmpty()||cur!=null){
           if(cur!=null){
               stack.push(cur);             
               cur = cur.left;
           }else{               
               cur =stack.pop();
               res.add(cur.val);
               cur = cur.right;
           }

       }
        return res;
        
    }

}

3.后序遍历
（1）递归

class Solution {
     List<Integer> list = new ArrayList<>();
    public List<Integer> postorderTraversal(TreeNode root) {

        if(root == null){
            return new ArrayList<>();
        }
        postorderTraversal(root.left);
       postorderTraversal(root.right);
        list.add(root.val);
        return list;
    }
}

(2)非递归：
后序遍历的非递归同样要借助一个栈来保存元素，栈中保存的元素是它的右子树和自身都没有被遍历到的节点，与中序遍历不同的是先访问右子树，在回来的时候再输出根节点的值。需要多一个last指针指向上一次访问到的节点，用来确认是从根节点的左子树返回的还是从右子树返回的。

class Solution {
    
    public List<Integer> postorderTraversal(TreeNode root) {

        if(root == null){
            return new ArrayList<>();
        }
       Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root,last = null;
        List<Integer> list = new ArrayList<>();
        while(!stack.isEmpty()||cur!=null){
          if(cur != null){
              stack.push(cur);
              cur = cur.left;
          }else{
              TreeNode top = stack.peek();
            //是否变到右子树
            if (top.right != null && top.right != last) {
                cur = top.right;
            } else {
                list.add(top.val);
                last = top;
                stack.pop();

          }
        }
        
    }
    return list;
    }
}

class Solution {
    
    public List<Integer> postorderTraversal(TreeNode root) {

        if(root == null){
            return new ArrayList<>();
        }
       Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        LinkedList<Integer> res = new LinkedList<>();
        while(!stack.isEmpty()){
          TreeNode cur = stack.pop();
          res.addFirst(cur.val);
          if(cur.left!=null){
              stack.push(cur.left);
          }
          if(cur.right!=null){
              stack.push(cur.right);
          }
        }
        return res;
        
    }
   
}

4.层序遍历

（1）递归：

/**  * Definition for a binary tree node.  * public class TreeNode { 
*     int val;  *     TreeNode left;  *     TreeNode right;  *     TreeNode(int x) { val = x; }  * }  */ class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>>  res = new ArrayList<>();
        if(root==null){
                return res;
        }
        levelOrder(root,0,res);
        return  res;
    }
     public void levelOrder(TreeNode root,int level,List<List<Integer>> res) {
            if(res.size()==level) { 			res.add(new ArrayList<Integer>());
	    	}
            res.get(level).add(root.val);
            if(root.left!=null){
                levelOrder(root.left,level+1,res);
            }
            if(root.right!=null){
                levelOrder(root.right,level+1,res);
            }
    }

}

(2)非递归

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
         List<List<Integer>> res = new  ArrayList<>();
         if(root == null){
             return res;
         }
         Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
         while(!queue.isEmpty()){
             int size = queue.size();
             List<Integer> list = new ArrayList<>(size);
             while(size-->0){
                 TreeNode node = queue.poll();
                list.add(node.val);
                if(node.left!=null){
                    queue.offer(node.left);
                }
                if(node.right!=null){
                    queue.offer(node.right);
                }
             }
             res.add(list);
         }
         return res;
    }
}