LeetCode – Refresh – Binary Tree Inorder Traversal

There are three methods to do it:

1. recursive(use memory stack): (Time O(n), Space O(logn)

 1 /**
 2  * Definition for binary tree
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 public:
12     void getTree(TreeNode *root, vector<int> &result) {
13         if (!root) return;
14         getTree(root->left, result);
15         result.push_back(root->val);
16         getTree(root->right, result);
17     }
18     vector<int> inorderTraversal(TreeNode *root) {
19         vector<int> result;
20         getTree(root, result);
21         return result;
22     }
23 };

2. directly use stack: Same with previous

 1 /**
 2  * Definition for binary tree
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 public:
12     vector<int> inorderTraversal(TreeNode *root) {
13         vector<int> result;
14         if (!root) return result;
15         stack<TreeNode *> s;
16         while (root || !s.empty()) {
17             if (root) {
18                 s.push(root);
19                 root = root->left;
20             } else {
21                 result.push_back(s.top()->val);
22                 root = s.top()->right;
23                 s.pop();
24             }
25         }
26         return result;
27     }
28 };

3. Two pointers (Time O(n), Space O(1)):

This method is trying to temporarily change the tree structure as a so called "linkedlist".

 1 /**
 2  * Definition for binary tree
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 public:
12     vector<int> inorderTraversal(TreeNode *root) {
13         vector<int> result;
14         if (!root) return result;
15         TreeNode *prev = NULL;
16         while (root) {
17             if (!root->left) {
18                 result.push_back(root->val);
19                 root = root->right;
20             } else {
21                 prev = root->left;
22                 while(prev->right && prev->right != root) prev = prev->right;
23                 if (!prev->right) {
24                     prev->right = root;
25                     root = root->left;
26                 } else {
27                     prev->right = NULL;
28                     result.push_back(root->val);
29                     root = root->right;
30                 }
31             }
32         }
33         return result;
34     }
35 };