【问题描述】[]

• 前序遍历 先输出当前结点的数据，再依次遍历输出左结点和右结点

• 中序遍历 先遍历输出左结点，再输出当前结点的数据，再遍历输出右结点
  
• 后续遍历 先遍历输出左结点，再遍历输出右结点，最后输出当前结点的数据

【解答思路】

递归 /迭代（栈）
时间复杂度：O(N) 空间复杂度：O(N)

1. 前序遍历

1.1 递归
二叉树遍历（前序、中序、后序）的递归方法，唯一改变的是记录节点值操作的位置

class Solution {public List<Integer> preorderTraversal(TreeNode root) {if (root != null) {res.add(root.val);preorderTraversal(root.left);preorderTraversal(root.right);}return res;}
}

1.2 迭代（栈）
需要一个辅助栈

class Solution {
public List<Integer> preorderTraversal(TreeNode root) {List<Integer> list = new ArrayList<>();Stack<TreeNode> stack = new Stack<>();TreeNode cur = root;while (cur != null || !stack.isEmpty()) {while (cur != null) {//立马加入当前值list.add(cur.val);stack.push(cur);cur = cur.left; //考虑左子树}//节点为空，就出栈cur = stack.pop();//考虑右子树cur = cur.right;}return list;
}}

2. 中序遍历

1.1 递归
二叉树遍历（前序、中序、后序）的递归方法，唯一改变的是记录节点值操作的位置

class Solution {List<Integer> res = new ArrayList<>();public List<Integer> inorderTraversal(TreeNode root) {if (root != null) {inorderTraversal(root.left);res.add(root.val);inorderTraversal(root.right);}return res;}
}

1.2 迭代（栈）
需要一个辅助栈

public List<Integer> inorderTraversal(TreeNode root) {List<Integer> ans = new ArrayList<>();Stack<TreeNode> stack = new Stack<>();TreeNode cur = root;while (cur != null || !stack.isEmpty()) {//节点不为空一直压栈while (cur != null) {stack.push(cur);cur = cur.left; //考虑左子树}//节点为空，就出栈cur = stack.pop();//当前值加入ans.add(cur.val);//考虑右子树cur = cur.right;}return ans;
}作者：windliang
链接：https://leetcode-cn.com/problems/binary-tree-postorder-traversal/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by--34/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

3. 后序遍历

1.1 递归
二叉树遍历（前序、中序、后序）的递归方法，唯一改变的是记录节点值操作的位置

class Solution {List<Integer> res = new ArrayList<>();public List<Integer> postorderTraversal(TreeNode root) {if (root != null) {postorderTraversal(root.left);postorderTraversal(root.right);res.add(root.val);}return res;}
}

1.2 迭代（栈）
需要两个辅助栈
-从根节点开始依次迭代，弹出栈顶元素输出到输出列表中，然后依次压入它的所有孩子节点，按照从上到下、从左至右的顺序依次压入栈中。

-因为深度优先搜索后序遍历的顺序是从下到上、从左至右，所以需要将输出列表逆序输出。

class Solution {List<Integer> res = new ArrayList<>();public List<Integer> postorderTraversal(TreeNode root) {if (root == null) {return res;}LinkedList<TreeNode> stack = new LinkedList<>();LinkedList<TreeNode> stackTemp = new LinkedList<>();stackTemp.push(root);while (!stackTemp.isEmpty()) {TreeNode curNode = stackTemp.pop();//stack压入stack.push(curNode);if (curNode.left != null) {stackTemp.push(curNode.left);}if (curNode.right != null) {stackTemp.push(curNode.right);}}//逆序while (!stack.isEmpty()) {res.add(stack.pop().val);}return res;}
}

1.3 转换思想 后续转前序 逆转

后序遍历的顺序是 左 -> 右 -> 根。
前序遍历的顺序是 根 -> 左 -> 右，
左右其实是等价的，所以我们也可以轻松的写出 根 -> 右 -> 左 的代码。
然后把 根 -> 右 -> 左 逆序，就是 左 -> 右 -> 根，也就是后序遍历了。

public List<Integer> postorderTraversal2(TreeNode root) {List<Integer> list = new ArrayList<>();Stack<TreeNode> stack = new Stack<>();TreeNode cur = root;while (cur != null || !stack.isEmpty()) {if (cur != null) {list.add(cur.val);stack.push(cur);cur = cur.right; // 考虑右子树} else {// 节点为空，就出栈cur = stack.pop();// 考虑左子树cur = cur.left;}}//翻转Collections.reverse(list);return list;
}

1.4 一个栈

public List<Integer> postorderTraversal(TreeNode root) {if (root == null) return new ArrayList<Integer>();TreeNode node = root;List<Integer> ret = new ArrayList<Integer>();Stack<TreeNode> stack = new Stack<TreeNode>();while(node != null || !stack.isEmpty()) {while (node != null) {stack.push(node);node = node.left;}node = stack.pop();// 后序遍历// 如果没有右孩子或者右孩子被访问过了 {@Alex Zheng 感谢建议哈～}if (node.right == null || (ret.size() != 0 && ret.get(ret.size() - 1).equals(node.right.val)) ) {ret.add(node.val);node = null;}  else {stack.push(node);node = node.right;}}return ret;}链接：https://leetcode-cn.com/problems/binary-tree-postorder-traversal/solution/bian-li-tong-jie-by-long_wotu/

【总结】

1. 前中后序遍历变化的是[中]的位置，左到右的顺序不改变

• 前序遍历 中左右
• 中序遍历 左中右
• 后续遍历 左右中

2.pop 与 poll 都是取出 LinkedList 的第一个元素，并将该元素删除，等效于：removeFirst

不同点：两者的实现所用数据结构不同，

• poll 是基于队列结构实现的方法，当队列中没有元素时，调用该方法返回 null
• pop 是基于栈结构实现的方法，当栈中没有元素时，调用该方法会发生异常

3. 递归模板

res.add(root.val); 位置动态变化

public List<Integer> preorderTraversal(TreeNode root) {if (root != null) {//先序遍历 res.add(root.val);preorderTraversal(root.left);//中序遍历 res.add(root.val);preorderTraversal(root.right);//后序遍历 res.add(root.val);}return res;}

4. 迭代模板

list.add(cur.val);位置动态变化
前中序可遍历，后续遍历可由前序遍历修改后逆转

public List<Integer> preorderTraversal(TreeNode root) {List<Integer> list = new ArrayList<>();Stack<TreeNode> stack = new Stack<>();TreeNode cur = root;while (cur != null || !stack.isEmpty()) {while (cur != null) {stack.push(cur);// 先序遍历   list.add(cur.val);cur = cur.left; }//节点为空，就出栈cur = stack.pop();// 中序序遍历   list.add(cur.val);cur = cur.right;//后序遍历   list.add(cur.val);  需要变得多}return list;
}

参考链接:https://leetcode.wang/leetcode-145-Binary-Tree-Postorder-Traversal.html