代码随想录算法训练营第十三天|层序遍历102,107,199,637,429,515,116,117,104,111，226翻转二叉树，101对称二叉树

二叉树part02

层序遍历102,107,199,637,429,515,116,117,104,111

226翻转二叉树

101对称二叉树

二叉树的层序遍历

102.二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

/**
 * 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) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                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;

    }
};

107.二叉树的层序遍历2

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

/**
 * 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>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                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.二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

 

/**
 * 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) {
        deque<TreeNode*> que;
        if (root != NULL) que.push_back(root);
        vector<int> result;
        while (!que.empty()) {
            int size = que.size();
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            int rightMostValue = 0; 
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop_front();
                rightMostValue = node->val;
                if (node->left) que.push_back(node->left);
                if (node->right) que.push_back(node->right);
            }
            result.push_back(rightMostValue);
        }
        return result;

    }
};

637.二叉树的层平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

/**
 * 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) {
        deque<TreeNode*> que;
        if (root != NULL) que.push_back(root);
        vector<double> result;
        while (!que.empty()) {
            int size = que.size();
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            double sum = 0; 
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop_front();
                sum += node->val;
                if (node->left) que.push_back(node->left);
                if (node->right) que.push_back(node->right);
            }
            result.push_back(sum / size);
        }
        return result;
    }
};

429.N叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

/*
// 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) {
        vector<vector<int>> result;
        if (!root) return result; // 如果根节点为空，直接返回空结果

        queue<Node*> q; // 创建队列
        q.push(root); // 将根节点加入队列

        while (!q.empty()) {
            int size = q.size(); // 当前层的节点数
            vector<int> currentLevel; // 存储当前层节点值的向量

            for (int i = 0; i < size; ++i) {
                Node* node = q.front(); q.pop(); // 获取并移除当前层的一个节点
                currentLevel.push_back(node->val); // 将节点值加入当前层结果中

                // 将当前节点的所有子节点加入队列中
                for (Node* child : node->children) {
                    if (child) q.push(child);
                }
            }

            result.push_back(currentLevel); // 将当前层结果加入最终结果中
        }

        return result;
    }
};

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

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

/**
 * 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) {
        vector<int> result;
        if (!root) return result; // 如果根节点为空，则直接返回空结果

        queue<TreeNode*> q; // 创建队列用于层序遍历
        q.push(root); // 将根节点加入队列

        while (!q.empty()) {
            int size = q.size(); // 当前层的节点数
            int maxVal = INT_MIN; // 初始化当前层的最大值为最小整数
            
            for (int i = 0; i < size; ++i) {
                TreeNode* node = q.front(); q.pop(); // 获取并移除当前层的一个节点
                
                maxVal = max(maxVal, node->val); // 更新当前层的最大值

                // 将当前节点的非空子节点加入队列中
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }

            result.push_back(maxVal); // 将当前层的最大值加入结果中
        }

        return result;

    }
};

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

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

/*
// 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) return root;
        connectTwoNode(root->left, root->right);
        return root;
        
    }
private:
    void connectTwoNode(Node* node1, Node* node2) {
        if (!node1 || !node2) return;

        // 将传入的两个节点连接
        node1->next = node2;

        // 连接相同父节点的两个子节点
        connectTwoNode(node1->left, node1->right);
        connectTwoNode(node2->left, node2->right);

        // 连接跨越父节点的两个子节点
        connectTwoNode(node1->right, node2->left);
    }
};

 

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

给定一个二叉树：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。

初始状态下，所有 next 指针都被设置为 NULL 。

/*
// 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 nullptr;

        queue<Node*> q;
        q.push(root);

        while (!q.empty()) {
            int levelSize = q.size(); // 当前层的节点数
            Node* prev = nullptr; // 记录前一个节点，用于连接next指针

            for (int i = 0; i < levelSize; ++i) {
                Node* node = q.front(); q.pop();

                if (prev != nullptr) {
                    prev->next = node; // 将前一个节点的next指向当前节点
                }
                prev = node; // 更新前一个节点为当前节点

                // 将当前节点的左右子节点加入队列
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }

            // 层的最后一个节点的next应当指向nullptr，这在循环中自然发生
        }

        return root;
        
    }
};

 104.二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

/**
 * 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) {
        // 基本情况：如果当前节点为空，返回0
        if (root == nullptr) {
            return 0;
        }

        // 计算左子树的最大深度
        int leftDepth = maxDepth(root->left);
        // 计算右子树的最大深度
        int rightDepth = maxDepth(root->right);

        // 当前节点的最大深度是其左右子树深度的最大值加1
        return std::max(leftDepth, rightDepth) + 1;

    }
};

111.二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

/**
 * 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) {
        // 基本情况：如果当前节点为空，返回0
        if (root == nullptr) {
            return 0;
        }

        // 如果左子树为空，递归计算右子树的最小深度
        if (root->left == nullptr) {
            return minDepth(root->right) + 1;
        }
        // 如果右子树为空，递归计算左子树的最小深度
        if (root->right == nullptr) {
            return minDepth(root->left) + 1;
        }

        // 如果左右子树都不为空，找出它们中的最小深度
        return std::min(minDepth(root->left), minDepth(root->right)) + 1;

    }
};

226.翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

• TreeNode类定义了二叉树的节点结构，包括节点值val以及指向左右子节点的指针left和right。
• Solution类中的invertTree方法负责翻转二叉树：
  • 基本情况：如果遇到空节点，则递归结束，直接返回None。
  • 节点交换：使用Python的元组解包特性同时交换左右子节点。
  • 递归翻转：对当前节点的左右子树递归调用invertTree方法，以翻转整棵树。
  • 返回值：方法返回翻转后的树的根节点。

复杂度分析

• 时间复杂度：O(n)，其中n是树中的节点数。递归过程中每个节点被访问一次。
• 空间复杂度：O(h)，其中h是树的高度，代表递归调用栈的最大深度。在最坏的情况下（树完全不平衡时），空间复杂度为O(n)。

python

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        # 基本情况：如果当前节点为空，则直接返回None
        if root is None:
            return None
        
        # 交换当前节点的左右子节点
        root.left, root.right = root.right, root.left
        
        # 递归地翻转当前节点的左子树和右子树
        self.invertTree(root.left)
        self.invertTree(root.right)
        
        # 返回根节点，此时的树已经被翻转
        return root

 C++

/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {
        // 基本情况：如果当前节点为空，则直接返回null
        if (root == nullptr) {
            return nullptr;
        }

        // 交换当前节点的左右子节点
        TreeNode* temp = root->left;
        root->left = root->right;
        root->right = temp;

        // 递归地翻转当前节点的左子树和右子树
        invertTree(root->left);
        invertTree(root->right);

        // 返回根节点，此时的树已经被翻转
        return root;

    }
};

101.对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

• isSymmetric方法检查给定的树是否是轴对称的。它主要通过调用isMirror来完成，isMirror检查两个树是否是彼此的镜像。
• isMirror是一个私有辅助方法，它递归地检查两个树是否是镜像对称的。具体来说，它首先检查两个树的根节点的值是否相等，然后递归地检查左树的左孩子和右树的右孩子、左树的右孩子和右树的左孩子是否分别镜像对称。
• 通过递归调用isMirror，可以深入每个节点进行比较，直到所有的节点都被比较过，或者在发现不对称的情况下提前返回。

python

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if root is None:
            return True
        return self.isMirror(root.left, root.right)

    def isMirror(self, left: TreeNode, right: TreeNode) -> bool:
        if left is None and right is None:
            return True
        if left is None or right is None or left.val != right.val:
            return False
        return self.isMirror(left.left, right.right) and self.isMirror(left.right, right.left)

C++

/**
 * 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:
    bool isSymmetric(TreeNode* root) {
        if (!root) return true;
        // 检查树是否是自己的镜像
        return isMirror(root->left, root->right);
    }
private:
    bool isMirror(TreeNode* t1, TreeNode* t2) {
        // 如果两个树都为空，则它们是镜像对称的
        if (!t1 && !t2) return true;
        // 如果其中一个为空另一个不为空，或者两个都不为空但值不同，则不是镜像对称的
        if (!t1 || !t2 || t1->val != t2->val) return false;
        // 递归比较左树的左孩子和右树的右孩子，以及左树的右孩子和右树的左孩子
        return isMirror(t1->left, t2->right) && isMirror(t1->right, t2->left);
    }
};