代码随想录算法训练营第14天 | 144.二叉树的前序遍历、145.二叉树的后序遍历、94.二叉树的中序遍历

144.二叉树的前序遍历

题目：144.二叉树的前序遍历
文档讲解：代码随想录-144.二叉树的前序遍历
视频讲解：哔哩哔哩-144.二叉树的前序遍历
状态/时间：没写出来/三十分钟

*思路：
法一：递归方式

思路：

通过递归的方式，要确定好递归的终止条件，还有递归的参数和返回值以及单调递归的逻辑。

由于是前序遍历，我们先返回的是，规则是 中 左 右 所以，按照这个顺序调用递归的逻辑。

代码：

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) { 
        List<Integer> res = new ArrayList<Integer>();
        preorder(root,res);
        return res;
    }
    public void preorder(TreeNode node, List<Integer> list){
        if (node == null) {
            return;
        }
		// 中
        list.add(node.val);
        // 左
        preorder(node.left, list);
        // 右
        preorder(node.right, list);
    }
}

注意：

法二：迭代方式

思路：

迭代的方式，是用栈来实现的，我们首先把根放入到栈中，然后不断找根的最右边的元素，为啥不是左边呢，不是中左右嘛，因为我们这里采用的是栈，要先让右边的进去，然后左边的进去了，才能先弹出来。

都加进去之后，再慢慢弹出来，不为空时，一直迭代。直到栈为空。

代码：

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    // 用迭代的方法实现
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        } 
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            // 中
            TreeNode node = stack.pop();
            res.add(node.val);
            // 右
           if (node.right != null) {
                stack.push(node.right);
           }
		  // 左
           if (node.left != null) {
               stack.push(node.left);
           }
            
        }
        return res;
    }
}

注意：

145.二叉树的后序遍历

题目：145.二叉树的后序遍历
文档讲解：代码随想录-145.二叉树的后序遍历
视频讲解：哔哩哔哩-145.二叉树的后序遍历
状态/时间：没写出来/三十分钟

思路：

改变了一下递归的顺序，改为左 右 中 即可。

代码：

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        postorder(root, res);
        return res;
    }

    public void postorder(TreeNode node, List<Integer> list) {
        if (node == null) {
            return;
        }
	   // 左
        postorder(node.left, list);
        // 右
        postorder(node.right, list);
        // 中
        list.add(node.val);
    }
}

注意：

法二：迭代法

思路：

迭代这里因为用栈实现，所以 中 左 右 出来是 中 右 左 然后倒过来刚好是 左 右 中，因此后序遍历就这么巧妙的解决了。

代码：

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        if (root == null) {
            return res;
        }

        stack.push(root);
        while(!stack.isEmpty()) {
            TreeNode node = stack.pop();
            res.add(node.val);
            if (node.left != null) {
                stack.push(node.left);
            }
            if (node.right != null) {
                stack.push(node.right);
            }
        }
        Collections.reverse(res);
        return res;
    }
}

注意：
94.二叉树的中序遍历

题目：94.二叉树的中序遍历
文档讲解：代码随想录-94.二叉树的中序遍历
视频讲解：哔哩哔哩-94.二叉树的中序遍历
状态/时间：没写出来/三十分钟
法一：递归方式

思路：

还是跟上面一样，中序遍历是 左 中 右，改下迭代的顺序即可。

代码：

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        inorder(root, res); 
        return res;
    }
    public void inorder(TreeNode node, List<Integer> list) {
        if (node == null) {
            return;
        }
		// 左
        inorder(node.left, list);
        // 中
        list.add(node.val);
        // 右
        inorder(node.right, list);
    }
}

注意：

法二：迭代法

代码

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        if (root == null) {
            return res;
        }

        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()) {
            if (cur != null) {
                stack.push(cur);
                cur = cur.left;
            } else {
                cur = stack.pop();
                res.add(cur.val);
                cur = cur.right;
            }
        }
        return res;
    }
}