理论基础
树,是一种基础的数据结构。一棵树的子节点数量最大为2(度为2)的树称为二叉树。
//二叉树的定义
struct TreeNode{
int val;//数据
TreeNode* left;
TreeNode* right;
TreeNode(int x):val(x),left(nullptr),right(nullptr){}//初始化
};
递归遍历
二叉树的非层次遍历包括前序遍历,中序遍历,后序遍历。
class Solution{
public:
//前序遍历
void preOrder(TreeeNode* root){
if(root==nullptr) return ;
//结点操作——比如保存
ans.push_back(root->val);
preOrder(root->left);
preOrder(root->right);
}
//中序遍历
void inOrder(TreeNode* root){
if(root==nullptr) return ;
preOrder(root->left);
//结点操作——比如保存
ans.push_back(root->val);
preOrder(root->right);
}
//后序遍历
void postOrder(TreeNode* root){
if(root==nullptr) return ;
postOrder(root->left);
postOrder(root->right);
//结点操作——比如保存
ans.push_back(root->val);
}
vector<int> traversal(TreeNode*Node){
vector<int>ans;//保存结果
preOrder(Node);
inOrder(Node);
postOrder(Node);
}
};
迭代遍历
二叉树的非层次遍历的迭代写法,基于栈实现(层次遍历基于队列实现)
class Solution{
public:
//前序迭代
vector<int> preOrder(TreeNode *root){
stack<TreeNode*>st;
vector<int>ans;
if(root==nullptr) return ans;
st.push(root);
while(!st.empty()){
TreeNode*node=st.pop();
st.pop();
ans.push_back(node->val);
if(node->left) st.push(node->left);
if(node->right) st.push(node->right);
}
return result;
}
//中序遍历
vector<int> inOrder(TreeNode *root){
stack<TreeNode*>st;
vector<int>ans;
if(root==nullptr) return ans;
TreeNode* cur=root;
while(cur||!st.empty()){//中左右——先找左子树的根节点
if(cur){
st.push(cur);
cur=cur->left;//左子树的根节点进队
}else{
cur=st.pop();
st.pop();
ans.push_back(cur->val);//保存左
cutr=cur->right;//保存右
}
}
return ans;
}
//后序遍历
vector<int> postOrder(TreeNode *root){
stack<TreeNode*>st;
vector<int>ans;
if(root==nullptr) return ans;
st.push(root);
while(!st.empty()){
TreeNode*node=st.pop();
st.pop();
ans.push_back(node->val);
if(node->left) st.push(node->left);
if(node->right) st.push(node->right);
}
reverse(ans.begin(),ans.end());
return result;
}
};
统一迭代
迭代写法的统一模板
class Solution{
public:
//中序
vector<int> inOrder(TreeNode* root){
vector<int>ans;
stack<TreeNode*>st;
if(root==nullptr) return ans;
st.push(root);
while(!st.empty()){
TreeNode* node=st.pop();
if(node){
st.pop();
if(node->right) st.push(node->right);
st.push(node);
st.push(null);
}else{//遇到空节点,直接处理下一节点
st.pop();
node=st.pop();//处理下一个
st.pop();
ans.push_back(node->val);
}
}
return ans;
}
//前序
vector<int> preOrder(TreeNode* root){
vector<int>ans;
stack<TreeNode*>st;
if(root==nullptr) return ans;
st.push(root);
while(!st.empty()){
TreeNode* node=st.pop();
if(node){
st.pop();
if(node->right) st.push(node->right);
if(node->left) st.push(node->left);
st.push(node);
st.push(null);
}else{//遇到空节点,直接处理下一节点
st.pop();
node=st.pop();//处理下一个
st.pop();
ans.push_back(node->val);
}
}
return ans;
}
//后序
vector<int> postOrder(TreeNode* root){
vector<int>ans;
stack<TreeNode*>st;
if(root==nullptr) return ans;
st.push(root);
while(!st.empty()){
TreeNode* node=st.pop();
if(node){
st.pop();
st.push(node);
st.push(null);
if(node->right) st.push(node->right);
if(node->left) st.push(node->left);
}else{//遇到空节点,直接处理下一节点
st.pop();
node=st.pop();//处理下一个
st.pop();
ans.push_back(node->val);
}
}
return ans;
}
};