代码随想录 10.06 || 二叉树的广度优先遍历（层序遍历）、翻转二叉树、对称二叉树

鱼Sun

已于 2023-10-29 16:22:09 修改

阅读量48

点赞数

文章标签：算法宽度优先数据结构

于 2023-10-06 22:56:51 首次发布

本文链接：https://blog.csdn.net/weixin_73177736/article/details/133623444

版权

二叉树的广度优先遍历

广度优先遍历，又称层序遍历，逐层遍历二叉树，在每一层中，从左至右依次遍历各个结点。层序遍历需要借助一个数据结构，存储当前层内所有元素节点的信息。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != nullptr) que.push(root);

        vector<vector<int>> result;

        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;

            while (size--) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }

            result.push_back(vec);
        }
        return result;
    }
};

class Solution { // 递归法
public:
    void order(TreeNode* cur, vector<vector<int>>& result, int depth) {
        if (cur == nullptr) return ;
        if (depth == result.size()) result.push_back(vector<int>());
        result[depth].push_back(cur->val);
        order(cur->left, result, depth + 1);
        order(cur->right, result, depth + 1);
    }

    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0;
        order(root, result, depth);
        return result;
    }
};

层序遍历也可以递归实现，但是迭代实现的层序遍历可以解决很多问题，可以作为二叉树层序遍历的通解，比如力扣的102、107、199、637、429、515、116、117、104和111。在此给出上述题的代码：

107.二叉树的层序遍历Ⅱ
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != nullptr) que.push(root);

        vector<vector<int>> result;

        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;

            while (size--) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }

            result.push_back(vec);
        }
        reverse(result.begin(), result.end());
        return result;
    }
};

199.二叉树的右视图
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != nullptr) que.push(root);

        vector<int> result;

        while (!que.empty()) {
            int size = que.size();

            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (i == size - 1) result.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};

637.二叉树的层平均值
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        vector<double> result;

        if (root != nullptr) que.push(root);

        while (!que.empty()) {
            int size = que.size();
            double count = 0;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                count += node->val;
                
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            double num = count / size;
            result.push_back(num);
        }

        return result;
    }
};

429.N叉树的层序遍历
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) {
        queue<Node*> que;
        if (root != nullptr) que.push(root);

        vector<vector<int>> result;

        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;

            while (size--) {
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                for (int i = 0; i < node->children.size(); i++) {
                    que.push(node->children[i]);
                }
            }

            result.push_back(vec);
        }
        return result;
    }
};

515.在每个树行中找最大值
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != nullptr) que.push(root);

        vector<int> result;

        while (!que.empty()) {
            int size = que.size();
            int max = que.front()->val;

            while (size--) {
                TreeNode* node = que.front();
                que.pop();

                if (node->val > max) max = node->val;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            
            result.push_back(max);
        }
        return result;
    }
};

116.填充每个节点的下一个右侧节点指针、117.填充每个节点的下一个右侧节点指针Ⅱ
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) {
        queue<Node*> que;
        if (root != nullptr) que.push(root);

        while (!que.empty()) {
            int size = que.size();

            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                
                node->next = que.front();
                if (i == size - 1) node->next = nullptr;
                
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }

        return root;
    }
};

104.二叉树的最大深度
class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        int layer = 0;

        if (root != nullptr) que.push(root);

        while (!que.empty()) {
            int size = que.size();

            while (size--) {
                TreeNode* node = que.front();
                que.pop();

                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            ++layer;
        }
        return layer;
    }
}

111.二叉树的最小深度
class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        int layer = 0;

        if (root != nullptr) que.push(root);

        while (!que.empty()) {
            int size = que.size();

            while (size--) {
                TreeNode* node = que.front();
                que.pop();

                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                if (!node->left && !node->right) return ++layer;
            }
            ++layer;
        }
        return layer;
    }
};

226. 翻转二叉树

交换二叉树左右子树对应位置的节点，即完成翻转。可以通过深度优先所搜的递归法和迭代法完成，也可以通过层序遍历完成。

class Solution { // 广度优先遍历
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != nullptr) que.push(root);

        while (!que.empty()) {
            int size = que.size();

            while (size--) {
                TreeNode* node = que.front();
                que.pop();

                swap(node->left, node->right);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};

class Solution { // 深度优先遍历，前序递归法
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) return root;
        swap(root->left, root->right);
        invertTree(root->left);
        invertTree(root->right);
        
        return root;
    }
};

class Solution { //深度优先遍历，前序迭代法
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) return root;

        stack<TreeNode*> st;
        st.push(root);

        while(!st.empty()) {
            TreeNode* node = st.top();
            st.pop();

            swap(node->left, node->right);
            
            if(node->right) st.push(node->right);
            if(node->left) st.push(node->left);
        }
        return root;
    }
};

101.对称二叉树

对称二叉树，左右子树对应位置上的节点相同，包括位置相同和值相同。

class Solution { // 递归法
public:

    bool compare(TreeNode* left, TreeNode* right) {
        if (left == nullptr && right != nullptr) return false;
        else if (left != nullptr && right == nullptr) return false;
        else if (left == nullptr && right == nullptr) return true;
        else if (left->val != right->val) return false;

        bool outsize = compare(left->left, right->right);
        bool inside = compare(left->right, right->left);
        return outsize && inside;
    }

    bool isSymmetric(TreeNode* root) {
        if (root == nullptr) return true;
        return compare(root->left, root->right);
    }
};

可以通过深度优先搜索的迭代法和递归法实现，在此仅给出相对简单的递归法，笔者尝试过层序遍历的方法，但是无法判断对应位置上的节点是否相同，只能判断左右子树的值相同，大家可以试试层序遍历的实现方法。

鱼Sun

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
代码随想录 10.06 || 二叉树的广度优先遍历（层序遍历）、翻转二叉树、对称二叉树

层序遍历也可以递归实现，但是迭代实现的层序遍历可以解决很多问题，可以作为二叉树层序遍历的通解，比如力扣的102、107、199、637、429、515、116、117、104和111。可以通过深度优先搜索的迭代法和递归法实现，在此仅给出相对简单的递归法，笔者尝试过层序遍历的方法，但是无法判断对应位置上的节点是否相同，只能判断左右子树的值相同，大家可以试试层序遍历的实现方法。广度优先遍历，又称层序遍历，逐层遍历二叉树，在每一层中，从左至右依次遍历各个结点。交换二叉树左右子树对应位置的节点，即完成翻转。
复制链接

扫一扫