2021-11-19每日刷题打卡

2021-11-19每日刷题打卡

力扣——每日一题

397. 整数替换

给定一个正整数 n ，你可以做如下操作：

如果 n 是偶数，则用 n / 2替换 n 。
如果 n 是奇数，则可以用 n + 1或n - 1替换 n 。
n 变为 1 所需的最小替换次数是多少？

示例 1：

输入：n = 8
输出：3
解释：8 -> 4 -> 2 -> 1

我们可以用枚举的情况来计算操作数，这就相当于一个二叉树，只要n不为1，树就向下延伸，当n为1时就是叶子节点了，然后就开始找最小深度即可。

n为偶数时我们只能/2，分支在n为奇数时该-1还是+1，我们利用二叉树的想法，如果n是偶数就除于2然后送去下次递归，如果是奇数就n+1或n-1送去递归。但有一点问题，当n为2^32-1时，我们+1会直接爆内存，所以我们把两步步骤合起来，比较+1或-1后n就是偶数了，直接/2，那我们就把这两步和一起，众所周知，整数除法是向下取整的，所以我们也不用减一了直接/2就行，至于加一我们可以先除然后再加一，比如7+1再/2是4，我们直接/2+1也是4。每次n为偶数时我们直接记上一次步骤然后把n/2送去递归，为奇数我们就记上两次步骤然后分别送n/2-1和n/2去递归，取两者的最小值，最后递归全部结束时，得到的即时最少的步骤数。

class Solution {
public:
    int integerReplacement(int n) {
        if(n==1)return 0;
        if(n%2==0)return 1+integerReplacement(n/2);
        return 2+min(integerReplacement(n/2+1),integerReplacement(n/2));
    }
};

236. 二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

示例 1：

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出：3
解释：节点 5 和节点 1 的最近公共祖先是节点 3 。

送root去递归，每次先判断root是否为空，为空就返回root，然后创建两个节点，一个l判断左子树中有没有p或q的节点，如果有，把拿个节点赋给l，另一个节点r判断右子树。然后判断，如果l为空就返回r节点，如果r为空就返回l节点，如果都不为空说明当前的root就是最近祖先。返回即可。

/**
 * 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:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(!root||root->val==p->val||root->val==q->val)return root;
        TreeNode*l=lowestCommonAncestor(root->left,p,q);
        TreeNode*r=lowestCommonAncestor(root->right,p,q);
        if(!r)return l;
        if(!l)return r;
        return root;
    }
};

226. 翻转二叉树

翻转一棵二叉树。

示例：

输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9

输出：

     4
   /   \
  7     2
 / \   / \
9   6 3   1

递归遍历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:
    TreeNode* invertTree(TreeNode* root) {
        if(!root)return root;
        TreeNode*p=root->left;
        root->left=root->right;
        root->right=p;
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

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

（116给的是完全二叉树，比这题简单一点，但我做法都是一样的，两题都适用）

给定一个二叉树

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

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

示例：

输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），’#’ 表示每层的末尾。

层序遍历，每次把当前节点的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;
        queue<Node*>que;
        que.push(root);
        while(que.size())
        {
            int len=que.size();
            Node*p=new Node(-1);
            for(int i=0;i<len;i++)
            {
                p->next=que.front();
                p=que.front();
                if(que.front()->left)que.push(que.front()->left);
                if(que.front()->right)que.push(que.front()->right);
                que.pop();
            }
            p->next=NULL;
        }
        return root;
    }
    
};