144. 二叉树的前序遍历

递归：

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     vector<int> preorderTraversal(TreeNode* root) {
15         vector<int> result;
16         dlr(root,result);
17         return result;
18     }
19 private:
20     void dlr(TreeNode* root,vector<int>& vec){
21         if(root == nullptr) return;
22         vec.push_back(root->val);
23         dlr(root->left,vec);
24         dlr(root->right,vec);
25     }
26 };

迭代：

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     vector<int> preorderTraversal(TreeNode* root) {
15         vector<int> result;
16         if(root == nullptr) return result;
17         stack<TreeNode*> stack;
18         stack.push(root);
19         while(!stack.empty()){
20             TreeNode* node = stack.top();
21             stack.pop();
22             if(node != nullptr){
23                 result.push_back(node->val);
24                 stack.push(node->right);
25                 stack.push(node->left);
26             }
27         }
28         return result;
29     }
30 };
145. 二叉树的后序遍历
 
 递归： 
 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     vector<int> postorderTraversal(TreeNode* root) {
15         vector<int> result;
16         lrd(root,result);
17         return result;
18     }
19     void lrd(TreeNode* node, vector<int>& vec){
20         if(node == nullptr) return;
21         lrd(node->left,vec);
22         lrd(node->right,vec);
23         vec.push_back(node->val);
24     }
25 };

迭代：

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     vector<int> postorderTraversal(TreeNode* root) {
15         stack<TreeNode*> stack;
16         vector<int> result;
17         if(root == nullptr) return result;
18         stack.push(root);
19         // 前序遍历反转
20         while(!stack.empty()){
21             TreeNode* node = stack.top();
22             stack.pop();
23             if(node != nullptr){
24                 stack.push(node->left);
25                 stack.push(node->right);
26                 result.push_back(node->val);
27             }
28         }
29         reverse(result.begin(),result.end());
30         return result;
31     }
32 };

94. 二叉树的中序遍历

递归：

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

迭代：

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

迭代的通用解法：

只需要调整右左中的顺序即可

 1 void reverse(TreeNode* root,vector<int> res){
 2     if(root==NULL)    return;
 3     stack<TreeNode*> st;
 4     st.push(root);
 5     while(!st.empty()){
 6         TreeNode* node = st.top();
 7         st.pop();
 8         if(node!=NULL){
 9             // 右
10             if(node->right)    st.push(node->right); 
11             // 左
12             if(node->left)      st.push(node->left); 
13             // 中
14             st.push(node);   
15             st.push(NULL);
16         }else{
17             node = st.top();
18             st.pop();
19             res.push_back(node->val);
20         }
21     }
22 }