1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 定义三个成员变量 2.1.1 max，返回的结果 2.1.2 sum，所有元素相加的结果 2.1.3 temp，元素与索引相乘

1.关于复杂度 1.1 时间复杂度为O(n^2) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 定义一个数组以及用索引值初始化值 2.2 正向遍历 2.2.1 将2.1定义的数组与当前元素相乘，对比更新返回的result 2.

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 循环遍历数组，获取字符串中 1 的数量 2.2 从 0 到 length - 1 遍历数组，若当前元素为 0，temp 自增，否则 temp 自减，对比交换 temp 以及 re

1.关于复杂度 1.1 时间复杂度为O(log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于动态规划 2.2 二分遍历数组查找插入的位置 2.3 返回左指针 3.提交记录 3.1 力扣中耗时1ms,消耗37.1MB内存

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 本解法基于桶排序 2.2 统计得到数组内最大最小值 2.3 根据数组长度形成桶，每个桶都含有一定范围内数组的元素 2.4 将数组所有元素加入到桶中 2.5 根据非空桶

1.About Complexity 1.1 Time Complexity is O(n) 1.2 Space Complexity is O(1) 2.how I solve 2.1 define array with length 82(upper to 9 + 9 +

1.About Complexity 1.1 Time Complexity is O(n) 1.2 Space Complexity is O(1) 2.how I solve 2.1 traverse array, define pointer to record del

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 解法基于深度优先遍历 2.2 递归遍历树 2.2.1 若当前节点没有左右孩子，返回1 2.2.2 若当前节点没有左孩子，返回右子树的深度 2.2.

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 因为题目指出待遍历的树是二叉搜索树，所以中序遍历结果肯定为有序数组 2.2 因为题目要求求出结点的最小距离，所以这个距离肯定发生在相邻结点之间 2.3 定义两

1. 关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2. 我的解题思路 2.1 定义两个临时变量记录计算的情况 2.2 循环遍历1到数组长度的元素，循环相加数组中元素，两个临时变量比较以及交换 2.3 如果最终结果大于0就返回1，否则返回最重结果的最

1. 关于复杂度 1.1 时间复杂度为O(log n) 1.2 空间负责度为O(1) 2. 我的解题思路 2.1 这个算法基于二分查找 2.2 循环n到n实现 3. 提交记录 3.1 力扣中耗时3ms,消耗43.85MB内存 3.2 leetcode中

@return the next smallest number

1.关于复杂度 1.1 时间复杂度为O(m+n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 因为我们需要得到当前元素在nums2的下一个最大元素，所以我们可以构成一个当前元素与在在nums2的下一个最大元素的一对一映射 2.2 定义一个栈跟队列缓存结果

1.关于复杂度 1.1 时间复杂度为O(n!) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 循环遍历每一个元素，有两种情况 2.1.1 当前元素为1，深度遍历并改变相邻元素为0，自增result 2.1.2 当前元素为0，继续下一遍

1.关于复杂度 1.1 时间复杂度为O(n^2) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 这个解法基于一个公式：G(n) = G(0) G(n-1)+G(1) (n-2)+...+G(n-1) G(0) 2.2 双重循环修改临时数组的值，外层循环为2到

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 定义两个数组存储计算过程中产生的结果 2.2 循环遍历传入字符串，统计每个字符出现的次数 2.3 通过统计每个数字含有的特征字符次数统计数字出现的次数 2.3.1

1.关于复杂度 1.1 时间复杂度为O(n!) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 因为结果含有片段和，所以我们不能用传统的遍历 2.2 因为结果含有片段和，所以我们可以用双重前序遍历（实在不知道怎么说） 3.提交记录 3.1 力扣中耗时1

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于tank arithmetic 2.2 循环遍历数组获取传入target的index 2.2.1 这个随机变量当target的index多

Removes the element from in front of queue and returns that element.

1.About Complexity 1.1 Time Complexity is O(n) 1.2 Space Complexity is O(n) 2.how I solve 2.1 this solution is base on one formula:num=num

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 这个算法基于一个公式：num=num 2+current element，以下是我的推导过程 2.1.1 最开始，num为0

1.About Complexity 1.1 Time Complexity is O(n) 1.2 Space Complexity is O(n) 2.how I solve 2.1 use traditional recursion to get val from tr

1. 关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2. 我的解题思路 2.1 利用API定义一个栈存储计算过程中的结点 2.2 首先将根节点加入到栈中 2.3 循环直到栈为空 2.3.1 移除栈顶结点并将它的值加入结

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 根据示例的结果，我们应该求出树的最大宽度 2.2 因为我们需要求出最大宽度，满二叉树的宽度是最大的，所以我们可以通过求出树的最大深度进而求出最大宽度 2.3

Push element x to the back of queue.

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于leetcode中国评论区的评论 2.2 用一个整型变量存储偏移量 2.3 同时右移m与n直到他们相等 2.4 返回n左移2.2整型的结果

1.About Complexity 1.1 Time Complexity is O(n) 1.2 Space Complexity is O(1) 2.how I solve 2.1 compare root.val to L and R,there have three

use mod and divide number in recursion to solve 1.About Complexity 1.1 Time Complexity is O(n) 1.2 Space Complexity is O(n) 2.how I solve 2

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 以空格字符为依据切割字符串 2.2 拼接 2.1 中数组最后一个元素，通过 hash 获取具体月份 2.3 根据 day 的长度，判断是否拼接前导 0 3.提交记录 3.

1.About Complexity 1.1 Time Complexity is O(n) 1.2 Space Complexity is O(n) 2.how I solve(this solution isn't prefect enough,I will prefect it

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 循环遍历源字符串，计算空格数量以及形成词列表 2.2 将空格插入到词列表中 2.2.1 源字符串只含有一个词，将所有空格拼接到末尾 2.2.2 源字符串含

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 循环遍历源字符串与索引数组 2.2 基于索引数组，将字符放入到临时数组中 2.3 构建一个新数组并返回 3.提交记录 3.1 力扣中耗时 1ms,消耗 39.6MB 内存

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 定义队列存储遍历当前层的结点 2.2 每次出队结点，左右孩子的添加顺序为右孩子到左孩子 3.提交记录 3.1 力扣中耗时3ms,消耗37MB内存 3.

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 判断并将k减少到数组长度以下等价的值 2.2 定义一个list存储最后的k个元素 2.3 后移0到length-k-1个元素 2.4 将list中元素

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 判断并将k减少到数组长度以下等价的值 2.2 首先反转所有元素 2.3 反转0到k-1的元素 2.4 反转k到最后的元素 3.提交记录 3.1

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于快慢指针 2.2 获取链表长度 2.3 快慢指针，两指针之间的距离为k(k经过length的取余处理) 2.4 循环直到fast的下一结点

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个算法基于BST树的特性 2.2 用val对比当前结点的值，有三种情况 2.2.1 node.val=val，返回当前结点 2.2.

1.About Complexity 1.1 Time Complexity is O(n) 1.2 Space Complexity is O(1) 2.how I solve 2.1 this solution is base on preOrder traverse

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 循环遍历数组，对比 target 与遍历元素的大小 2.2 这个解法很简单，但是不是最快的 3.提交记录 3.1 力扣中耗时 2ms,消耗 39.8MB 内存 3.2 l

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 定义起始位置为 0 以及 n 的双指针 2.2 循环遍历数组，将当前指针的元素放入新数组，返回 3.提交记录 3.1 力扣中耗时 0ms,消耗 40.1MB 内存 3.2

1.About Complexity 1.1 Time Complexity is N/A 1.2 Space Complexity is N/A 2.how I solve 2.1 I think topic is asking us change sex,so I wri

1.关于复杂度 2.我的解题思路 2.1 根据题意，结果输出的国家必须满足以下条件 2.1.1 area>3000000 2.1.2 population>25000000 3.提交记录 3.1 力扣中耗时483ms 3.2 leetcode中耗时216

1.关于复杂度 1.1 时间复杂度为N/A 1.2 空间负责度为N/A 2.我的解题思路 2.1 选择薪水最高的记录 2.2 inner join两个表 3.提交记录 3.1 力扣中耗时513ms 3.2 leetcode中耗时1394ms 4.Q&A 1.About Co

1.我的解题思路 1.1 用DATEDIFF这个函数对比recordDate 1.2 对比两个日期的temperate返回符合条件的id 2.提交记录 2.1 力扣中耗时529ms 2.2 leetcode中耗时355ms 3.Q&A 1.how I solve

1. 关于复杂度 None 2. 我的解题思路 2.1 根据题意，必须返回所有人的信息，所以用Person表左连接address表 3. 提交记录 3.1 力扣中耗时353ms 3.2 leetcode中耗时204ms 4. Q&A 1.About Complexi

1.关于复杂度 N/A 2.我的解题思路 2.1 依据email分类整合为组 2.2 找出各组中最小id的行 2.3 删除组内除2.2行的所有行 3.提交记录 3.1 力扣中耗时924ms 3.2 leetcode中耗时624ms Q&A 1.Abou

381ms and N/A memory in LeetCode China 413ms and MB N/A in LeetCode

1.关于复杂度 1.1 时间复杂度为N/A 1.2 空间负责度为N/A 2.我的解题思路 2.1 内层取出最高的薪水 2.2 外层取出比2.1的薪水小的最大薪水 3.提交记录 3.1 力扣中耗时ms,消耗MB内存 3.2 leetcode中耗时ms,消耗MB内存 4.Q&A

1.关于复杂度 N/A 2.我的解题思路 2.1 对比删除较大id的行 3.提交记录 3.1 力扣中耗时1835ms 3.2 leetcode中耗时854ms 4.Q&A 1.About Complexity N/A 2.how I solve 2.

535ms and N/A memory in LeetCode China 212ms and N/A memory in LeetCode

1. 关于复杂度 1.1 时间复杂度为N/A 1.2 空间负责度为N/A 2. 我的解题思路 2.1 降序排列所有记录 2.2 用limit关键字取出第二高薪水 2.3 主sql语句在内层则为了防止null情况的发生 3. 提交记录 3.1 力扣中耗时109ms,消耗N/A内

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个算法基于二分查找 2.2 根据左右指针获取当前情况的中间索引 2.3 前序递归建立左右子树 3.提交记录 3.1 力扣中耗时1ms,消耗37.4M

1. 关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2. 我的解题思路 2.1 这个解法基于二分查找以及树的中序遍历 2.2 循环遍历head，获取list的长度 2.3 递归中序建立树 2.3.1 根据左右指针获取中

1.About Complexity 1.1 Time Complexity is O(n) 1.2 Space Complexity is O(n) 2.how I solve 2.1 this solution is base on depth traversal

1.关于复杂度 1.1 时间复杂度为O(log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于先序遍历 2.2 判断当前结点的左孩子是否有孩子，如果没有则将它的值相加起来 3.提交记录 3.1 力扣中耗时1ms,消耗34.2MB内存

Method: addTwoNumbers(ListNode l1, ListNode l2)

Method: anotherFindMaxConsecutiveOnes(int[] nums)

Method: arrayPairSum(int[] nums)

Method: average(int[] salary)

Method: balancedStringSplit(String s)

Method: canCompleteCircuit(int[] gas, int[] cost)

Method: canConstructByArray3(String ransomNote, String magazine)

Method: canJumpByBackTracking(int[] nums)

Method: canJumpByInvertedOrder(int[] nums)

Method: canJumpByPositiveSequence(int[] nums)

Method: canMakeArithmeticProgression(int[] arr)

Method: candy(int[] ratings)

Method: checkRecord(String s)

Method: coinChange(int[] coins, int amount)

Method: combinationSum(int[] candidates, int target)

Method: combinationSum2(int[] candidates, int target)

Method: combinationSum3(int k, int n)

Method: compareVersion1(String version1, String version2)

Method: compareVersion2(String version1, String version2)

Method: convert(String s, int numRows)

Method: countBits(int num)

Method: countGoodRectangles(int[][] rectangles)