二叉树遍历（递归、非递归）

1、递归遍历

1 void helper(TreeNode* root, vector<int>& res) {
2         if (root) {
3             res.push_back(root->val);
4             helper(root->left, res);
5             helper(root->right, res);
6         }
7 }

把3~5行按照访问顺序交换一下位置，就能实现前序遍历、中序遍历和后序遍历。

2、非递归遍历

非递归遍历可以用栈实现。

a. 前序遍历（144. Binary Tree Preorder Traversal）

前序遍历节点访问次序是 根-左-右

所以对于弹出的每一个节点，进栈顺序是先右孩子，再左孩子

 1 class Solution {
 2 public:
 3     vector<int> preorderTraversal(TreeNode* root) {
 4         vector<int> res;
 5         stack<TreeNode*> stk;
 6         if(root)
 7             stk.push(root);
 8         while (!stk.empty()) {
 9             TreeNode *temp = stk.top();
10             stk.pop();
11             res.push_back(temp->val);
12             if (temp->right)
13                 stk.push(temp->right);
14             if (temp->left)
15                 stk.push(temp->left);
16         }
17         return res;
18     }
19 };

b. 中序遍历（94. Binary Tree Inorder Traversal）

中序遍历节点访问次序是 左-根-右

初始化，temp指向root

扫描二维码关注公众号，回复： 175333 查看本文章

1、temp不为空，temp入栈，temp = temp -> left

2、temp为空，访问栈顶节点并出栈，temp = temp ->right

因为是先入栈，所以在出栈过程中，指针永远不能指回栈顶。

 1 class Solution {
 2 public:
 3     vector<int> inorderTraversal(TreeNode* root) {
 4         vector<int> res;
 5         stack<TreeNode*> stk;
 6         TreeNode *temp = root;
 7         while(!stk.empty() || temp) {
 8             if (temp) {
 9                 stk.push(temp);
10                 temp = temp->left;
11             }  
12             else {
13                 temp = stk.top();
14                 stk.pop();
15                 res.push_back(temp->val);
16                 temp = temp->right;
17             }
18         }
19         return res;
20     }
21 };

c. 后序遍历（145. Binary Tree Postorder Traversal）

后序遍历节点访问次序是 左-右-根

当以根-右-左形式遍历，出栈后的顺序刚好是倒着的后序遍历。操作方式跟前序遍历相同，只不过这回是左孩子先入栈。

可以把出栈节点再压入另一个栈，那么从栈2出去的节点顺序，就是后序遍历。

 1 class Solution {
 2 public:
 3     vector<int> postorderTraversal(TreeNode* root) {
 4         vector<int> res;
 5         stack<TreeNode*> stk1;
 6         stack<TreeNode*> stk2;
 7         if(root)
 8             stk1.push(root);
 9         while(!stk1.empty()){
10             TreeNode *temp = stk1.top();
11             stk2.push(temp);
12             stk1.pop();
13             if(temp->left)
14                 stk1.push(temp->left);
15             if(temp->right)
16                 stk1.push(temp->right);
17         }
18         while(!stk2.empty()) {
19             res.push_back(stk2.top()->val);
20             stk2.pop();
21         }
22         return res;
23     }
24 };