1.DFS
1.1 递归
vector<int> result;
vector<int> preorderTraversal(TreeNode* root) {
if(root == nullptr)
return result;
result.push_back(root->val);//先序
if(root->left != nullptr)
preorderTraversal(root->left);
//result.push_back(root->val);//中序
if(root->right != nullptr)
preorderTraversal(root->right);
//result.push_back(root->val);//后序
return result;
}
1.2 迭代
1.2.1 先序遍历
vector<int> preorderTraversal(TreeNode* root) {
vector<int> ret;
stack<TreeNode*> helper;
while(root || !helper.empty())
{
while(root)
{
ret.push_back(root->val);
helper.push(root);
root = root->left;
}
root = helper.top()
root = root->right;
helper.pop();
}
return ret;
}
1.2.2 中序遍历
vector<int> inorderTraversal(TreeNode* root) {
vector<int> ret;
stack<TreeNode*> helper;
while(root || !helper.empty())
{
while(root)
{
helper.push(root);
root = root->left;
}
root = helper.top();
ret.push_back(root->val);
root = root->right;
helper.pop();
}
return ret;
}
2.BFS
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> ret;
queue<TreeNode*> q;
if(root || !q.empty())
{
if(q.empty())
q.push(root);
while(!q.empty())
{
vector<int> temp;
int size = q.size();
for(int i = 0; i < size; i++)
{
TreeNode* p = q.front();
if(p->left)
q.push(p->left);
if(p->right)
q.push(p->right);
temp.push_back(p->val);
q.pop();
}
ret.push_back(temp);
}
}
return ret;
}
3 例题:
3.1 深度优先遍历
110.平衡二叉树,可以套用深度优先遍历dfs模板,得到树的深度,进而进行判断
class Solution {
public:
bool flag;
int dfs(TreeNode* p)//得到子树的深度
{
if(p == NULL) return 0;
int l = dfs(p->left);
int r = dfs(p->right);
if(abs(l - r) > 1)
flag = false;
return max(l,r) + 1;
}
bool isBalanced(TreeNode* root) {
if(root == NULL)
return true;
flag = 1;
dfs(root);
return flag;
}
};
3.2 广度优先遍历
- 二叉树的最大深度
借助队列,用push和pop操作进行广度优先遍历,得到树的深度,进而求解。(深度优先遍历在很大的树时会超时失效)
class Solution {
public:
int maxDepth(TreeNode* root) {
if(root == NULL) return 0;
queue<pair<TreeNode*,int> > que;
que.push(make_pair(root,1));//用pair的第二位记录深度
int num = 0;
for(; que.size() > 0; que.pop())
{
auto n = que.front();
num = max(num,n.second);
if(n.first->left)
que.push(make_pair(n.first->left, n.second + 1));
if(n.first->right)
que.push(make_pair(n.first->right, n.second + 1));
}
return num;
}
};