利用二叉树来实现家谱_利用循环和递归实现二叉树的三种遍历

一、前序遍历

遍历的过程为：首先访问根节点，再前序访问其左子树，再前序访问其右子树。

输入二叉树：

正确答案为：

[1,3,4,43,3,2,2,2,42]

递归实现：

void qianxu(TreeNode* root,vector<int>&res)
{
    if(root==NULL)return ;
    res.push_back(root->val);
    if(root->left)qianxu(root->left,res);
    if(root->right)qianxu(root->right,res);
    return ;
}
vector<int> preorderTraversal(TreeNode* root) 
{
    vector<int>res;
    qianxu(root,res);
    return res;
}

输出：[1,3,4,43,3,2,2,2,42]

循环实现：

vector<int> preorderTraversal(TreeNode* root)
{
    if(root==NULL)
        return {};
    vector<int>res;
    stack<TreeNode*> fuzhu;
    while(root||!fuzhu.empty())
    {
        while(root)
        {
            fuzhu.push(root);
            res.push_back(root->val);
            root=root->left;
        }
        if(!fuzhu.empty())
        {
            TreeNode* p=fuzhu.top();
            fuzhu.pop();
            root=p->right;
        }
    }
    return res;
}

输出：[1,3,4,43,3,2,2,2,42]

二、中序遍历

遍历过程为：首先中序遍历其左子树，访问根结点，中序遍历其右子树，代码如下：

递归实现：

    void zhongxu(TreeNode* root,vector<int>&res)
    {
        if(root->left!=NULL)
            zhongxu(root->left,res);
        res.push_back(root->val);
        if(root->right!=NULL)
            zhongxu(root->right,res);
        
    }
    vector<int> inorderTraversal(TreeNode* root) {
        if(root==NULL)
            return {};
        vector<int>res;
        zhongxu(root,res);
        return res;
    }

循环实现：

当遇到一个节点时，将其压入栈中，并去访问其左子树，左子树遍历结束后，从栈顶弹出这个节点并访问它，然后再去中序遍历该节点的右子树，代码如下：

    vector<int> inorderTraversal(TreeNode* root) {
        if(root==NULL)
            return {};
        vector<int>res;
        stack<TreeNode*> fuzhu;
        while(root||!fuzhu.empty())
        {
            while(root)
            {
                fuzhu.push(root);
                root=root->left;
            }
            if(!fuzhu.empty())
            {
                TreeNode* p=fuzhu.top();
                fuzhu.pop();
                res.push_back(p->val);
                root=p->right;
            }
        }
        return res;
    }

三、后序遍历

遍历过程为：后序遍历其左子树，后序遍历其右子树，访问根结点，代码如下:

递归实现：

void houxu(TreeNode* root,vector<int>&res)
{
    if(root->left!=NULL)
        houxu(root->left,res);
    if(root->right!=NULL)
        houxu(root->right,res);
    res.push_back(root->val);
    return ;
}
vector<int> postorderTraversal(TreeNode* root) {
    if(root==NULL)return {};
    vector<int>res;
    houxu(root,res);
    return res;
}

循环实现：

对于一个节点而言，要实现访问顺序为左儿子-右儿子-根节点，可以利用后进先出的栈，在节点不为空的前提下，依次将根节点，右儿子，左儿子压栈。故我们需要按照根节点-右儿子-左儿子的顺序遍历树，而我们已经知道先序遍历的顺序是根节点-左儿子-右儿子，故只需将先序遍历的左右调换并把访问方式打印改为压入另一个栈即可。最后一起打印栈中的元素。代码如下：

    vector<int> postorderTraversal(TreeNode* root) {
        if(root==NULL)
            return {};
        vector<int>res;
        stack<TreeNode*> fuzhu1;
        stack<TreeNode*> fuzhu2;
        while(root||!fuzhu1.empty())
        {
            while(root)
            {
                fuzhu1.push(root);
                fuzhu2.push(root);
                root=root->right;
            }
            if(!fuzhu1.empty())
            {
                TreeNode* p=fuzhu1.top();
                fuzhu1.pop();
                root=p->left;
            }
        }
        while(!fuzhu2.empty())
            {
                TreeNode* p=fuzhu2.top();
                fuzhu2.pop();
                res.push_back(p->val);
            }
        return res;
    }