二叉树非递归遍历(前序、中序、后续、层序)

本文链接：https://blog.youkuaiyun.com/lyl194458/article/details/94832066

本文详细介绍了二叉树的四种遍历方法：前序、中序、后续及层序遍历。通过栈和队列辅助数据结构，实现非递归遍历，深入解析每种遍历的实现细节。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

（1）前序

vector<int> v;
        if(root==nullptr)
            return v;
        
        stack<TreeNode*> s;
        TreeNode* cur=root;
        while(cur || !s.empty())
        {
            while(cur)//左路节点入栈，并访问
            {
                v.push_back(cur->val);
                s.push(cur);
                cur=cur->left;
            }
            TreeNode* top=s.top();
            cur=top->right;//栈顶右子树赋给cur,模拟递归
        }
        return v;

（2）中序

vector<int> inorderTraversal(TreeNode* root) {
        vector<int> v;
        if(root==nullptr)
            return v;
        
        TreeNode* cur=root;
        stack<TreeNode*> s;
        while(cur || !s.empty())
        {
            while(cur)//左路节点入栈，但是不访问
            {
                s.push(cur);
                cur=cur->left;
            }
            //拿出栈顶元素访问，并将右子树赋给cur(模拟递归)
            TreeNode* top=s.top();
            v.push_back(top->val);
            cur=top->right;
            s.pop();
        }
        
        return v;
    }

（3）后续

vector<int> postorderTraversal(TreeNode* root) {
        vector<int> v;
        if(root==nullptr)
            return v;
        
        TreeNode* cur=root;
        TreeNode* prev=nullptr;
        stack<TreeNode*> s;
        
        while(cur || !s.empty())
        {
            while(cur)//左路节点入栈，但是不访问
            {
                s.push(cur);
                cur=cur->left;
            }
            
            TreeNode* top=s.top();
            //栈顶的右子树为空，或者右子树是它的前驱，则可以直接访问栈顶元素
            if(top->right==nullptr || top->right==prev)
            {
                v.push_back(top->val);
                prev=top;//将当前节点赋给pre
                s.pop();
            }
            else//否则将栈顶的右子树赋给cur,(模拟递归)
            {
               
                cur=top->right;
            }
        }
        return v;
    }

（4）层序边遍历

 vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> vv;
        if(root==nullptr)
            return vv;
        
        TreeNode* cur=root;
        queue<pair<TreeNode*, int>> q;
        q.push({cur, 0});
        
        while(!q.empty())
        {
            pair<TreeNode*, int> top=q.front();
            TreeNode* node=top.first;
            int index=top.second;
            
            if(vv.size()<index+1)
                vv.push_back({});
            vv[index].push_back(node->val);//访问队首节点
            q.pop();
            
            //左右孩子入队
            if(node->left!=nullptr)
                q.push({node->left, index+1});
            if(node->right!=nullptr)
                q.push({node->right, index+1});
            
        }
        return vv;
    }