Rubyr代码随想录算法训练营第14天| 二叉树递归遍历 、迭代遍历、统一迭代

二叉树理论基础：摘自代码随想录

Leetcode 144 前序遍历 Binary Tree Preorder Traversal  

Method1: 递归遍历

1）递归函数会在所有节点上执行相同的操作

2）如果单独抽出一个二叉树节点，考虑的是它需要做什么事情？需要在什么时候（前/中/后序位置）做？每个节点都有唯一的的前中后序位置，所以前中后序遍历是遍历二叉树过程中处理每一个节点的三个特殊时间点。

3）前序遍历是刚进入一个节点的时候，所以前序位置的代码在刚进入一个节点时执行

class Solution {
    List<Integer> res = new LinkedList<>();

    public List<Integer> preorderTraversal(TreeNode root) {

       tranverse(root);

       return res;

    }

    public void tranverse(TreeNode root) {
        if (root == null) {
            return;
        }

        res.add(root.val);
        tranverse(root.left);
        tranverse(root.right);
    }
}

Method2: 迭代遍历

//迭代法
     public List<Integer> preorderTraversal(TreeNode root) {
         //create a arrayList to store result
         List<Integer> res = new ArrayList<>();

         //create a stack to store node
         Stack<TreeNode> stack = new Stack<>();

         if (root == null) {
             return res;
         }

         stack.push(root);

         while (!stack.isEmpty()) {
             TreeNode node = stack.pop();

             res.add(node.val);
            //pop left node first after that
             if (node.right != null) {
                 stack.push(node.right);
             }
             if (node.left != null) {
                 stack.push(node.left);
             }
         }

         return res;

    }

Leetcode 94 中序遍历 Binary Tree Inorder Traversal

中序遍历在遍历完左节点，即将开始遍历右节点的时候

Method1: 递归遍历

class Solution {
    LinkedList<Integer> res = new LinkedList<>();
    
    public List<Integer> inorderTraversal(TreeNode root) {
        traverse(root);
        return res;
    }

    // 二叉树遍历函数
    void traverse(TreeNode root) {
        if (root == null) {
            return;
        }
        traverse(root.left);
        // 中序遍历位置
        res.add(root.val);
        traverse(root.right);
    }
}

Method 2: 迭代遍历 

中序遍历顺序: 左-中-右

入栈顺序： 左-右

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

Leetcode 145 后序遍历

后序遍历在将离开一个节点的时候执行

Method 1: 递归遍历

class Solution {

    List<Integer> res = new LinkedList<>();

    public List<Integer> postorderTraversal(TreeNode root) {
        tranverse(root);
        return res;
    }

    public void tranverse(TreeNode root) {
        if (root == null) {
            return;
        }

        tranverse(root.left);
        tranverse(root.right);
        //后序位置是即将离开节点的时刻
        res.add(root.val);

    }
}

Method 2: 迭代遍历 

后序遍历为 左-右-中

入栈顺序：中-左-右 出栈顺序：中-右-左， 最后翻转结果

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.left != null){
                stack.push(node.left);
            }
            if (node.right != null){
                stack.push(node.right);
            }
        }
        Collections.reverse(result);
        return result;
    }