二叉树的相关常考操作

二叉树的相关操作

二叉树的模版

struct TreeNode{
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x):val(x),left(NULL),right(NULL){
        
    }
};

前序遍历

递归版

//前序遍历,递归
void pre(TreeNode *root, vector<int> &ret){
    if(root!=NULL){
        ret.push_back(root->val);
        pre(root->left,ret);
        pre(root->right,ret);
    }
}

vector<int> preorderTraversal(TreeNode *root){
    vector<int> ret;
    pre(root,ret);
    return ret;
}

非递归版

利用栈来实现，注意入栈的时候是先右后左

//前序遍历，非递归
vector<int> preorderTraversal2(TreeNode *root){
    vector<int> ret;
    stack<TreeNode*> pre;
    TreeNode *p;
    if(root==NULL) return ret;
    pre.push(root);//先根
    while(!pre.empty()){
        p=pre.top();//取栈顶
        ret.push_back(p->val);//先根
        pre.pop();  //根出栈
        if(p->right!=NULL){//右子树入栈
            pre.push(p->right);
        }
        if(p->left!=NULL){//左子树入栈
            pre.push(p->left);
        }
    }
    return ret;
}

中续遍历

递归版

//中序遍历，递归
void mid(TreeNode *root,vector<int> &res){
    if(root!=NULL){
        mid(root->left,res);
        res.push_back(root->val);
        mid(root->right,res);
    }
}

vector<int> midorder(TreeNode *root){
    vector<int> res;
    mid(root,res);
    return res;
}

非递归版

//中序遍历，非递归
vector<int> midorder2(TreeNode *root){
    vector<int> res;
    stack<TreeNode *> s;
    if(root==NULL) return res;
    while(root!=NULL||!s.empty()){
        while(root!=NULL){
            s.push(root);
            root=root->left;
        }
        root=s.top();
        s.pop();
        res.push_back(root->val);
        root=root->right;
    }
    return res;
}

后续遍历

左右根

递归版

//后续遍历，递归
void rec(TreeNode *root,vector<int> &ret)
{
    if(root!=NULL)
    {
        rec(root->left,ret);
        rec(root->right,ret);
        ret.push_back(root->val);
    }
}
vector<int> postorderTraversal(TreeNode *root) {
    vector<int> ret;
    rec(root,ret);
    return ret;
}

非递归版

//后续遍历，非递归
vector<int> postorderTraversal2(TreeNode *root){
    vector<int> ret;
    if(root==NULL) return ret;
    TreeNode *p=root;
    TreeNode *last=root;
    stack<TreeNode *> toTraversal;
    toTraversal.push(p);
    while(!toTraversal.empty())
    {
        p=toTraversal.top();
        if((p->left==NULL&&p->right==NULL)||(p->right==NULL&&last==p->left)||last==p->right)//这些情况说明左右节点都输出了，可以输出跟节点
        {
            ret.push_back(p->val);
            last=p;
            toTraversal.pop();
        }
        else{
                if(p->right!=NULL)
                {
                toTraversal.push(p->right);
                }
                if(p->left!=NULL)
                {
                toTraversal.push(p->left);
                }
        }
    }
    return ret;
}

层次遍历

用队列来实现，先进先出，由于队列新加入的节点排在后面，优先出队列之前加入的节点，因此，加进来的下一层的节点，只有在本层所有节点都出队列的时候才会出队列，以此来实现层次遍历。

//层次遍历
vector<int> PrintFromToBottom(TreeNode* root){
    vector<int> vec;
    queue<TreeNode*> q;
    if(root==NULL) return vec;
    q.push(root);
    while(!q.empty()){
        TreeNode *r=q.front();
        vec.push_back(r->val);
        q.pop();
        if(r->left!=NULL){
            q.push(r->left);
        }
        if(r->right!=NULL){
            q.push(r->right);
        }
    }
    return vec;
}