代码随想录打卡14

最新推荐文章于 2024-07-17 18:07:42 发布

weixin_42324843

最新推荐文章于 2024-07-17 18:07:42 发布

阅读量27

点赞数

文章标签： c++ 算法开发语言

本文链接：https://blog.csdn.net/weixin_42324843/article/details/129253221

版权

二叉树的遍历

递归遍历

前序：根左右
中序：左根右
后序：左右根

{
    if (pRoot == nullptr) return;
    vec.push_back(pRoot->nValue);
    Pre_Traversal(pRoot->pLeft, vec);
    Pre_Traversal(pRoot->pRight, vec);
}

void In_Traversal(TreeNode* pRoot, vector<int>& vec)
{
    if (pRoot == nullptr) return;

    In_Traversal(pRoot->pLeft, vec);
    vec.push_back(pRoot->nValue);
    In_Traversal(pRoot->pRight, vec);
}

void Post_Traversal(TreeNode* pRoot, vector<int>& vec)
{
    if (pRoot == nullptr) return;

    Post_Traversal(pRoot->pLeft, vec);
    Post_Traversal(pRoot->pRight, vec);
    vec.push_back(pRoot->nValue);
}

迭代遍历（非递归的方法）

vector<int> preorderTraversal(TreeNode* root) 
{
    stack<TreeNode*> sk;
    vector<int> vec;
    if (root == nullptr) return vec;
    sk.push(root);
    while(!sk.empty())
    {
       TreeNode* pNode = sk.top();
       sk.pop();
       vec.push_back(node->val);
       if (node->right) sk.push(node->right);
       if (node->left) sk.push(node->left);
    }
    return vec;
}

vector<int> postorderTraversal(TreeNode* root) 
{
    vector<int> vec = preorderTraversal(root);
    reverse(vec.begin(), vec.end());
    return vec;
}

vector<int> inorderTraversal(TreeNode* root) 
{
    stack<TreeNode*> sk;
    vector<int> vec;
    TreeNode* cur = root;
    while(cur != nullptr || !sk.empty())
    {
        if(cur != nullptr)
        {
            sk.push(cur);
            cur = cur->pLeft;
        }
        else
        {
            cur = sk.top();
            sk.pop();
            vec.push_back(cur->nValue);
            cur = cur->pRight;
        }
    }
    return vec;
}

统一的迭代法（非递归）

标记法

vector<int> preoder(TreeNode* pRoot)
{
    vector<int> vec;
    if (pRoot == nullptr) return vec;
    stack<TreeNode*> sk;
    sk.push(pRoot);
    while(!sk.empty())
    {
        TreeNode* pNode = sk.top();
        if (pNode != nullptr)
        {
            sk.pop();
            if (pNode->pRight) sk.push(pNode->pRight);
            if (pNode->pLeft) sk.push(pNode->pLeft);
            sk.push(pNode);
            sk.push(nullptr);
        }
        else
        {
            sk.pop();
            pNode = sk.top();
            sk.pop();
            vec.push_back(pNode->nValue);
        }
    }
    return vec;
}

vector<int> inoder(TreeNode* pRoot)
{
    vector<int> res;
    if (pRoot == nullptr) return res;
    stack<TreeNode*> sk;
    sk.push(pRoot);
    while (!sk.empty())
    {
        TreeNode* pNode = sk.top();
        if (pNode != nullptr)
        {
            sk.pop();
            if (pNode->pRight) sk.push(pNode->pRight);
            sk.push(pNode);
            sk.push(nullptr);
            if (pNode->pLeft) sk.push(pNode->pLeft);
        }
        else
        {
            sk.pop();
            pNode = sk.top();
            sk.pop();
            res.push_back(pNode->nValue);
        }
    }
    return res;
}


vector<int> postorder(TreeNode* pRoot)
{
    vector<int> res;
    if (pRoot == nullptr) return res;
    stack<TreeNode*> sk;
    sk.push(pRoot);
    while(!sk.empty())
    {
        TreeNode* pNode = sk.top();
        if (pNode != nullptr)
        {
            sk.pop();
            sk.push(pNode);
            sk.push(nullptr);
            if (pNode->pRight) sk.push(pNode->pRight);
            if (pNode->pLeft) sk.push(pNode->pLeft);
        }
        else
        {
            sk.pop();
            pNode = sk.top();
            sk.pop();
            res.push_back(pNode->nValue);
        }
    }
    return res;
}