LeetCode Binary Tree Inorder Traversal

class Solution {
public:
    vector<int> inorderTraversal(TreeNode *root) {
        vector<int> res;
        if (root == NULL) return res;
        vector<pair<TreeNode*, bool> > stack;
        stack.push_back(make_pair(root, false));
        
        while (!stack.empty()) {
            pair<TreeNode*, bool>& pn = stack.back();
            TreeNode* n = pn.first;
            if (pn.second) {
                stack.pop_back();
                res.push_back(n->val);
                if (n->right != NULL) {
                    stack.push_back(make_pair(n->right, false));
                }
                continue;
            }
            pn.second = true;
            n = n->left;
            while (n != NULL) {
                stack.push_back(make_pair(n, true));
                n = n->left;
            }
        }
    }
    
    // a better one
    vector<int> _inorderTraversal(TreeNode *root) {
        vector<int> res;
        vector<TreeNode*> stack;
        
        while(root != NULL || !stack.empty()) {
                while (root != NULL) {
                    stack.push_back(root);    
                    root=root->left;
                }
                if (!stack.empty()) {
                    root = stack.back();
                    stack.pop_back();
                    res.push_back(root->val); 
                    root = root->right;   
                }
        }
    }
};

这种题想想简单，写起来也不好写，尤其是写的像第二个那么巧妙简洁，又找到一个比较通用的可以用在中序遍历和后续遍历中

class Solution {
public:
    vector<int> inorderTraversal(TreeNode *root) {
                vector<int> res;
        if (root == NULL) return res;
        vector<pair<TreeNode*, bool> > stack;
        stack.push_back(make_pair(root, false));
        
        while (!stack.empty()) {
            pair<TreeNode*, bool>& pn = stack.back();
            TreeNode* n = pn.first;
            stack.pop_back();
            
            if (pn.second) {
                res.push_back(n->val);
            } else {
                if (n->right != NULL) {
                    stack.push_back(make_pair(n->right, false));
                }
                stack.push_back(make_pair(n, true));
                if (n->left != NULL) {
                    stack.push_back(make_pair(n->left, false));    
                }
            }
        }
        return res;
    }
};

不过以上花样百出，以前好几次都写过但又记不起来（当然能直接想出来的也就没必要看了），现在应该有个终极方法将这些问题统统秒杀掉，以防止其再来迫害人类。因为递归实质上是用到了栈，通过循环加上一个自己维护的栈也可以模拟递归的过程。除了保存在栈上的一般可编程变量外，在函数调用的时候会还会把下一条语句（指令）的CS:EIP存入栈中作为返回地址一般的递归函数返回后，会从调用位置的下一条语句（指令）再开始执行，这个学过汇编就应该非常明白。我们可以通过一个变量再结合switch语句简单而低效的实现这个过程，实质上是个状态机。下面来看代码

    vector<int> universal_traversal(TreeNode *root, int* map) {
        vector<int> res;
        vector<pair<TreeNode*, int> > stack;
        stack.push_back(make_pair(root, -1));
        while (!stack.empty()) {
            pair<TreeNode*, int>& np = stack.back();
            TreeNode* n = np.first;
            if (n == NULL) {
                stack.pop_back();
                continue;
            }
            np.second++;
            switch(map[np.second]) {
                case 0: res.push_back(n->val);break;
                case 1: stack.push_back(make_pair(n->left, -1));break;
                case 2: stack.push_back(make_pair(n->right, -1));break;
                default:stack.pop_back();
            }
        }
        return res;
    }

void print(vector<int> nums) {
    for (int i=0; i<nums.size(); i++) {
        cout<<nums[i]<<" ";
    }
    cout<<endl;
}

int main() {
    TreeNode nodes[10];
    for (int i=0; i<10; i++) {
        nodes[i].val = i;
        nodes[i].left = NULL;
        nodes[i].right = NULL;
    }
    nodes[0].left = &nodes[1];
    // nodes[0].right= &nodes[2];

    nodes[1].right = &nodes[3];
    // nodes[1].right= &nodes[4];
    int preorder[] = {0, 1, 2, -1};
    int inorder[] =  {1, 0, 2, -1};
    int postorder[]= {1, 2, 0, -1};
    
    cout<<"Preorder: "<<endl;
    print(universal_traversal(&nodes[0], preorder));
    cout<<"Inorder: "<<endl;
    print(universal_traversal(&nodes[0], inorder));
    cout<<"Postorder: "<<endl;
    print(universal_traversal(&nodes[0], postorder));
    
    system("pause");
    return 0;
}

 switch中的语句被函数中的map数组进行了映射，相当于几行代码重新排序了一下，因为树遍历重要的就三个语句（输出当前节点数据，左子树进栈，右子树进栈），通过不同的map数组映射，就分别得到了前序、中序、后序遍历的效果，从此妈妈再也不用担心我的学习！

第二轮:

Given a binary tree, return the inorder traversal of its nodes' values.

For example:
Given binary tree {1,#,2,3},

   1
    
     2
    /
   3

return [1,3,2].

Note: Recursive solution is trivial, could you do it iteratively?

还是先用经典方法做吧：

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode *root) {
        vector<int> res;
        if (root == NULL) {
            return res;
        }
        
        vector<TreeNode*> stk;
        TreeNode* cur = root;
        while (cur != NULL) {
            while (cur != NULL) {
                stk.push_back(cur);
                cur = cur->left;
            }
            while (!stk.empty()) {
                cur = stk.back();
                res.push_back(cur->val);
                stk.pop_back();
                if (cur->right != NULL) {
                    break;
                }
            }

            cur = cur->right;
        }
        return res;
    }
};

 简洁一点：

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */
class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Inorder in vector which contains node values.
     */
public:
    vector<int> inorderTraversal(TreeNode *root) {
        // write your code here
        vector<int> res;
        stack<TreeNode*> ns;
        TreeNode* curr = root;
        
        for (;;) {
            while (curr != NULL) {
                ns.push(curr);
                curr = curr->left;
            }
            if (ns.empty()) {
                break;
            }
            TreeNode* tmp = ns.top();
            res.push_back(tmp->val);
            curr = tmp->right;
            ns.pop();
        }
        return res;
    }
};