leetcode-145-Binary Tree Postorder Traversal

#include <iostream>
#include <stack>
#include <vector>
using namespace std;
//Definition for a binary tree node.
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
/*
 利用栈的非递归实现，将节点压进栈里面才能实现回溯，但是要
 保证左儿子、右儿子、当前节点的出栈顺序，所以在检查到当前
 节点有左儿子的时候必须压进栈，所以第一次压栈操作结束的时候
 应该是压进树的最左分支的时候；如果当前节点没有左儿子，就要考虑
 有没有右儿子，如果有而且没有访问过的话，就要压进栈里面，然后
 再重复相同的过程，递归的思想判断其有没有左儿子，这样就能保证
 出栈顺序是左儿子、右儿子、当前节点。
 当前节点一定是紧接着它的右儿子出栈的，有两种节点，一种是叶子节点
 另一种是非叶子节点。叶子节点一定是走左分支的时候检查到左儿子为空的
 节点，此时可检查它的右儿子是否为空，不是空的话，就是有右儿子，右儿子
 压栈并且重复整个判断的过程；
 */
//class Solution {
//public:
//    vector<int> postorderTraversal(TreeNode* root) {
//        vector<int> myvec;
//        stack<TreeNode*> mystack;
//        if (!root) {
//            return myvec;
//        }
//        TreeNode *cur = root;
//        do {
//            while (cur) {
//                mystack.push(cur);
//                cur = cur->left;
//            }
//            TreeNode *prev = NULL;
//            while (!mystack.empty()) {
//                cur = mystack.top();
//                if (cur->right == prev) {
//                    mystack.pop();
//                    myvec.push_back(cur->val);
//                    prev = cur;
//                } else {
//                    cur = cur->right;
//                    break;
//                }
//            }
//        } while (!mystack.empty());
//        return myvec;
//    }
//};
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> myvec;
        TreeNode dumpNode(0);
        TreeNode *dump = &dumpNode;
        dump->left = root;
        TreeNode *cur = dump;
        TreeNode *prev;
        while (cur) {
            if (!cur->left) {
                cur = cur -> right;
            } else {
                prev = cur->left;
                while (prev->right && prev->right != cur) {
                    prev = prev->right;
                }
                if (!prev->right) {
                    prev->right = cur;
                    cur = cur->left;
                } else if (prev->right == cur) {
                    if (cur->left == prev) {
                        myvec.push_back(cur->left->val);
                    } else {
                        reverse(cur->left, prev);
                        TreeNode *rev = prev;
                        while (rev != cur->left) {
                            myvec.push_back(rev->val);
                            rev = rev->right;
                        }
                        myvec.push_back(rev->val);
                        reverse(prev, cur->left);
                    }
                    prev->right = NULL;
                    cur = cur->right;
                }
            }
        }
        return myvec;
    }
private:
    void reverse(TreeNode *from, TreeNode *to) {
        TreeNode *last = from;
        TreeNode *current = from->right;
        TreeNode *next;
        while (last != to) {
            next = current->right;
            current->right = last;
            last = current;
            current = next;
        }
    }
};
int main(int argc, const char * argv[]) {
    TreeNode one = TreeNode(1);
    TreeNode two = TreeNode(2);
    TreeNode three = TreeNode(3);
    TreeNode four = TreeNode(4);
    TreeNode five = TreeNode(5);
    TreeNode six = TreeNode(6);
    TreeNode seven = TreeNode(7);
    TreeNode eight = TreeNode(8);
    TreeNode nine = TreeNode(9);
//    one.left = &two;
    one.right = &two;
//    two.left = &four;
//    two.right = &five;
//    three.right = &six;
//    five.left = &seven;
//    five.right = &eight;
//    six.left = &nine;
    Solution s;
    vector<int> result = s.postorderTraversal(&one);
    for (int i = 0; i < result.size(); i++) {
        cout << result[i] << " ";
    }
    cout << endl;
    return 0;
}