一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第4天，点击查看活动详情。
一、题目描述
原文链接：144. 二叉树的前序遍历
具体描述：
给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
示例 1：
输入：root = [1,null,2,3] 输出：[1,2,3]
示例 2：
输入：root = [] 输出：[]
示例 3：
输入：root = [1] 输出：[1]
示例 4：
输入：root = [1,2] 输出：[1,2]
示例 5：
输入：root = [1,null,2] 输出：[1,2]
提示：
-
树中节点数目在范围 [0, 100] 内
-
-100 <= Node.val <= 100
进阶：递归算法很简单，你可以通过迭代算法完成吗？
原文链接：145. 二叉树的后序遍历
具体描述：
给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。
示例 1：
输入：root = [1,null,2,3] 输出：[3,2,1]
示例 2：
输入：root = [] 输出：[]
示例 3：
输入：root = [1] 输出：[1]
提示：
-
树中节点的数目在范围 [0, 100] 内
-
-100 <= Node.val <= 100
进阶：递归算法很简单，你可以通过迭代算法完成吗？
原文链接：94. 二叉树的中序遍历
具体描述：
给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。
示例 1：
输入：root = [1,null,2,3] 输出：[1,3,2]
示例 2：
输入：root = [] 输出：[]
示例 3：
输入：root = [1] 输出：[1]
提示：
-
树中节点数目在范围 [0, 100] 内
-
-100 <= Node.val <= 100
进阶: 递归算法很简单，你可以通过迭代算法完成吗？
二、思路分析
先说说前序遍历（根左右）：
- 我们可以用栈来存储二叉树的子树，首先把整个树放到栈当中
Stack<TreeNode> stack = new Stack<>();stack.push(root); - 首先弹出栈顶元素，把栈顶元素的根节点放到结果当中，然后在让栈来存储当前根节点的左子树和右子树，需要注意的是先存右子树，在存左字数（栈的特点是先进后出，我们要保证先左后右的顺序，所以先存右子树）
- 直到栈为空，循环结束！
在说说后序遍历（左右根）：
我们需要知道，后序遍历就是根右左的反转，比如示例1，根右左的结果是123，反转是321，正好是后序遍历！
那这么说我们只需要实现根右左就可以了，根左右是前序遍历，根右左，不就是换一下存储左右子树的顺序就可以了嘛～
再说说中序遍历（左根右）： 中序遍历是必须找到最下面的左边才是第一个，所以当前节点不断等于左子树，直到最后一个左子树！ 如果找到了最后一个左子树，就把结果存储起来，并开始遍历右边！直到栈空为止！
if (currentNode != null){// 找到最左边左子树
stack.push(currentNode);
currentNode = currentNode.left;
}else{
TreeNode tmpNode = stack.pop();
result.add(tmpNode.val);// 把左边的值放到结果中（注意左边其实就是根）
currentNode = tmpNode.right;// 然后开始右边
}
三、AC代码
前序迭代遍历：
/**
* 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> result = new ArrayList<>();
if (root == null) return result;
Stack<TreeNode> stack = new Stack<>();
stack.push(root);
// 根左右
while (!stack.empty()){
TreeNode rootNode = stack.pop();
result.add(rootNode.val);// 把根放进去
// 栈是先进后出，所以说先添加右边，在添加左边，出来的顺序就是先左后右
if (rootNode.right != null){
stack.push(rootNode.right);
}
if (rootNode.left != null){
stack.push(rootNode.left);
}
}
return result;
}
}
后序迭代遍历：
/**
* 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> result = new ArrayList<>();
if (root == null) return result;
Stack<TreeNode> stack = new Stack<>();
stack.push(root);
// 后序遍历是根右左的反转
while (!stack.empty()){
TreeNode rootNode = stack.pop();
result.add(rootNode.val);
if (rootNode.left != null){
stack.push(rootNode.left);
}
if (rootNode.right != null){
stack.push(rootNode.right);
}
}
Collections.reverse(result);
return result;
}
}
中序迭代遍历：
/**
* 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> result = new ArrayList<>();
if (root == null) return result;
Stack<TreeNode> stack = new Stack<>();
TreeNode currentNode = root;
while (currentNode != null || stack.empty() == false){
if (currentNode != null){// 找到最左边左子树
stack.push(currentNode);
currentNode = currentNode.left;
}else{
TreeNode tmpNode = stack.pop();
result.add(tmpNode.val);// 把左边的值放到结果中（注意左边其实就是根）
currentNode = tmpNode.right;// 然后开始右边
}
}
return result;
}
}
四、总结
- 根右左反转就是后序遍历
感谢大家的阅读，我是Alson_Code，一个喜欢把简单问题复杂化，把复杂问题简单化的程序猿！ ❤
