二叉树的遍历
二叉树的遍历通常有四种，前序遍历、中序遍历、后序遍历（分别以当前节点被操作的时机命名）和层序遍历
前序遍历
- 递归写法
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<int> preorderTraversal(TreeNode* root) {
vector<int> res;
traversal(root, res);
return res;
}
void traversal(TreeNode* root, vector<int>& vec) {
if (!root)
return;
vec.push_back(root->val);
traversal(root->left, vec);
traversal(root->right, vec);
}
};
- 迭代写法
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<int> preorderTraversal(TreeNode* root) {
stack<TreeNode*> stk;
vector<int> res;
if (!root)
return res;
stk.push(root);
while (!stk.empty()) {
auto node = stk.top();
res.push_back(node->val);
stk.pop();
if (node->right)
stk.push(node->right);
if (node->left)
stk.push(node->left);
}
return res;
}
};
中序遍历
- 递归写法
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> res;
traversal(root, res);
return res;
}
void traversal(TreeNode* node, vector<int>& vec) {
if (!node)
return;
traversal(node->left, vec);
vec.push_back(node->val);
traversal(node->right, vec);
}
};
- 迭代写法
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> res;
stack<TreeNode*> stk;
if (!root)
return res;
TreeNode* cur = root;
while (cur || !stk.empty()) {
if (cur) {
stk.push(cur);
cur = cur->left;
} else {
cur = stk.top();
stk.pop();
res.push_back(cur->val);
cur = cur->right;
}
}
return res;
}
};
后序遍历
- 递归写法
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
vector<int> res;
travsersal(root, res);
return res;
}
void travsersal(TreeNode* root, vector<int>& vec) {
if (!root)
return;
travsersal(root->left, vec);
travsersal(root->right, vec);
vec.push_back(root->val);
}
};
- 迭代写法
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
stack<TreeNode*> stk;
vector<int> res;
if (!root)
return res;
stk.push(root);
while (!stk.empty()) {
auto node = stk.top();
stk.pop();
res.push_back(node->val);
if (node->left)
stk.push(node->left);
if (node->right)
stk.push(node->right);
}
return vector<int>(res.rbegin(), res.rend());
}
};
层序遍历
- 递归写法
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> res;
order(root, res, 0);
return res;
}
void order(TreeNode* node, vector<vector<int>>& res, int depth) {
if (!node)
return;
if (depth == res.size())
res.push_back(vector<int>());
res[depth].push_back(node->val);
order(node->left, res, depth + 1);
order(node->right, res, depth + 1);
}
};
- 迭代写法
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
queue<TreeNode*> que;
vector<vector<int>> res;
if (!root)
return res;
que.push(root);
while (!que.empty()) {
int sz = que.size();
vector<int> vec;
for (int i = 0; i < sz; ++i) {
TreeNode* node = que.front();
que.pop();
vec.push_back(node->val);
if (node->left)
que.push(node->left);
if (node->right)
que.push(node->right);
}
res.push_back(vec);
}
return res;
}
};
