[LeetCode] Nonrecursive postorder traversal 非递归后续遍历

来源：互联网发布：2016windows系统的手机编辑：程序博客网时间：2024/05/22 04:35

简单的做法是，用一个栈来保存遍历时的节点，用另外一个栈保存经过节点的次数。下面的算法不需要节点次数的栈。

翻译自：http://leetcode.com/2010/10/binary-tree-post-order-traversal.html

We use a prev variable to keep track of the previously-traversed node. Let’s assume curr is the current node that’s on top of the stack. When prev is curr‘s parent, we are traversing down the tree. In this case, we try to traverse to curr‘s left child if available (ie, push left child to the stack). If it is not available, we look at curr‘s right child. If both left and right child do not exist (ie, curr is a leaf node), we print curr‘s value and pop it off the stack.

If prev is curr‘s left child, we are traversing up the tree from the left. We look at curr‘s right child. If it is available, then traverse down the right child (ie, push right child to the stack), otherwise print curr‘s value and pop it off the stack.

If prev is curr‘s right child, we are traversing up the tree from the right. In this case, we print curr‘s value and pop it off the stack.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
void postOrderTraversalIterative(BinaryTree *root) {
  if (!root) return;
  stack<BinaryTree*> s;
  s.push(root);
  BinaryTree *prev = NULL;
  while (!s.empty()) {
    BinaryTree *curr = s.top();
    // we are traversing down the tree
    if (!prev || prev->left == curr || prev->right == curr) {
      if (curr->left) {
        s.push(curr->left);
      } else if (curr->right) {
        s.push(curr->right);
      } else {
        cout << curr->data << " ";
        s.pop();
      }
    } 
    // we are traversing up the tree from the left
    else if (curr->left == prev) {
      if (curr->right) {
        s.push(curr->right);
      } else {
        cout << curr->data << " ";
        s.pop();
      }
    }
    // we are traversing up the tree from the right
    else if (curr->right == prev) {
      cout << curr->data << " ";
      s.pop();
    }
    prev = curr;  // record previously traversed node
  }
}

The above method is easy to follow, but has some redundant code. We could refactor out the redundant code, and now it appears to be more concise. Note how the code section for printing curr‘s value get refactored into one single else block. Don’t worry about in an iteration where its value won’t get printed, as it is guaranteed to enter the else section in the next iteration.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
voidpostOrderTraversalIterative(BinaryTree *root){
  if(!root)return;
  stack<BinaryTree*>s;
  s.push(root);
  BinaryTree *prev=NULL;
  while(!s.empty()){
    BinaryTree *curr=s.top();
    if(!prev||prev->left==curr||prev->right==curr){
      if(curr->left)
        s.push(curr->left);
      elseif(curr->right)
        s.push(curr->right);
    }elseif(curr->left==prev){
      if(curr->right)
        s.push(curr->right);
    }else{
      cout<<curr->data<<" ";
      s.pop();
    }
    prev=curr;
  }
}

Alternative Solution:
An alternative solution is to use two stacks. Try to work it out on a piece of paper. I think it is quite magical and beautiful. You will think that it works magically, but in fact it is doing a reversed pre-order traversal. That is, the order of traversal is a node, then its right child followed by its left child. This yields post-order traversal in reversed order. Using a second stack, we could reverse it back to the correct order.

Here is how it works:

Push the root node to the first stack.
Pop a node from the first stack, and push it to the second stack.
Then push its left child followed by its right child to the first stack.
Repeat step 2) and 3) until the first stack is empty.
Once done, the second stack would have all the nodes ready to be traversed in post-order. Pop off the nodes from the second stack one by one and you’re done.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
voidpostOrderTraversalIterativeTwoStacks(BinaryTree *root){
  if(!root)return;
  stack<BinaryTree*>s;
  stack<BinaryTree*>output;
  s.push(root);
  while(!s.empty()){
    BinaryTree *curr=s.top();
    output.push(curr);
    s.pop();
    if(curr->left)
      s.push(curr->left);
    if(curr->right)
      s.push(curr->right);
  }
  while(!output.empty()){
    cout<<output.top()->data<<" ";
    output.pop();
  }
}

Complexity Analysis:
The two-stack solution takes up more space compared to the first solution using one stack. In fact, the first solution has a space complexity of O(h), where h is the maximum height of the tree. The two-stack solution however, has a space complexity of O(n), where n is the total number of nodes.

0 0