神评 [★★★★★] 一套带走
作者:sonp orz
链接:https://leetcode-cn.com/problems/binary-tree-postorder-traversal/solution/mo-fang-di-gui-zhi-bian-yi-xing-by-sonp/
来源:力扣(LeetCode)
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
vector<int> preorderTraversal(TreeNode* root) {
vector<int> res; //保存结果
stack<TreeNode*> call; //调用栈
if (root != nullptr) call.push(root); //首先介入root节点
while (!call.empty()) {
TreeNode* t = call.top();
call.pop(); //访问过的节点弹出
if (t != nullptr) {
if (t->right) call.push(t->right); //右节点先压栈,最后处理
if (t->left) call.push(t->left);
call.push(t); //当前节点重新压栈(留着以后处理),因为先序遍历所以最后压栈
call.push(nullptr); //在当前节点之前加入一个空节点表示已经访问过了
}
else { //空节点表示之前已经访问过了,现在需要处理除了递归之外的内容
res.push_back(call.top()->val); //call.top()是nullptr之前压栈的一个节点,也就是上面call.push(t)中的那个t
call.pop(); //处理完了,第二次弹出节点(彻底从栈中移除)
}
}
return res;
}
vector<int> inorderTraversal(TreeNode* root) {
vector<int> res;
stack<TreeNode*> call;
if (root != nullptr) call.push(root);
while (!call.empty()) {
TreeNode* t = call.top();
call.pop();
if (t != nullptr) {
if (t->right) call.push(t->right);
call.push(t); //在左节点之前重新插入该节点,以便在左节点之后处理(访问值)
call.push(nullptr); //nullptr跟随t插入,标识已经访问过,还没有被处理
if (t->left) call.push(t->left);
}
else {
res.push_back(call.top()->val);
call.pop();
}
}
return res;
}
vector<int> postorderTraversal(TreeNode* root) {
vector<int> res;
stack<TreeNode*> call;
if (root != nullptr) call.push(root);
while (!call.empty()) {
TreeNode* t = call.top();
call.pop();
if (t != nullptr) {
call.push(t); //在右节点之前重新插入该节点,以便在最后处理(访问值)
call.push(nullptr); //nullptr跟随t插入,标识已经访问过,还没有被处理
if (t->right) call.push(t->right);
if (t->left) call.push(t->left);
}
else {
res.push_back(call.top()->val);
call.pop();
}
}
return res;
}
一套带走x2 [★★★★]
https://leetcode.com/problems/binary-tree-postorder-traversal/discuss/45551/Preorder-Inorder-and-Postorder-Iteratively-Summarization
// 英文官网 作者:yavinci
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<>();
Deque<TreeNode> stack = new ArrayDeque<>();
TreeNode p = root;
while(!stack.isEmpty() || p != null) {
if(p != null) {
stack.push(p);
result.add(p.val); // Add before going to children
p = p.left;
} else {
TreeNode node = stack.pop();
p = node.right;
}
}
return result;
}
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<>();
Deque<TreeNode> stack = new ArrayDeque<>();
TreeNode p = root;
while(!stack.isEmpty() || p != null) {
if(p != null) {
stack.push(p);
p = p.left;
} else {
TreeNode node = stack.pop();
result.add(node.val); // Add after all left children
p = node.right;
}
}
return result;
}
public List<Integer> postorderTraversal(TreeNode root) {
LinkedList<Integer> result = new LinkedList<>();
Deque<TreeNode> stack = new ArrayDeque<>();
TreeNode p = root;
while(!stack.isEmpty() || p != null) {
if(p != null) {
stack.push(p);
result.addFirst(p.val); // Reverse the process of preorder
p = p.right; // Reverse the process of preorder
} else {
TreeNode node = stack.pop();
p = node.left; // Reverse the process of preorder
}
}
return result;
}
/* 番外篇
这种模板写法的第三种评论区有些争议,大概是如果这棵树存在类似于拓扑排序的情
况的时候,这个post_order写法会导致最后的结果的顺序可能有问题???(8太懂)评论区也是
看法不一,有人认为有拓扑排序的就不是二叉树了。也有人给出了适用于拓扑排序下
的写法。
*/
// 拓扑排序补充(13赞) 作者:popejoeyxrq ★★★☆
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> result=new ArrayList<>();
Stack<TreeNode> stack=new Stack<>();
if(root==null){
return result;
}
stack.push(root);
TreeNode cur=root;
TreeNode pre=null;
while (!stack.isEmpty()){
cur=stack.peek();
if(cur.left==null&&cur.right==null||(pre!=null&&(pre==cur.left||pre==cur.right))){
result.add(cur.val); //deal with topological dependency
stack.pop();
pre=cur;
}else {
if (cur.right!=null){
stack.push(cur.right);
}
if(cur.left!=null){
stack.push(cur.left);
}
}
}
return result;
}
xiaoyuz666 对yavinci的一些改进 (yavinci评论区)
// ★★★★
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
if (root == null) return res;
Stack<TreeNode> stack = new Stack<>();
TreeNode curr = root;
while (curr != null || !stack.isEmpty()) {
while (curr != null) {
stack.push(curr);
curr = curr.left;
}
curr = stack.pop();
res.add(curr.val);
curr = curr.right;
}
return res;
}
//preorder ★★★★★
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
if (root == null) return list;
Stack<TreeNode> stack = new Stack<>();
stack.push(root);
while (!stack.isEmpty()) {
TreeNode current = stack.pop();
list.add(current.val);
if (current.right != null) {
stack.push(current.right);
}
if (current.left != null) {
stack.push(current.left);
}
}
return list;
}
//postorder ★★★★
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
if (root == null) return list;
Stack<TreeNode> stack = new Stack<>();
stack.push(root);
while (!stack.isEmpty()) {
TreeNode curr = stack.pop();
list.add(0, curr.val);
if (curr.left != null) {
stack.push(curr.left);
}
if (curr.right != null) {
stack.push(curr.right);
}
}
return list;
}
后序遍历的补充(Iterative solution)这个,,个人感觉有点难不太推荐
// ★★★☆ 好难懂,和下面的那个对照着看吧
// https://leetcode.com/problems/binary-tree-postorder-traversal/discuss/45550/C%2B%2B-Iterative-Recursive-and-Morris-Traversal
vector<int> postorderTraversal(TreeNode* root) {
vector<int> nodes;
stack<TreeNode*> todo;
TreeNode* last = NULL;
while (root || !todo.empty()) {
if (root) {
todo.push(root);
root = root->left;
}
else {
TreeNode* node = todo.top();
if (node->right && last != node->right) {
root = node->right;
}
else {
nodes.push_back(node->val);
last = node;
todo.pop();
}
}
}
return nodes;
}
// ★★★ 这是java的一个,ofLucas,(yavinci评论区)
public List<Integer> postorderTraversal(TreeNode root) {
Stack<TreeNode> s = new Stack();
List<Integer> ans = new ArrayList<Integer>();
TreeNode cur = root;
while (cur != null || !s.empty()) {
while (!isLeaf(cur)) {
s.push(cur);
cur = cur.left;
}
if (cur != null) ans.add(cur.val);
while (!s.empty() && cur == s.peek().right) {
cur = s.pop();
ans.add(cur.val);
}
if (s.empty()) cur = null; else cur = s.peek().right;
}
return ans;
}
private boolean isLeaf(TreeNode r) {
if (r == null) return true;
return r.left == null && r.right == null;
}
测试
暂时写一个想到的树
1
/
2
/ \
3 4
\
5
struct node {
int v;
node* l = NULL, * r = NULL;
node(int x) : v(x){}
};
node* rt = t = new node(1);
t = t->l = new node(2);
t->l = new node(3);
t = t->r = new node(4);
t->r = new node(5);