PlantsVsZombies of Crazy /植物大战僵尸杂交版 PlantsVsZombies of Crazy By Chinese ProgrammerAs the video shows, there are some problems，and the language only is Chinese,if you speak Chinese，you'd better have a try. click me to download

MYSQL八股 VARCHAR(100)和VARCHAR(10)的区别是什么?二者在磁盘中占的大小是相同的，但是100能存储的数据更多，如果10想存储更多，需要改变结构在内存中100占用更多，因为要分配固定大小的内存来存储为什么不推荐使用 TEXT 和 BLOB？● 检索性差● 不能有默认值● 不能直接创建索引，需要指定前缀长度● 消耗大量网络和IO● 在使用临表时不能使用内存临表，只能创建硬盘临表DATETIME 和 TIMESTAMP 的区别是什么？DATETIME大小为5-8字节，根据是否有毫秒表示DATETIME无时区，表示范围1000-9999TIMESTAMP4-7字节有时区，范围1970-2038NULL 和 '' 的区别是什么？● NULL在一定条件下是不等的select null=null结果为false,但是在dictinct group by又是相等的● null要占大小，''不需要占大小● null存在字段中的时候，使用count(字段)是会排除null的，只计算非null● 比较时要用is null 比较 ''可以直接比较为什么 MySQL 不建议使用 NULL 作为列默认值？在对某个字段进行计数的时候，会因为null，而无法正确的计数还会因为null占大小，造成不必要的磁盘开销MSQL的存储引擎了解吗？● MYSQL存储引擎是插件式架构，且是基于表的，可以为不同的表设置不同的存储引擎，也可以按MYSQL提供的标准自定义存储引擎MyISAM 和 InnoDB 有什么区别？● InnoDB支持行级锁，MyISAM不支持行级锁，只支持表级锁，锁竞争更激烈● InnoDB支持事务，MyISAM不支持事务，InnoDB提供了四种事务级别（读未提交，读已提交，可重复读，可串行化）● InnoDB支持外键● InnoDB支持通过redo log崩溃后安全恢复● InnoDB支持MVCC● InnoDB和MyISAM都是采用B+树，但是实现方式不同● InnoDB性能更高缓存不命中的情况？● 当两个查询语句的字符串不完全一样时不会命中● 当使用聚合函数时不会命中● 当缓存建立后，会根据缓存内容的表是否发生改变，决定缓存是否失效MYSQL有哪些日志？● Error log用来储存mysql启动、关闭过程的日志记录● binary log用来存储对数据库的操作日志● 一般查询日志：已建立连接的客户端发送给mysql的所有查询语句，一般没开● slow_query_log 慢查询日志，可通过慢查询日志解决sql执行慢● redo undo log redo log 是重做日志，undo是回滚日志● relay-log 和binary log 差不多但是relaylog主要是从库● DDL日志，ddl语句执行的元素据操作binary log● 一般对数据库的数据有改变的会被记录到binarylog中，select show这些不会● 即使表结构数据修改操作并未对数据库修改也会被记录● 类型一般有 ○ statement:每一条修改的sql都会被记录,insert update delete ○ row：每一行的变更都会记录 ○ Mixed混合模式：默认使用statement，在有些场景使用row● statement性能更好，磁盘压力小，日志文件小，但是准确性差点● 主要用于主从复制、主主、主备● 刷盘时机：sync_binlog ○ 0 系统决定什么时候刷盘 ○ 1 每一次事务完成都刷 ○ N N个完成之后刷盘● 什么时候重写binlog文件序号递增 ○ mysql重启 ○ 日志文件大小超过阈值 ○ fulsh logs命令后Mysql如何保证持久性innoDB插入的数据都是存在于页中的，为了减少io读取内存中存在buffer poll缓存池，在查询时buffer poll中不存在时，直接读取到buffer pool来直接操作页，当完成操作之后，提交事务时遇到mysql宕机，事务更改失败，违背持久性，引入redolog，记录空间号，页号，偏移量，更新的数据，在提交事务的时候，直接将redo log刷到磁盘上 undo log原子性当事务执行失败，可通过undo log进行回滚操作undo log是逻辑日志，insert时会自动生成记录一条delete事务● 事务可以看作成一组操作，要么都成功，要么都失败● ACID 原子性、一致性、隔离性、持久性脏读当事务1更改数据之后，事务二读取，但是事务1又回滚了，出现脏读脏写当事务1写入之后，事务2又写入，事务1回滚不可重复读事务1在执行读取，事务2对数据进行了操作，导致读出的数据不同幻读事务1读取几行数据，事务2又插入了几条数据，导致事务1幻读四个隔离● read-uncommit 读未提交 脏读、幻读、不可重复读● read-commit 读已提交 幻读、不可重复读● preatable-read可重复读 幻读● serializable 可串行化

128. 最长连续序列 给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。请你设计并实现时间复杂度为 O(n) 的算法解决此问题。示例 1：输入：nums = [100,4,200,1,3,2]输出：4解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。示例 2：输入：nums = [0,3,7,2,5,8,4,6,0,1]输出：9提示：0 <= nums.length <= 105-109 <= nums[i] <= 109拿HashSet存储数组，达到去重，和快速判断是否有这个元素设置一个 longLength = 0,保存最大长度开始遍历数组当当前元素i不存在n-1时，就代表它是这个序列长度中最小的一个，设置int count = 1，这个要算长度的，再设置current = i;开始while(set.contains(current+1)) //判断有无这个数有count++,current +=1;再比较count和longLength,赋值给longLengthreturnclass Solution { public int longestConsecutive(int[] nums) { HashSet<Integer> integers = new HashSet<>(); for (Integer i:nums ) { integers.add(i); } int longLenght = 0; int count = 0; int current = 0; for (Integer i:nums ) { if (!integers.contains(i-1)){ current = i; count = 1; while (integers.contains(current+1)){ current+=1; count++; } longLenght = Math.max(count,longLenght); } } return longLenght; } }

2024-02-15打卡BFS 层序遍历层序遍历给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。示例 1：输入：root = [3,9,20,null,null,15,7] 输出：[[3],[9,20],[15,7]]示例 2：输入：root = [1] 输出：[[1]]示例 3：输入：root = [] 输出：[]提示：树中节点数目在范围 [0, 2000] 内-1000 <= Node.val <= 1000 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNode right) { * this.val = val; * this.left = left; * this.right = right; * } * } */ class Solution { public List<List<Integer>> levelOrder(TreeNode root) { //采用队列形式，父节点进了之后让子节点进 Queue<TreeNode> treeNodes = new LinkedList<>(); List<List<Integer>> arrayLists = new ArrayList<>(); ArrayList<Integer> list = new ArrayList<>(); if (root!=null){ treeNodes.add(root); } while (!treeNodes.isEmpty()){ //只能每一次获取队列的大小，不然会wA int n = treeNodes.size(); for (int i = 0; i < n; i++) { TreeNode poll = treeNodes.poll(); if (poll.left!=null){ treeNodes.add(poll.left); } if (poll.right!=null){ treeNodes.add(poll.right); } list.add(poll.val); } arrayLists.add(list); list = new ArrayList<>(); } return arrayLists; } } //leetcode submit region end(Prohibit modification and deletion)层序遍历 Ⅱ给你二叉树的根节点 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与上题不同的就只是插入大列表的时候是从头插class Solution { public List<List<Integer>> levelOrderBottom(TreeNode root) { LinkedList<TreeNode> treeNodes = new LinkedList<>(); List<List<Integer>> lists = new ArrayList<>(); ArrayList<Integer> integers = new ArrayList<>(); if (root!=null){ treeNodes.add(root); } while(!treeNodes.isEmpty()){ int n = treeNodes.size(); for (int i = 0;i<n;i++){ TreeNode poll = treeNodes.poll(); integers.add(poll.val); if (poll.left!=null){ treeNodes.add(poll.left); } if(poll.right!=null){ treeNodes.add(poll.right); } } lists.add(0,integers); integers = new ArrayList<Integer>(); } return lists; } }给定一个二叉树 root ，返回其最大深度。二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。示例 1：输入：root = [3,9,20,null,null,15,7] 输出：3示例 2：输入：root = [1,null,2] 输出：2提示：树中节点的数量在 [0, 104] 区间内。-100 <= Node.val <= 100class Solution { public int maxDepth(TreeNode root) { Queue<TreeNode> treeNodes = new LinkedList<TreeNode>(); int i = 0; if (root!=null){ treeNodes.add(root); } while(!treeNodes.isEmpty()){ int n = treeNodes.size(); for (int j = 0; j < n; j++) { TreeNode poll = treeNodes.poll(); if (poll.left!=null){ treeNodes.add(poll.left); } if (poll.right!=null){ treeNodes.add(poll.right); } } i++; } return i; } }给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。示例 1：输入：root = [3,9,20,null,null,15,7] 输出：[[3],[20,9],[15,7]]示例 2：输入：root = [1] 输出：[[1]]示例 3：输入：root = [] 输出：[]提示：树中节点数目在范围 [0, 2000] 内-100 <= Node.val <= 100class Solution { public List<List<Integer>> zigzagLevelOrder(TreeNode root) { LinkedList<TreeNode> queue = new LinkedList<TreeNode>(); List<List<Integer>> arrayLists = new ArrayList<>(); ArrayList<Integer> list = new ArrayList<>(); boolean q = false; if (root!=null){ queue.add(root); } while(!queue.isEmpty()){ int n = queue.size(); for (int i = 0; i < n; i++) { TreeNode poll = queue.poll(); list.add(poll.val); if (poll.left!=null){ queue.add(poll.left); } if(poll.right!=null){ queue.add(poll.right); } } if (q){ Collections.reverse(list); } arrayLists.add(list); list = new ArrayList<Integer>(); q=!q; } return arrayLists; } }给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。说明：叶子节点是指没有子节点的节点。示例 1：输入：root = [3,9,20,null,null,15,7] 输出：2示例 2：输入：root = [2,null,3,null,4,null,5,null,6] 输出：5提示：树中节点数的范围在 [0, 105] 内-1000 <= Node.val <= 1000考虑左右都没子节点class Solution { public int minDepth(TreeNode root) { LinkedList<TreeNode> queue = new LinkedList<TreeNode>(); int deep = 0; if (root!=null){ queue.add(root); }else{ return deep; } while(!queue.isEmpty()){ int n = queue.size(); for (int i = 0; i < n; i++) { TreeNode poll = queue.poll(); if (poll.left!=null){ queue.add(poll.left); } if (poll.right!=null){ queue.add(poll.right); } if (poll.left==null&&poll.right==null){ return ++deep; } } deep++; } return deep; } }给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。叶子节点 是指没有子节点的节点。示例 1：输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22 输出：true 解释：等于目标和的根节点到叶节点路径如上图所示。示例 2：输入：root = [1,2,3], targetSum = 5 输出：false 解释：树中存在两条根节点到叶子节点的路径： (1 --> 2): 和为 3 (1 --> 3): 和为 4 不存在 sum = 5 的根节点到叶子节点的路径。示例 3：输入：root = [], targetSum = 0 输出：false 解释：由于树是空的，所以不存在根节点到叶子节点的路径。提示：树中节点的数目在范围 [0, 5000] 内-1000 <= Node.val <= 1000-1000 <= targetSum <= 1000class Solution { public boolean hasPathSum(TreeNode root, int targetSum) { LinkedList<TreeNode> queue = new LinkedList<>(); ArrayList<Integer> integers = new ArrayList<>(); if(root!=null){ queue.add(root); TreeNode poll = queue.poll(); if (poll.left!=null){ poll.left.val += poll.val; queue.add(poll.left); } if (poll.right!=null){ poll.right.val +=poll.val; queue.add(poll.right); } if (poll.left==null&&poll.right==null){ integers.add(poll.val); } } while(!queue.isEmpty()){ int n = queue.size(); for (int i = 0; i < n; i++) { TreeNode poll = queue.poll(); if (poll.left!=null){ poll.left.val += poll.val; queue.add(poll.left); } if (poll.right!=null){ poll.right.val +=poll.val; queue.add(poll.right); } if (poll.left==null&&poll.right==null){ integers.add(poll.val); } } } int i = integers.indexOf(targetSum); if (i!=-1){ return true; }else{ return false; } } }给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：struct Node { int val; Node *left; Node *right; Node *next; }填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。初始状态下，所有 next 指针都被设置为 NULL。示例 1：输入：root = [1,2,3,4,5,6,7] 输出：[1,#,2,3,#,4,5,6,7,#] 解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。示例 2:输入：root = [] 输出：[]提示：树中节点的数量在 [0, 212 - 1] 范围内-1000 <= node.val <= 1000class Solution { public Node connect(Node root) { LinkedList<Node> nodes = new LinkedList<Node>(); ArrayList<Node> list = new ArrayList<Node>(); if(root!=null){ nodes.add(root); } while(!nodes.isEmpty()){ int n = nodes.size(); for (int i = 0; i < n; i++) { Node poll = nodes.poll(); list.add(poll); if (poll.left!=null){ nodes.add(poll.left); } if (poll.right!=null){ nodes.add(poll.right); } } for (int i = 0; i < list.size()-1; i++) { list.get(i).next = list.get(i+1); } list.get(list.size()-1).next=null; list.clear(); } return root; } }

修车的最少时间 给你一个整数数组 ranks ，表示一些机械工的 能力值 。ranksi 是第 i 位机械工的能力值。能力值为 r 的机械工可以在 r * n2 分钟内修好 n 辆车。同时给你一个整数 cars ，表示总共需要修理的汽车数目。请你返回修理所有汽车 最少 需要多少时间。注意：所有机械工可以同时修理汽车。示例 1：输入：ranks = [4,2,3,1], cars = 10输出：16解释：第一位机械工修 2 辆车，需要 4 2 2 = 16 分钟。第二位机械工修 2 辆车，需要 2 2 2 = 8 分钟。第三位机械工修 2 辆车，需要 3 2 2 = 12 分钟。第四位机械工修 4 辆车，需要 1 4 4 = 16 分钟。分钟是修理完所有车需要的最少时间。示例 2：输入：ranks = [5,1,8], cars = 6输出：16解释：第一位机械工修 1 辆车，需要 5 1 1 = 5 分钟。第二位机械工修 4 辆车，需要 1 4 4 = 16 分钟。第三位机械工修 1 辆车，需要 8 1 1 = 8 分钟。分钟时修理完所有车需要的最少时间。提示：1 <= ranks.length <= 1051 <= ranks[i] <= 1001 <= cars <= 106根据题解的思路由于无法判断每一个修车师傅修的具体数量，但是可以假设时间为t则每个师傅修车的数量为sqrt(t/r)，这个函数的自变量为t，故函数为单调递增的将每一个修车师傅的数量加上大于等于cars，那么这个时间就是ok的采用二分法先写一个check()函数 private boolean check(int[] ranks,long m,long cars){ long x=0;//用来求和 for(int i=0;i<ranks.length;i++) { x+=Math.sqrt(m/ranks[i]);//求在当前t下，每一个师傅的修车数，并叠加 } return x>=cars;//是否总数大于cars }再采用二分public long repairCars(int[] ranks, int cars) { long l=0; long r=1l*ranks[0]*cars*cars;//这是假设的最大时间，可以换成rank[rank.length-1]*cars*cars; while(l<r){ long m=l+r>>1;//取中间的时间 if(check(ranks,m,cars)){ r=m;//如果满足check函数，则说明右侧所有时间都可以满足，那我们就需要把中间点向左侧移动 }else{ l=m+1;//同理 } } return l; }完整代码class Solution { public long repairCars(int[] ranks, int cars) { long l=0; long r=1l*ranks[0]*cars*cars;//这是假设的最大时间，可以换成rank[rank.length-1]*cars*cars; while(l<r){ long m=l+r>>1;//取中间的时间 if(check(ranks,m,cars)){ r=m;//如果满足check函数，则说明右侧所有时间都可以满足，那我们就需要把中间点向左侧移动 }else{ l=m+1;//同理 } } return l; } private boolean check(int[] ranks,long m,long cars){ long x=0;//用来求和 for(int i=0;i<ranks.length;i++) { x+=Math.sqrt(m/ranks[i]);//求在当前t下，每一个师傅的修车数，并叠加 } return x>=cars;//是否总数大于cars } }