二叉树前中后层序遍历方法（Java版）

二叉树前中后层序遍历方法（Java版）

二叉树的节点如下所示：

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

 

1 二叉树前序遍历

前序遍历的遍历顺序是：中左右。Leetcode对应题目为144. 二叉树的前序遍历。

下图二叉树的前序遍历为：ABDGCEFH

 

1.1 递归

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        traversal(root,list);
        return list;
    }

    void traversal(TreeNode root,List<Integer> list){
        if(root==null) return;
    //先访问当前节点
        list.add(root.val);
    //遍历左孩子
        traversal(root.left,list);
        //再遍历右孩子
        traversal(root.right,list);
    }
}

 

1.2 迭代

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
    //保存节点值
        List<Integer> list = new ArrayList<>();
    //保存访问过的节点
        Stack<TreeNode> stack = new Stack<>();
        TreeNode p = root;
        while(p!=null || !stack.empty()){
            if(p!=null){
                list.add(p.val);
        //将当前节点入栈
                stack.push(p);
        //访问左孩子
                p=p.left;
            }else{
        //出栈最近访问的节点，并访问其右孩子
                p=stack.pop();
                p=p.right;
            }
        }
        return list;
    }
}

 

2 二叉树中序遍历

中序遍历的遍历顺序是：左中右。Leetcode对应题目为94. 二叉树的中序遍历。

下图二叉树的中序遍历为：DGBAECHF

 

2.1 递归

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        traversal(root,list);
        return list;
    }

    void traversal(TreeNode root,List<Integer> list){
        if(root==null) return;
        traversal(root.left,list);
        list.add(root.val);
        traversal(root.right,list);
    }
}

 

2.2 迭代

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode p = root;
        while(p!=null || !stack.empty()){
            if(p!=null){
        //先不断遍历左孩子，将左孩子入栈
                stack.push(p);
                p=p.left;
            }else{
        //左孩子为空或遍历完成后，就将父节点出栈并遍历，再访问右孩子
                p = stack.pop();
                list.add(p.val);
                p=p.right;
            }
        }
        return list;
    }
}

 

3 二叉树后序遍历

后序遍历的遍历顺序是：左右中。Leetcode对应题目为145. 二叉树的后序遍历。

下图二叉树的后序遍历为：GDBEHFCA

 

3.1 递归

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

    void traversal(TreeNode root,List<Integer> list){
        if(root==null) return;
        traversal(root.left,list);
        traversal(root.right,list);
        list.add(root.val);
    }
}

 

3.2 迭代

技巧法—该迭代方法，在前序遍历的迭代方法上稍作了修改。前序遍历时先访问父节点，再访问左孩子，最后访问右孩子，形成中左右的遍历顺序。在这里，先访问父节点，再访问右孩子，最后访问左孩子，形成中右左的遍历顺序。而我们知道右序遍历的遍历顺序是左右中，我们把上面得到的结果反转不就得到后序遍历的结果了。

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode p = root;
        while(p!=null || !stack.empty()){
            if(p!=null){
                list.add(p.val);
                stack.push(p);
                p = p.right;
            }else{
                p = stack.pop();
                p = p.left;
            }
        }
    //将list中的结果反转
        Collections.reverse(list);
        return list;
    }
}

 

常规法—后序遍历需要确定是从左子树回到父节点，还是从右子树回到父节点。如果从左子树回到父节点，则需要先遍历右子树；如果从右子树回到父节点，则访问父节点。在这里，用节点pre标记前一个访问的节点，用node标记当前要处理的节点，当node的右子树非空且不是前一个访问的节点（pre）时，先访问node的右子树，否则访问node节点。

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode pre = null;
        while(root!=null || !stack.isEmpty()){
            //先遍历左子树
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            TreeNode node = stack.pop();
            //当右子树非空，同时右子树还没访问时，先访问右子树
            if (node.right != null && node.right != pre) {
                root = node.right;
                stack.push(node);
            }else{
                //该节点的右子树为空或已访问后，就访问该节点
                list.add(node.val);
                pre = node;
            }
        }
        return list;
    }
}

 

4 二叉树层序遍历

层序遍历的遍历顺序是：从左至右一层层访问。Leetcode对应题目为102. 二叉树的层序遍历。

下图二叉树的层序遍历为：ABCDEFGH

 

4.1 递归

class Solution {

    List<List<Integer>> reList = new ArrayList<>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        traversal(root,0);
        return reList;
    }

    void traversal(TreeNode root,int deep){
        if(root==null) return;
        deep++;
        if(reList.size()<deep){
            //当层级增加时，list的Item也增加，利用list的索引值进行层级界定
            List<Integer> item = new ArrayList<>();
            reList.add(item);
        }
        reList.get(deep-1).add(root.val);
        traversal(root.left,deep);
        traversal(root.right,deep);
    }
}

 

4.2 迭代

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> reList = new ArrayList<>();
        if(root==null) return reList;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            List<Integer> item = new ArrayList<>();
            //len保存每层的节点数
            int len = queue.size();
            while(len>0){
                TreeNode p = queue.poll();
                item.add(p.val);
                if(p.left!=null) queue.offer(p.left);
                if(p.right!=null) queue.offer(p.right);
                len--;
            }
            reList.add(item);
        }
        return reList;
    }
}