代码随想录算法训练营第十五天|层序遍历，226.翻转二叉树，101.对称二叉树

最新推荐文章于 2024-06-27 17:17:34 发布

可乐可乐吖

最新推荐文章于 2024-06-27 17:17:34 发布

阅读量158

点赞数 3

分类专栏：算法训练营文章标签：算法

本文链接：https://blog.csdn.net/weixin_50544110/article/details/137394885

版权

算法训练营专栏收录该内容

53 篇文章 0 订阅

订阅专栏

本文介绍了二叉树和N叉树的层序遍历算法，涉及使用队列实现，以及如何计算最大深度、最小深度、右视图和层平均值等。同时，还包括了填充每个节点的下一个右侧节点指针的方法。

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

层序遍历

使用队列数据结构，将一层结点放入队列，然后逐个弹出，再将弹出元素的左右结点放入队列。

102. 二叉树的层序遍历

题目链接：102. 二叉树的层序遍历

两个队列

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode *root) {
        queue<TreeNode *> que1, que2;
        vector<vector<int>> result;
        if (!root)
            return result;
        que1.push(root);
        while (!que1.empty() || !que2.empty()) {
            if (que1.empty()) {
                que1 = que2;
                while (!que2.empty())
                    que2.pop();
            }
            vector<int> temp;
            while (!que1.empty()) {
                TreeNode *cur = que1.front();
                que1.pop();
                temp.push_back(cur->val);
                if (cur->left)
                    que2.push(cur->left);
                if (cur->right)
                    que2.push(cur->right);
            }
            result.push_back(temp);
        }
        return result;
    }
};

一个队列

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode *root) {
        queue<TreeNode *> que;
        vector<vector<int>> result;
        if (!root)
            return result;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            while(size--){
                TreeNode* cur = que.front();
                que.pop();
                vec.push_back(cur->val);
                if (cur->left)
                    que.push(cur->left);
                if (cur->right)
                    que.push(cur->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

107. 二叉树的层序遍历 II

题目链接：107. 二叉树的层序遍历 II

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode *root) {
        queue<TreeNode *> que;
        vector<vector<int>> result;
        if (!root)
            return result;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            while(size--){
                TreeNode* cur = que.front();
                que.pop();
                vec.push_back(cur->val);
                if (cur->left)
                    que.push(cur->left);
                if (cur->right)
                    que.push(cur->right);
            }
            result.push_back(vec);
        }
        reverse(result.begin(), result.end());
        return result;
    }
};

199. 二叉树的右视图

题目链接：199. 二叉树的右视图

class Solution {
public:
    vector<int> rightSideView(TreeNode *root) {
        queue<TreeNode *> que;
        vector<int> result;
        if (!root)
            return result;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            while (size--) {
                TreeNode *cur = que.front();
                que.pop();
                if (size == 0)
                    result.push_back(cur->val);
                if (cur->left)
                    que.push(cur->left);
                if (cur->right)
                    que.push(cur->right);
            }
        }
        return result;
    }
};

637. 二叉树的层平均值

题目链接：637. 二叉树的层平均值

class Solution {
public:
    vector<double> averageOfLevels(TreeNode *root) {
        queue<TreeNode *> que;
        vector<double> result;
        if (!root)
            return result;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            int size_t = size;
            double sum = 0;
            vector<int> vec;
            while (size_t--) {
                TreeNode *cur = que.front();
                que.pop();
                sum += cur->val;
                if (cur->left)
                    que.push(cur->left);
                if (cur->right)
                    que.push(cur->right);
            }
            result.push_back(sum / size);
        }
        return result;
    }
};

429. N 叉树的层序遍历

题目链接：429. N 叉树的层序遍历

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

515. 在每个树行中找最大值

题目链接：515. 在每个树行中找最大值

class Solution {
public:
    vector<int> largestValues(TreeNode *root) {
        queue<TreeNode *> que;
        vector<int> result;
        if (!root)
            return result;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            int max = INT32_MIN;
            while (size--) {
                TreeNode *cur = que.front();
                que.pop();
                max = cur->val > max ? cur->val : max;
                if (cur->left)
                    que.push(cur->left);
                if (cur->right)
                    que.push(cur->right);
            }
            result.push_back(max);
        }
        return result;
    }
};

116. 填充每个节点的下一个右侧节点指针

题目链接：116. 填充每个节点的下一个右侧节点指针

class Solution {
public:
    Node *connect(Node *root) {
        queue<Node *> que;
        vector<int> result;
        if (root)
            que.push(root);
        while (!que.empty()) {
            int size = que.size();
            while (size--) {
                Node *cur = que.front();
                que.pop();
                if (size == 0)
                    cur->next = NULL;
                else
                    cur->next = que.front();
                if (cur->left)
                    que.push(cur->left);
                if (cur->right)
                    que.push(cur->right);
            }
        }
        return root;
    }
};

117. 填充每个节点的下一个右侧节点指针 II

题目链接：117. 填充每个节点的下一个右侧节点指针 II

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node *> que;
        vector<int> result;
        if (root)
            que.push(root);
        while (!que.empty()) {
            int size = que.size();
            while (size--) {
                Node *cur = que.front();
                que.pop();
                if (size == 0)
                    cur->next = NULL;
                else
                    cur->next = que.front();
                if (cur->left)
                    que.push(cur->left);
                if (cur->right)
                    que.push(cur->right);
            }
        }
        return root;
    }
};

104. 二叉树的最大深度

题目链接：104. 二叉树的最大深度

class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode *> que;
        int depth = 0;
        if (root)
            que.push(root);
        while (!que.empty()) {
            int size = que.size();
            while (size--) {
                TreeNode *cur = que.front();
                que.pop();
                if (cur->left)
                    que.push(cur->left);
                if (cur->right)
                    que.push(cur->right);
                
            }
            depth++;
        }
        return depth;
    }
};

111. 二叉树的最小深度

题目链接：111. 二叉树的最小深度

class Solution {
public:
    int minDepth(TreeNode *root) {
        queue<TreeNode *> que;
        int depth = 0;
        if (root)
            que.push(root);
        while (!que.empty()) {
            int size = que.size();
            while (size--) {
                TreeNode *cur = que.front();
                que.pop();
                if (!cur->left && !cur->right)
                    return depth + 1;
                if (cur->left)
                    que.push(cur->left);
                if (cur->right)
                    que.push(cur->right);
            }
            depth++;
        }
        return depth;
    }
};