代码随想录 - 训练营8期- day 14

最新推荐文章于 2024-10-02 23:40:03 发布

薇薇拉

最新推荐文章于 2024-10-02 23:40:03 发布

阅读量52

点赞数

文章标签：算法 leetcode 职场和发展 Powered by 金山文档

本文链接：https://blog.csdn.net/RossQAQ/article/details/129033534

版权

文章详细介绍了如何使用迭代方法实现二叉树的前序、中序和后序遍历。通过栈来辅助操作，对于前序遍历，先访问根节点，然后右子节点，最后左子节点；中序遍历则在遇到空节点时访问当前节点并转向右子树；后序遍历需在遍历完所有子节点后再访问根节点，并通过反转结果来得到正确顺序。

摘要由CSDN通过智能技术生成

今天是二叉树的各种基本操作。

递归

这个就略过了，太简单了，上过数据结构的应该都会吧

迭代

能用递归，那么借用栈就可以迭代。

前序

利用 stack 的特性进行迭代，感觉很好理解。

唯一需要注意的是打印的顺序和入栈顺序，先入右子结点

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if(root == nullptr) {
            return {};
        }

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

中序

注意处理 nullptr ，利用这个实现中左右的遍历

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        if(root == nullptr) {
            return {};
        }

        vector<int> res;
        stack<TreeNode*> stk;
        TreeNode* node = root;
        while(node != nullptr || !stk.empty()) {
            if(node != nullptr) {
                stk.push(node);
                node = node->left;
            } else {
                node = stk.top();
                stk.pop();
                res.push_back(node->val);
                node = node->right;
            }
        }
        return res;
    }
};

后序

前序改一改，最后reverse

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if(root == nullptr) {
            return {};
        }

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

        }
        reverse(res.begin(), res.end());
        return res;
    }
};

统一风格的迭代

关键就是处理节点后用 nullptr 占位

中序

自己想的其实差不多，细节得注意注意

基本上就是每次迭代时都调整一下结点的顺序

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        if(root == nullptr) {
            return {};
        }

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

前序

没什么好说的，牢记 stack FILO 的特点

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if(root == nullptr) {
            return {};
        }

        vector<int> res;
        stack<TreeNode*> stk;
        stk.push(root);
        while(!stk.empty()) {
            TreeNode* node = stk.top();
            if(node != nullptr) {
                stk.pop();
                if(node->right != nullptr) {
                    stk.push(node->right);
                }
                
                if(node->left != nullptr) {
                    stk.push(node->left);
                }

                stk.push(node);
                stk.push(nullptr);
            } else {
                stk.pop();
                node = stk.top();
                stk.pop();
                res.push_back(node->val);
            }
        }
        return res;
    }
};

后序

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if(root == nullptr) {
            return {};
        }

        vector<int> res;
        stack<TreeNode*> stk;
        stk.push(root);
        while(!stk.empty()) {
            TreeNode* node = stk.top();
            if(node != nullptr) {
                stk.pop();
                stk.push(node);
                stk.push(nullptr);
                if(node->right != nullptr) {
                    stk.push(node->right);
                }
                
                if(node->left != nullptr) {
                    stk.push(node->left);
                }

                
            } else {
                stk.pop();
                node = stk.top();
                stk.pop();
                res.push_back(node->val);
            }
        }
        return res;
    }
};