先序遍历、中序遍历二叉树非递归实现

最新推荐文章于 2022-07-29 15:37:10 发布

liuchengxu_

最新推荐文章于 2022-07-29 15:37:10 发布

阅读量1k

点赞数

CC 4.0 BY-SA版权

分类专栏： Leetcode 文章标签：二叉树中序遍历 leetcode 先序遍历数据结构

本文链接：https://blog.csdn.net/simple_the_best/article/details/52713491

Leetcode 专栏收录该内容

2 篇文章

订阅专栏

本文详细介绍了二叉树的先序遍历和中序遍历算法，包括递归和非递归两种实现方式，并提供了具体的C++代码实现。

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

先序遍历

leetcode 144. binary-tree-preorder-traversal

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        return preorderTraversalIteratively(root);
    }
    /* 先序遍历递归版本 */
    void preorderTraversalRecursion(TreeNode* root){
        if(root){
            cout<<root->val<<endl;
            preorderTraversalRecursion(root->left);
            preorderTraversalRecursion(root->right);
        }
    }
    /* 先序遍历非递归版本 */
    vector<int> preorderTraversalIteratively(TreeNode* root){
        stack<TreeNode*>S;  // 初始化栈 S
        vector<int>v;       // v 记录访问节点的顺序
        // 两种情况：
        // 只要左子树不为空那么就一直向左走
        // 走到最左边时，看是否有
        while(root || !S.empty()){
            // 左子树不为空一直往左走
            if(root){
                v.push_back(root->val);  // 访问根节点
                S.push(root); // 根节点入栈，因为左子树访问完毕时需要回来再访问右子树
                root = root->left; // 访问左子树
            }
            //  走到最左边后，开始向右走
            else{
                root = S.top();
                S.pop();
                root = root->right;
            }
        }
        return v;
    }
};

中序遍历

leetcode 94. Binary Tree Inorder Traversal

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        return inorderTraversalInteratively(root);
    }
    /* 中序遍历递归版本*/
    void inorderTraversalRecursion(TreeNode* root){
        if(root){
            inorderTraversalRecursion(root->left);
            cout<<root->val<<endl;  // 访问根节点
            inorderTraversalRecursion(root->right);
        }
    }
    /* 中序遍历非递归版本 */
    vector<int> inorderTraversalInteratively(TreeNode* root){

        stack<TreeNode*>S;
        vector<int>v;

        /* 第一种写法
        while(root || !S.empty()){
            if(root){
                S.push(root);
                root = root->left;
            }
            else{
                root = S.top();
                v.push_back(root->val);  // 注意与先序遍历的区别
                S.pop();
                root = root->right;
            }
        }
        */

        /* 第二种写法 */
        while(root || !S.empty()){
            /* 左子树全部入栈 */
            while(root){
                S.push(root);
                root = root->left;
            }
            if(!S.empty()){
                root = S.top();
                v.push_back(root->val);  // 访问根节点
                S.pop();
                root = root->right; // 下一次循环遍历右子树
            }
        }

        return v;
    }
};