[LintCode] 二叉树的前序遍历

The recursive solution is trivial and I omit it here.

Iterative Solution using Stack (O(n) time and O(n) space):

 /**
  * Definition of TreeNode:
  * class TreeNode {
  * public:
  *     int val;
  *     TreeNode *left, *right;
  *     TreeNode(int val) {
  *         this->val = val;
  *         this->left = this->right = NULL;
  *     }
  * }
  */

 class Solution {
 public:
     /**
      * @param root: The root of binary tree.
      * @return: Preorder in vector which contains node values.
      */
     vector<int> preorderTraversal(TreeNode *root) {
         // write your code here
         vector<int> nodes;
         TreeNode* node = root;
         stack<TreeNode*> right;
         while (node || !right.empty()) {
             if (node) {
                 nodes.push_back(node -> val);
                 if (node -> right)
                     right.push(node -> right);
                 node = node -> left;
             }
             else {
                 node = right.top();
                 right.pop();
             }
         }
         return nodes;
     }
 };

Another more sophisticated solution using Morris Traversal (O(n) time and O(1) space):

 /**
  * Definition of TreeNode:
  * class TreeNode {
  * public:
  *     int val;
  *     TreeNode *left, *right;
  *     TreeNode(int val) {
  *         this->val = val;
  *         this->left = this->right = NULL;
  *     }
  * }
  */

 class Solution {
 public:
     /**
      * @param root: The root of binary tree.
      * @return: Preorder in vector which contains node values.
      */
     vector<int> preorderTraversal(TreeNode *root) {
         // write your code here
         vector<int> nodes;
         TreeNode* node = root;
         while (node) {
             if (node -> left) {
                 TreeNode* predecessor = node -> left;
                 while (predecessor -> right && predecessor -> right != node)
                     predecessor = predecessor -> right;
                 if (!(predecessor -> right)) {
                     nodes.push_back(node -> val);
                     predecessor -> right = node;
                     node = node -> left;
                 }
                 else {
                     predecessor -> right = NULL;
                     node = node -> right;
                 }
             }
             else {
                 nodes.push_back(node -> val);
                 node = node -> right;
             }
         }
         return nodes;
     }
 };