代码随想录算法训练营第十三天|树的前序，中序，后序遍历、树的层序遍历

已于 2025-06-09 18:00:46 修改
阅读量223 收藏 6
点赞数 3
文章标签： 算法 leetcode c++ 二叉树 树的遍历
于 2025-06-09 18:00:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/python1_1/article/details/148539556
版权

目录

前言

一、树的前序，中序，后序遍历

1、递归遍历

题目链接：

前序代码：

后序代码：

中序代码：

 2、迭代遍历（非递归算法）：

前序代码：

后序代码：

中序代码：

二、树的层序遍历

题目链接：​​​​​​102. 二叉树的层序遍历 - 力扣（LeetCode）

题目链接：107. 二叉树的层序遍历 II - 力扣（LeetCode）

题目链接：199. 二叉树的右视图 - 力扣（LeetCode）

题目链接：637. 二叉树的层平均值 - 力扣（LeetCode）

题目链接：429. N 叉树的层序遍历 - 力扣（LeetCode） 

题目链接：515. 在每个树行中找最大值 - 力扣（LeetCode）

 题目链接：116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）

题目链接：117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode）

 题目链接：104. 二叉树的最大深度 - 力扣（LeetCode）

 题目链接：111. 二叉树的最小深度 - 力扣（LeetCode）

前言

树的理论基础

文章链接：代码随想录

树的前序，中序，后序遍历

文章链接：树的递归遍历

视频链接（递归遍历）：LeetCode：144.前序遍历，145.后序遍历，94.中序遍历

文章链接：树的迭代遍历（非递归）

视频链接（迭代遍历）：树的前序和后序遍历

视频链接（迭代遍历）：树的中序遍历

树的层序遍历

文章链接：代码随想录

视频链接：LeetCode：102.二叉树的层序遍历

一、树的前序，中序，后序遍历

1、递归遍历

题目链接：

144. 二叉树的前序遍历 - 力扣（LeetCode）

145. 二叉树的后序遍历 - 力扣（LeetCode）

94. 二叉树的中序遍历 - 力扣（LeetCode）

前序代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void preOrder(vector<int>& ret, TreeNode* root)
    {
        if(root != nullptr)
        {
            ret.push_back(root->val);
            preOrder(ret, root->left);
            preOrder(ret, root->right);
        }
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ret;
        preOrder(ret, root);
        return ret;
    }
};

后序代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void postOrder(vector<int>& ret, TreeNode* root)
    {
        if(root != nullptr)
        {
            postOrder(ret, root->left);
            postOrder(ret, root->right);
            ret.push_back(root->val);
        }
    }

    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ret;
        postOrder(ret, root);

        return ret;
    }
};

中序代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void inOrder(vector<int>& ret, TreeNode* root)
    {
        if(root == nullptr)
            return ;
        inOrder(ret, root->left);
        ret.push_back(root->val);
        inOrder(ret, root->right);;
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ret;
        inOrder(ret, root);
        return ret;
    }
};

 2、迭代遍历（非递归算法）：

前序代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ret;
        stack<TreeNode*> sta;

        if(root)
            sta.push(root);
        while(!sta.empty())
        {
            TreeNode *pCur = sta.top();
            sta.pop();
            if(pCur != nullptr)
            {
                ret.push_back(pCur->val);
            }
            else
                continue;
            
            sta.push(pCur->right);
            sta.push(pCur->left);
        }

        return ret;
    }
};

后序代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void postOrder(vector<int>& ret, TreeNode* root)
    {
        if(root != nullptr)
        {
            postOrder(ret, root->left);
            postOrder(ret, root->right);
            ret.push_back(root->val);
        }
    }

    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ret;
        postOrder(ret, root);

        return ret;
    }
};

中序代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ret;
        stack<TreeNode*> sta;
        TreeNode *pCur = root;
        
        while(pCur || !sta.empty())
        {
            if(pCur)
            {
                sta.push(pCur);
                pCur = pCur->left;
            }
            else
            {
                pCur = sta.top();
                sta.pop();
                ret.push_back(pCur->val);
                pCur = pCur->right;
            }
        }

        return ret;
    }
};

二、树的层序遍历

题目链接：​​​​​​102. 二叉树的层序遍历 - 力扣（LeetCode）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ret;
        queue<TreeNode*> que;
        if(root)
            que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            vector<int> vec;
            while(size--)
            {
                TreeNode *pCur = que.front();
                que.pop();
                vec.push_back(pCur->val);
                if(pCur->left)
                    que.push(pCur->left);
                if(pCur->right)
                    que.push(pCur->right);
            }
            ret.push_back(vec);
        }
        return ret;
    }
};

题目链接：107. 二叉树的层序遍历 II - 力扣（LeetCode）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void reverse(vector<vector<int>>& vec)
    {
        int low = 0;
        int high = vec.size() - 1;
        while(low < high)
        {
            swap(vec[low++], vec[high--]);
        }
    }
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> ret;
        queue<TreeNode *> que;

        if(root)
            que.push(root);
        
        while(!que.empty())
        {
            int size = que.size();
            vector<int> vec;
            while(size--)
            {
                TreeNode *pCur = que.front();
                que.pop();
                vec.push_back(pCur->val);
                if(pCur->left)
                {
                    que.push(pCur->left);
                }
                if(pCur->right)
                {
                    que.push(pCur->right);
                }
            }
            ret.push_back(vec);
        }
        reverse(ret);
        return ret;
    }
};

题目链接：199. 二叉树的右视图 - 力扣（LeetCode）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
 * right(right) {}
 * };
 */
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> ret;
        queue<TreeNode*> que;
        if (root)
            que.push(root);

        while (!que.empty()) {
            int size = que.size();
            while (size--) {
                TreeNode* pCur = que.front();
                que.pop();
                if (pCur->left) {
                    que.push(pCur->left);
                }
                if (pCur->right) {
                    que.push(pCur->right);
                }
                if(size == 0)
                {
                    ret.push_back(pCur->val);
                }
            }

        }
        return ret;
    }
};

题目链接：637. 二叉树的层平均值 - 力扣（LeetCode）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> ret;
        queue<TreeNode *> que;
        if(root)
            que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            double sum = 0;
            TreeNode *pCur = nullptr;
            for(int i = 0; i < size; i++)
            {
                pCur = que.front();
                que.pop();
                sum += pCur->val;
                if(pCur->left)
                {
                    que.push(pCur->left);
                }
                if(pCur->right)
                {
                    que.push(pCur->right);
                }
            }
            ret.push_back(sum / size);
        }

        return ret;
    }
};

题目链接：429. N 叉树的层序遍历 - 力扣（LeetCode） 

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        if(root == nullptr) return {};
        vector<vector<int>> ret;
        queue<Node*> que;
        que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            vector<int> vec;
            Node *pCur = nullptr;
            while(size--)
            {
                pCur = que.front();
                que.pop();
                vec.push_back(pCur->val);
                for(int i = 0; i < pCur->children.size(); i++)
                {
                    que.push(pCur->children[i]);
                }
            }
            ret.push_back(vec);
        }
        return ret;
    }
};

题目链接：515. 在每个树行中找最大值 - 力扣（LeetCode）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        if(root == nullptr) return {};
        vector<int> ret;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            TreeNode *pCur = nullptr;
            int maxNum = INT32_MIN;
            while(size--)
            {
                pCur = que.front();
                que.pop();
                if(pCur->left)
                    que.push(pCur->left);
                if(pCur->right)
                    que.push(pCur->right);
                if(pCur->val > maxNum)
                {
                    maxNum = pCur->val;
                }
            }
            ret.push_back(maxNum);
        }
        return ret;
    }
};

 题目链接：116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        if (root == nullptr)
            return {};
        queue<Node*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            Node* pCur = nullptr;
            while (size--) {
                pCur = que.front();
                que.pop();
                if (size != 0) {
                    pCur->next = que.front();

                } else {
                    pCur->next = nullptr;
                }
                if (pCur->left)
                    que.push(pCur->left);
                if (pCur->right)
                    que.push(pCur->right);
            }
        }
        return root;
    }
};

题目链接：117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode）

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        if (root == nullptr)
            return {};
        queue<Node*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            Node* pCur = nullptr;
            while (size--) {
                pCur = que.front();
                que.pop();
                if (size != 0) {
                    pCur->next = que.front();

                } else {
                    pCur->next = nullptr;
                }
                if (pCur->left)
                    que.push(pCur->left);
                if (pCur->right)
                    que.push(pCur->right);
            }
        }
        return root;
    }
};

 题目链接：104. 二叉树的最大深度 - 力扣（LeetCode）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == nullptr) return 0;
        int layerNum = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            TreeNode *pCur = nullptr;
            while(size--)
            {
                pCur = que.front();
                que.pop();
                if(pCur->left)
                    que.push(pCur->left);
                if(pCur->right)
                    que.push(pCur->right);
            }
            layerNum++;
        }

        return layerNum;
    }
};

 题目链接：111. 二叉树的最小深度 - 力扣（LeetCode）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root == nullptr) return 0;
        queue<TreeNode *> que;
        que.push(root);
        int layerNum = 1;
        while(!que.empty())
        {
            int size = que.size();
            TreeNode *pCur = nullptr;
            while(size--)
            {
                pCur = que.front();
                que.pop();
                if(pCur->left == nullptr && pCur->right == nullptr)
                    return layerNum;
                else
                {
                    if(pCur->left)
                        que.push(pCur->left);
                    if(pCur->right)
                        que.push(pCur->right);
                }
            }
            layerNum++;
        }
        return layerNum;
    }
};

hellogarbage
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值