wy的leetcode刷题记录_Day53

wy的leetcode刷题记录_Day53

声明

本文章的所有题目信息都来源于leetcode
如有侵权请联系我删掉!
时间：2022-11-27

前言

补

1752. 检查数组是否经排序和轮转得到

今天的每日一题是：1752. 检查数组是否经排序和轮转得到

题目介绍

给你一个数组 nums 。nums 的源数组中，所有元素与 nums 相同，但按非递减顺序排列。

如果 nums 能够由源数组轮转若干位置（包括 0 个位置）得到，则返回 true ；否则，返回 false 。

源数组中可能存在 重复项 。

注意：我们称数组 A 在轮转 x 个位置后得到长度相同的数组 B ，当它们满足 A[i] == B[(i+x) % A.length] ，其中 % 为取余运算。

示例 1：
输入：nums = [3,4,5,1,2]
输出：true
解释：[1,2,3,4,5] 为有序的源数组。 可以轮转 x = 3个位置，使新数组从值为 3 的元素开始：[3,4,5,1,2] 。

示例 2：
输入：nums = [2,1,3,4]
输出：false
解释：源数组无法经轮转得到 nums 。

思路

简单模拟题：
我的思路简单就是，寻找到数组的分割点，然后将其分割从分割点开始算作第一个元素向后遍历看是否有序即可，这样做省下了空间。至于寻找分割点就是寻找数组中的最小值的下标。其中有较复杂的情况，当最小值不重复的话，那么分割点就是改最小值的下标，然后进行判断。如果最小值重复，那么还需要细分：其中有一个最小值的位置出现在数组的第一个，那么剩下的所有的最小值的位置必须出现在数组的末尾并且连续；最小值的位置未出现在数组的第一个，也就是中间情况，我们需要判断最小值最先出现的位置和最小值最后出现的位置之间是否存在大于最小值的数（也就是最小值出现是否连续），如果不连续那么就不行，因为你选择第一个最小值出现的位置作为分割点，但是此时分割点之后的子序列本省就无序那么重排后的也无序。这里我就简洁了一下，直接不分情况，将分割点直接选为第一次最小值连续出现的位置。
题解思路：

1. 出现两次以上递减直接返回False；
2. 不出现递减，返回True；
3. 出现一次递减，就看nums的最后一个元素是否不大于第一个元素。

代码

class Solution {
public:
    bool check(vector<int>& nums) {
        int check_point=0;
        int n=nums.size();
        
        int min_val=nums[n-1];
        int min_index=n-1;
        for(int i=n-1;i>=0;i--)
        {
            if(nums[i]<min_val)
            {
                min_val=nums[i];
                min_index=i;
            }
            else if(nums[i]==min_val)
            {
                if(abs(i-min_index)==1)
                {
                    min_val=nums[i];
                    min_index=i;
                }
            }
        }



        for(int i=min_index+1;i<min_index+n;i++)
        {
            if(nums[(i-1)%n]>nums[i%n])
                return false;
        }
        return true;
    }
};

class Solution {
public:
    bool check(vector<int>& nums) {
        int n = nums.size(), x = 0;
        for (int i = 1; i < n; ++i) {
            if (nums[i] < nums[i - 1]) {
                x = i;
                break;
            }
        }
        if (x == 0) {
            return true;
        }
        for (int i = x + 1; i < n; ++i) {
            if (nums[i] < nums[i - 1]) {
                return false;
            }
        }
        return nums[0] >= nums[n - 1];
    }
};

收获

简单的模拟题

617. 合并二叉树

617. 合并二叉树

题目介绍

给你两棵二叉树： root1 和 root2 。

想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始。

示例 1：

输入：root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]
输出：[3,4,5,5,4,null,7]

示例 2：
输入：root1 = [1], root2 = [1,2
] 输出：[2,2]

思路

递归：
递归将t2这颗树的节点值加到t1上。

递推：
之前写过一篇对称树，跟本题采用一样的思路，使用一个队列，来将等同位置的节点加入队列，然后取出相加值，如果取出的节点的左右子节点的存在情况不同那么分情况讨论，如果t1不存在左节点，那么用t2的去补，同理。

代码

递归：

/**
 * 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* root1, TreeNode* root2) {
        if(!root1&&!root2)
            return nullptr;
        if(root1==nullptr)
            return root2;
        if(root2==nullptr)
            return root1;
        root1->val+=root2->val;
        root1->left=mergeTrees(root1->left,root2->left);
        root1->right=mergeTrees(root1->right,root2->right);
        return root1;

    }
};

递推：

class Solution {
public:
 TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
    if (t1 == NULL) 
        return t2;
    if (t2 == NULL) 
        return t1;
    queue<TreeNode*> que;
    que.push(t1);
    que.push(t2);
    while(!que.empty()) {
        TreeNode* node1 = que.front(); que.pop();
        TreeNode* node2 = que.front(); que.pop();
        // 此时两个节点⼀定不为空，val相加
        node1->val += node2->val;
        // 如果两棵树左节点都不为空，加⼊队列
        if (node1->left != NULL && node2->left != NULL) {
            que.push(node1->left);
            que.push(node2->left);
        }
        // 如果两棵树右节点都不为空，加⼊队列
        if (node1->right != NULL && node2->right != NULL) {
            que.push(node1->right);
            que.push(node2->right);
        }
        // 当t1的左节点 为空 t2左节点不为空，就赋值过去
        if (node1->left == NULL && node2->left != NULL) {
            node1->left = node2->left;
        }
        // 当t1的右节点 为空 t2右节点不为空，就赋值过去
        if (node1->right == NULL && node2->right != NULL) {
            node1->right = node2->right;
        }
    }
    return t1;
    }
};

收获

二叉树的知识又增加啦！