算法-二叉树的前中后序遍历

题目一、二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历 --letcode

解法一、迭代

巧妙使用双向队列的先进先出规则,挨个查左节点

  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;
      }
  }
 
public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> integers = new ArrayList<>();
        if(root == null){
            return integers;
        }
        Deque<TreeNode> deque = new LinkedList<>();
        TreeNode node = root;
        while(!deque.isEmpty() || node !=null){
            while (node != null){
                integers.add(node.val);
                deque.push(node);
                node = node.left;
            }

            node = deque.pop();
            node = node.right;
        }
        return integers;
    }

解法二：递归

迭代要有个返回，为null说明到底了，然后依次遍历左右，真巧妙

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

    public void addNode( List<Integer> integers,TreeNode node){
        if(node == null){
            return ;
        }
        integers.add(node.val);
        addNode(integers,node.left);
        addNode(integers,node.right);
    }
}

题目二、中序遍历

递归法：

   public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        addNode(res,root);
        return res;
    }

    public void addNode(List<Integer> res,TreeNode node){
        if(node == null){
            return ;
        }

        addNode(res,node.left);
        res.add(node.val);
        addNode(res,node.right);
    }

迭代法：

 public List<Integer> inorderTraversal1(TreeNode root) {
            List<Integer> res = new ArrayList<Integer>();
            Deque<TreeNode> stk = new LinkedList<TreeNode>();
            while (root != null || !stk.isEmpty()) {
                while (root != null) {
                    stk.push(root);
                    root = root.left;
                }
                root = stk.pop();
                res.add(root.val);
                root = root.right;
            }
            return res;
        }

题目三、后序

递归：

 public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        addNode(res,root);
        return res;
    }

    public void addNode(List<Integer> res,TreeNode node){
        if(node == null){
            return ;
        }

        addNode(res,node.left);
        addNode(res,node.right);
        res.add(node.val);
    }

迭代

后序的迭代相对复杂，需要额外判断右节点的位置

    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Deque<TreeNode> stk = new LinkedList<TreeNode>();
        TreeNode prev = null;
        while (root != null || !stk.isEmpty()) {
            while (root != null) {
                stk.push(root);
                root = root.left;
            }
            root = stk.pop();

            if (root.right == null || root.right == prev) {
                res.add(root.val);
                prev = root;
                root = null;
            } else {
                stk.push(root);
                root = root.right;
            }
        }
        return res;
    }