<LeetCode OJ> 144 / 145 / 94 Binary Tree （Pre & In & Post） order Traversal

144. Binary Tree Preorder Traversal

Total Accepted: 108586 Total Submissions: 278837 Difficulty: Medium

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

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

   1    \     2    /   3

return [1,2,3].

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

1，前序遍历：
递归解法：

基本规则，总是先访问根节点在左节点，在右节点

class Solution {public:    vector<int> result;    vector<int> preorderTraversal(TreeNode* root) {        if(root){            result.push_back(root->val);            preorderTraversal(root->left);            preorderTraversal(root->right);        }        return result;    }};

迭代解法：

class Solution {public:    vector<int> preorderTraversal(TreeNode* root) {        if (root==NULL)             return result;          stack<TreeNode*> stk;          TreeNode* pCurNode=root;          stk.push(pCurNode);          while (!stk.empty())        {              pCurNode = stk.top();              stk.pop();              result.push_back(pCurNode->val);                if (pCurNode->right)                  stk.push(pCurNode->right); //后压进来的后访问             if (pCurNode->left)                  stk.push(pCurNode->left);          }          return result;      }private:  vector<int> result;  };

94. Binary Tree Inorder Traversal

Total Accepted: 111035 Total Submissions: 286275 Difficulty: Medium

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?

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

2，中序遍历：

递归解法：

总是遍历树的左子，再当前节点，再右子

class Solution {  public:      vector<int> inorderTraversal(TreeNode* root) {           if(root){                inorderTraversal(root->left);                result.push_back(root->val);                inorderTraversal(root->right);            }            return result;        }    private:        vector<int> result;   };  

迭代解法：

class Solution {  public:      vector<int> inorderTraversal(TreeNode* root) {          if (root==NULL)                 return result;              stack<TreeNode*> stk;              TreeNode* pCurNode=root;              while (!stk.empty() ||pCurNode)            {                  while(pCurNode)//先把当前节点的所有左子压进去，              {                  stk.push(pCurNode);                  pCurNode=pCurNode->left;              }                pCurNode=stk.top();              stk.pop();//访问当前节点              result.push_back(pCurNode->val);                            pCurNode=pCurNode->right;//再访问当前节点的右子树          }              return result;          }    private:        vector<int> result;      }; 

综上述：都可以采用栈来实现。将当前节点，左子，右子压进栈的顺序以及访问后的弹出栈形成的访问顺序，目的就是在维护要求的遍历顺序。

145. Binary Tree Postorder Traversal

Total Accepted: 89388 Total Submissions: 257694 Difficulty: Hard

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

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

   1    \     2    /   3

return [3,2,1].

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

3，后序遍历：
总是先访问左子，再右子，最后当前节点
递归解法：

class Solution {public:    vector<int> postorderTraversal(TreeNode* root) {        if(root!=NULL)        {            postorderTraversal(root->left);            postorderTraversal(root->right);            result.push_back(root->val);        }        return result;    }private:    vector<int> result;    };

迭代解法

然而发现回顾了一下也没用，尼玛，尽然要用两个栈或者用到了前后节点来维护。
别人的算法设计：

输出栈：获取最终的输出结果

辅助栈：

1，利用辅助栈总是先将当前节点压进栈，接着弹给输出栈（此时他的顺序已确定，所以最先进输出栈，因为最后访问），

2，再左子进辅助栈，在右子进辅助栈（此时在栈顶，下次循环他已被确定顺序）

class Solution {public:    vector<int> postorderTraversal(TreeNode* root) {        if (root==NULL)             return result;          stack<TreeNode*> outStk;//辅助栈将维护此栈的顺序就是后序遍历的顺序        stack<TreeNode*> assistStk;//辅助栈        TreeNode *pCurNode = root;        assistStk.push(pCurNode);                while (!assistStk.empty())        {            pCurNode = assistStk.top();            assistStk.pop();            outStk.push(pCurNode);                        if (pCurNode->left!=NULL)                assistStk.push(pCurNode->left);            if (pCurNode->right!=NULL)                assistStk.push(pCurNode->right);        }        while (!outStk.empty())        {            result.push_back(outStk.top()->val);            outStk.pop();        }        return result;    }private:  vector<int> result;  };

注：本博文为EbowTang原创，后续可能继续更新本文。如果转载，请务必复制本条信息！

原文地址：http://blog.csdn.net/ebowtang/article/details/50572826

原作者博客：http://blog.csdn.net/ebowtang