2021_01_20 LeetCode刷题

617. 合并二叉树

个人认为是一道简单模拟题目吧，对于当前节点，先判定两棵树中哪棵不为空，然后合并，之后直接递归的对于左子树和右子树分别进行相应的操作即可。但是自己实现的代码一直报错，在合并过程中说是会存在空指针的情况，所以直接使用了官方的题解代码。

/**
 * 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* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == nullptr) {
            return t2;
        }
        if (t2 == nullptr) {
            return t1;
        }
        auto merged = new TreeNode(t1->val + t2->val);
        merged->left = mergeTrees(t1->left, t2->left);
        merged->right = mergeTrees(t1->right, t2->right);
        return merged;
    }
};

637. 二叉树的层平均值

简单模拟题。首先遍历树，对于每一层的层数在遍历的时候进行记录，对于每一层的叶子节点进行求和，同时记录节点的个数。遍历完成之后，求取每一层的平均值，之后存入数组中即可。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        double ans[1001] = {0.0};
        int p[1001] = {0};
        vector<double> ans1;
        dfs(root,0,ans,p);
        for(int i = 0; i < 1001; i++) {
            if(p[i] == 0)
                break;
            else
                ans1.push_back(ans[i] / p[i]);
        }
        return ans1;
    }
    void dfs(TreeNode* root,int depth,double* ans,int* p) {
        if(root == nullptr)
            return;
        ans[depth] += root -> val;
        p[depth] += 1;
        dfs(root -> left, depth + 1, ans, p);
        dfs(root -> right, depth + 1, ans, p);
    }
};

643. 子数组最大平均数 I

简单模拟题。采用类型双端队列的数据结构，对于第一组的k个数据，计算求和，之后每次移动一个位置，减去长度为k的队列的第一个数据的数值，加上最后一个数据的数值，得到新的结果，每次对比求出最大数值，即可得到答案。

class Solution {
public:
    double findMaxAverage(vector<int>& nums, int k) {
        int start = 0,end1 = k - 1;
        int length1 = nums.size();
        double ans = 0.0, sum = 0.0;
        for(int i = start; i <= end1; i++) {
            sum += nums[i];
        }
        ans = sum;
        for(int i = end1 + 1;i < length1; i++) {
            sum += nums[i];
            sum -= nums[i - k];
            ans = max(ans,sum);
        }
        return ans / k;
    }
};

653. 两数之和 IV - 输入 BST

一道递归题目硬生生做成了模拟题目...最初的想法是运用BST的性质，比根节点大的数值都在右子树，比根节点数值小的都在右子树，然后打算逐一遍历每个每个节点，然后再遍历树一遍，这样就可以达到目的，但是写不出来，然后就改为了存储每个节点的数值，然后遍历一遍所有数值判定是否有两个节点求和为目标数值的情况。为了防止有两个数值一样然后相加为目标数值，但是只有一个数值的情况，所以中途的判定写的稍微复杂了一点点。

/**
 * 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 findTarget(TreeNode* root, int k) {
        if(root == nullptr)
            return false;
        map<int,int> p;
        vector<int> z;
        dfs(root,p,z);
        int length = z.size();
        bool flag = false;
        for(int i = 0;i < length; i++) {
            if(p[k-z[i]] != 0) {
                if(k - z[i] == z[i]) {
                    if(p[z[i]] >= 2) {
                        flag = true;
                        break;
                    }
                } else {
                    flag = true;
                    break;
                }
            }
        }
        return flag;
    }
    void dfs(TreeNode* root,map<int,int>& p,vector<int>& z) {
        if(root == nullptr)
            return;
        p[root->val] += 1;
        z.push_back(root->val);
        dfs(root->left,p,z);
        dfs(root->right,p,z);
    }
};