题目: LeetCode 145. 二叉树的后序遍历
给定一个二叉树,返回它的 后序 遍历。
示例:
输入: [1,null,2,3]
1
2
/
3
输出: [3,2,1]
进阶: 递归算法很简单,你可以通过迭代算法完成吗?
递归算法
import java.util.ArrayList;
import java.util.List;
/// 145. Binary Tree Postorder Traversal
/// https://leetcode.com/problems/binary-tree-postorder-traversal/description/
/// 二叉树的后序遍历
/// 时间复杂度: O(n), n为树的节点个数
/// 空间复杂度: O(h), h为树的高度
public class Solution145 {
// Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
public List<Integer> postorderTraversal(TreeNode root) {
ArrayList<Integer> res = new ArrayList<Integer>();
postorderTraversal(root, res);
return res;
}
private void postorderTraversal(TreeNode node, List<Integer> list){
if(node != null){
postorderTraversal(node.left, list);
postorderTraversal(node.right, list);
list.add(node.val);
}
}
}
非递归算法
// Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
// Non-Recursive
// Using a tag to record whether the node has been visited
//
// Time Complexity: O(n), n is the node number in the tree
// Space Complexity: O(h), h is the height of the tree
public class Solution1 {
private class TagNode{
TreeNode node;
boolean isFirst;
TagNode(TreeNode node){
this.node = node;
this.isFirst = false;
}
};
public List<Integer> postorderTraversal(TreeNode root) {
ArrayList<Integer> res = new ArrayList<Integer>();
if(root == null)
return res;
Stack<TagNode> stack = new Stack<>();
TreeNode cur = root;
while(cur != null || !stack.empty()){
while(cur != null){
stack.push(new TagNode(cur));
cur = cur.left;
}
TagNode tagNode = stack.pop();
cur = tagNode.node;
if(tagNode.isFirst == false){
tagNode.isFirst = true;
stack.push(tagNode);
cur = cur.right;
}
else{
res.add(cur.val);
cur = null;
}
}
return res;
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
// Non-Recursive
// Using two stacks, Reverse Preorder Traversal!
//
// Time Complexity: O(n)
// Space Complexity: O(n)
public class Solution2 {
public List<Integer> postorderTraversal(TreeNode root) {
ArrayList<Integer> res = new ArrayList<Integer>();
if(root == null)
return res;
Stack<TreeNode> stack = new Stack<>();
Stack<Integer> output = new Stack<>();
stack.push(root);
while(!stack.empty()){
TreeNode cur = stack.pop();
output.push(cur.val);
if(cur.left != null)
stack.push(cur.left);
if(cur.right != null)
stack.push(cur.right);
}
while(!output.empty())
res.add(output.pop());
return res;
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
import java.util.LinkedList;
// Non-Recursive
// Using two stacks, Reverse Preorder Traversal!
//
// Time Complexity: O(n)
// Space Complexity: O(n)
public class Solution3 {
public List<Integer> postorderTraversal(TreeNode root){
Stack<TreeNode> stack = new Stack<>();
LinkedList<TreeNode> output = new LinkedList<>();
TreeNode p = root;
while(p != null || !stack.isEmpty()){
if(p != null){
stack.push(p);
output.push(p);
p = p.right;
}
else{
p = stack.pop();
p = p.left;
}
}
ArrayList<Integer> res = new ArrayList<>();
while(!output.isEmpty())
res.add(output.pop().val);
return res;
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
// Non-Recursive
// Using a pre pointer to record the last visted node
//
// Time Complexity: O(n)
// Space Complexity: O(h)
public class Solution4 {
public List<Integer> postorderTraversal(TreeNode root) {
ArrayList<Integer> res = new ArrayList<Integer>();
if(root == null)
return res;
Stack<TreeNode> stack = new Stack<>();
TreeNode pre = null;
stack.push(root);
while(!stack.empty()){
TreeNode cur = stack.pop();
if((cur.left == null && cur.right == null) ||
(pre != null && pre == cur.left && cur.right == null) ||
(pre != null && pre == cur.right)){
res.add(cur.val);
pre = cur;
}
else{
stack.push(cur);
if(cur.right != null)
stack.push(cur.right);
if(cur.left != null)
stack.push(cur.left);
}
}
return res;
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
// Classic Non-Recursive
// Using a pre pointer to record the last visted node
//
// Time Complexity: O(n)
// Space Complexity: O(h)
public class Solution5 {
public List<Integer> postorderTraversal(TreeNode root) {
ArrayList<Integer> res = new ArrayList<Integer>();
if(root == null)
return res;
Stack<TreeNode> stack = new Stack<>();
TreeNode pre = null;
TreeNode cur = root;
while(cur != null || !stack.empty()){
while(cur != null){
stack.push(cur);
cur = cur.left;
}
cur = stack.pop();
if(cur.right == null || pre == cur.right){
res.add(cur.val);
pre = cur;
cur = null;
}
else{
stack.push(cur);
cur = cur.right;
}
}
return res;
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
// Classic Non-Recursive
// Using a pre pointer to record the last visted node
//
// Time Complexity: O(n)
// Space Complexity: O(h)
public class Solution6 {
public List<Integer> postorderTraversal(TreeNode root) {
ArrayList<Integer> res = new ArrayList<Integer>();
if(root == null)
return res;
Stack<TreeNode> stack = new Stack<>();
TreeNode pre = null;
TreeNode cur = root;
while(cur != null || !stack.empty()){
if(cur != null){
stack.push(cur);
cur = cur.left;
}
else{
cur = stack.pop();
if(cur.right == null || pre == cur.right){
res.add(cur.val);
pre = cur;
cur = null;
}
else{
stack.push(cur);
cur = cur.right;
}
}
}
return res;
}
}