总结
二叉序的遍历主要就是深度优先(前序,中序,后序),广度优先(层序);
前中后序中的前中后指的就是中间节点的顺序;
二叉树遍历的时候,递归走到叶子节点的下一层NULL终止;
力扣俩边要把答案存下来,而非直接输出,所以写二叉树遍历函数的时候,参数里边加了vector &ans;
二叉树的迭代遍历,要把握住每个节点都是一个小子树的中间节点;前中后不同的就是何时处理这个中间节点;
前序遍历:先把根入栈,然后不断弹栈放ans,右孩子入栈,左孩子入栈;
中序遍历:借助一个是指针cur去遍历,先指向根,当栈为空且cur指向NULL时退出循环,如果cur不为空就入栈,指向左孩子,如果为空就弹栈放ans,指向右孩子;
后序遍历:左右中,为中右左的反转,改一下前序代码,最后反转即可;
144. 二叉树的前序遍历
递归思路
写一个递归函数,参数是指针,ans容器,不用返回值;
终止条件是当前指针为空;
对于每一个节点,先把自己放ans,递归左孩子,递归右孩子;
/**
* 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:
void front(TreeNode* t,vector<int> &ans){
if(t==nullptr) return;
ans.push_back(t->val);
front(t->left,ans);
front(t->right,ans);
}
vector<int> preorderTraversal(TreeNode* root) {
vector<int> ans;
front(root,ans);
return ans;
}
};
迭代思路
用栈模拟递归的思路,中左右;
先把根放栈里;
while(栈不为空),弹栈放ans,右孩子不空就放栈里,左孩子不空就放栈里;
/**
* 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> ans;
stack<TreeNode*> st;
if(root==nullptr) return ans;
st.push(root);
while(!st.empty()){
auto t=st.top();
ans.push_back(t->val);
st.pop();
if(t->right!=nullptr) st.push(t->right);
if(t->left!=nullptr) st.push(t->left);
}
return ans;
}
};
94. 二叉树的中序遍历
递归思路
写一个递归函数,参数是指针,ans容器,不用返回值;
终止条件是当前指针为空;
对于每一个节点,先递归左孩子,再放自己,然后递归右孩子;
/**
* 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:
void between(TreeNode* root,vector<int> &ans){
if(root==nullptr) return;
between(root->left,ans);
ans.push_back(root->val);
between(root->right,ans);
}
vector<int> inorderTraversal(TreeNode* root) {
vector<int> ans;
between(root,ans);
return ans;
}
};
迭代思路
左中右,由于访问顺序跟操作顺序不同,故借助一个指针cur遍历存栈里;
访问左边一路到NULL,然后放自身节点,然后访问右边;
- cur初始指向root;
- 只有栈空了,并且cur指向NULL时才完成(即退出while);
- 只要当前节点不空,就把当前节点放st里,并且往左孩子走;
- 当前空了,就弹栈放ans,往右孩子走;
/**
* 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> ans;
stack<TreeNode*> st;
TreeNode* cur=root;
while(!st.empty()||cur!=nullptr){
if(cur!=nullptr){
st.push(cur);
cur=cur->left;
}
else{
auto t=st.top();
st.pop();
ans.push_back(t->val);
cur=t->right;
}
}
return ans;
}
};
145. 二叉树的后序遍历
递归思路
写一个递归函数,参数是指针,ans容器,不用返回值;
终止条件是当前指针为空;
对于每一个节点,递归左孩子,递归右孩子,放自己;
/**
* 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:
void behind(TreeNode* root,vector<int> &ans){
if(root==nullptr) return;
behind(root->left,ans);
behind(root->right,ans);
ans.push_back(root->val);
}
vector<int> postorderTraversal(TreeNode* root) {
vector<int> ans;
behind(root,ans);
return ans;
}
};
迭代思路
注意,后序是左右中,相当于中右左反转一下,故直接中左右的代码稍加改动即可;
先把左孩子放栈里,再放右孩子;
最后reverse一下;
/**
* 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> ans;
stack<TreeNode*> st;
if(root==nullptr) return ans;
st.push(root);
while(!st.empty()){
auto t=st.top();
ans.push_back(t->val);
st.pop();
if(t->left!=nullptr) st.push(t->left);
if(t->right!=nullptr) st.push(t->right);
}
reverse(ans.begin(),ans.end());
return ans;
}
};