算法学习——LeetCode力扣二叉树篇2

算法学习——LeetCode力扣二叉树篇2

107. 二叉树的层序遍历 II

107. 二叉树的层序遍历 II - 力扣（LeetCode）

描述

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

示例

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

示例 2：

输入：root = [1]
输出：[[1]]
示例 3：

输入：root = []
输出：[]

提示

• 树中节点数目在范围 [0, 2000] 内
• -1000 <= Node.val <= 1000

代码解析

/**
 * 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) {
   

        vector<vector<int>> result;
       
        queue<TreeNode* > my_que;
        TreeNode* node = root;

        if(root == nullptr) return result;
        else
        {
   
            my_que.push(root);
        }

        while(my_que.empty() != 1)
        {
   
            int size = my_que.size();
            vector<int> nums;
            for(int i=0 ; i<size ;i++ )
            {
   
                node = my_que.front();
                my_que.pop();
                nums.push_back(node->val);

                if(node->left != nullptr) my_que.push(node->left);
                if(node->right != nullptr) my_que.push(node->right);
            }
            result.push_back(nums);
        }
        //和正常的层次遍历二叉树，多一个反转
        reverse(result.begin(),result.end());
        return result;
    }
};

199. 二叉树的右视图

199. 二叉树的右视图 - 力扣（LeetCode）

描述

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

示例

示例 1:

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

示例 2:

输入: [1,null,3]
输出: [1,3]

示例 3:

输入: []
输出: []

提示

• 二叉树的节点个数的范围是 [0,100]
• -100 <= Node.val <= 100

代码解析

/**
 * 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> result;
        queue<TreeNode*> my_que;

        if(root == nullptr) return result;
        TreeNode* cur = root;
        my_que.push(cur);
        while(my_que.empty() != 1)
        {
   
           int size = my_que.size();

           for (int i=0 ; i<size ; i++)
           {
   
               cur = my_que.front();
               my_que.pop();
               //此时为该层次的最右点
               if(i == size-1) result.push_back(cur->val);

               if(cur->left != nullptr) my_que.push(cur->left);
               if(cur->right != nullptr) my_que.push(cur->right);
           }
        }
        return result;

    }
};

637. 二叉树的层平均值

637. 二叉树的层平均值 - 力扣（LeetCode）

描述

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

示例

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。

示例 2:

输入：root = [3,9,20,15,7]
输出：[3.00000,14.50000,11.00000]

提示

• 树中节点数量在 [1, 104] 范围内
• -231 <= Node.val <= 231 - 1

代码解析

/**
 * 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>  result;
        TreeNode* node ; 
        queue<TreeNode*> my_que; 

        if(root == nullptr) return result;
        else 
        {
   
            my_que.push(root);
        }

        while(my_que.empty() != 1)
        {
   
            int size = my_que.size(); 
            double sum = 0;
        
            for(int i=0 ; i<size ; i++) 
            {
   
                node = my_que.front(); 
                my_que.pop();
              
                sum = sum + (double)node->val;

                if(node->left != nullptr)    my_que.push(node->left);
                if(node->right != nullptr)   my_que.push(node->right);

            }
           result.push_back(sum/size);
        }
        return result;

    }
};

429. N 叉树的层序遍历

429. N 叉树的层序遍历 - 力扣（LeetCode）

描述

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

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

示例

示例 1：

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

示例 2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

提示

• 树的高度不会超过 1000
• 树的节点总数在 [0, 10^4] 之间

代码解析

class Node {
   
public:
    int val;
    vector<Node*> children; //子节点为vector

    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;
        Node* node ; //迭代节点
        queue<Node*> my_que; //队列

        if(root == nullptr) return result;
        else // 根节点进队列
        {
   
            my_que.push(root);
        }

        while(my_que.empty() != 1)
        {
   
            int size = my_que.size(); //size是不断变化的，指每一层级的点数量
            vector<int> nums;//每一层级存放的点  
            //将每一层的点从队列弹出放入nums，并且下一个层级点放入队列
            for(int i=0 ; i<size ; i++) 
            {
   
                node = my_que.front(); //该层级的点弹出放入数组
                my_que.pop();
                nums.push_back(node->val);
                //每一个弹出点的下一个层级左右节点压入队列
                for(int j=0 ; j < node->children.size() ;j++)
                {
   
                    if(node->children[j] != nullptr)    my_que.push(node->children[j]);
                }

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

    }
};

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

515. 在每个树行中找最大值 - 力扣（LeetCode）

描述

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

示例

示例1：

输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]

示例2：

输入: root = [1,2,3]
输出: [1,3]

提示

• 二叉树的节点个数的范围是 [0,104]
• -231 <= Node.val <= 231 - 1

代码解析

/**
 * 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;
        TreeNode* node ;
        queue<TreeNode*> my_que; 

        if(root == nullptr) return result;
        else 
        {
   
            my_que.push(root);
        }

        while(my_que.empty() != 1)
        {
   
            int size = my_que.size();
            int num = 0;  
           
            for(int i=0 ; i<size ; i++) 
            {
   
                node = my_que.front(); 
                my_que.pop();
                
                if(i==0)num = node->val;
                if(node->val > num) num = node->val;

               
                if(node->left != nullptr)    my_que.push(node->left);
                if(node->right != nullptr)   my_que.push(node->right);

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

    }
};