1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 这个算法基于前序遍历 2.2 如果当前结点不是叶子，继续追加路径 2.3 当前结点为空，将当前工作字符串加入到结果列表中 3.提交记录 3.1 力扣中

1.关于复杂度 1.1 时间复杂度为O(log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 循环计算N的二进制表示 2.2 返回N的前length-N-1的二进制表示 3.提交记录 3.1 力扣中耗时1ms,消耗32.9MB内存 3.

1.About Complexity 1.1 Time Complexity is O(n) 1.2 Space Complexity is O(1) 2.how I solve 2.1 define origin sum is 0 2.2 traverse righ

1.About Complexity 1.1 Time Complexity is O(n^2) 1.2 Space Complexity is O(n) 2.how I solve 2.1 this solution is base on inOrder 2.2 g

1.About Complexity 1.1 Time Complexity is O(n^2) 1.2 Space Complexity is O(n) 2.how I solve 2.1 this solution is base on inOrder and solut

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 对比起始与结束时间并累加结果 3.提交记录 3.1 力扣中耗时 0ms,消耗 37.9MB 内存 3.2 leetcode 中耗时 0ms,消耗 37.5MB 内存 4.Q&

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 因为两个数组所有元素的大小都属于固定的范围，所以我们可以使用计数排序思想解题 2.2 定义一个长度为 1001 的数组 2.3 循环两个数组，target 数组循环相加计数，

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 根据题意，当n<2时返回false 2.2 使用三指针 2.2.1 res,记录计算结果 2.2.2 i,遍历指针 2

1.About Complexity 1.1 Time Complexity is O(n) 1.2 Space Complexity is O(1) 2.how I solve 2.1 according to first and second point,calculat

1. 关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2. 我的解题思路 2.1 排除n<=1的情况 2.2 循环操作n判断结果 2.2.1 如果n%4!=0，表明n不可能是4的幂 2.2.2 用n相除4，继续循

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

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 level order 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 2.2 se

1.关于复杂度 1.1 时间复杂度为O(n^2) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法一定程度上借鉴了分治思想 2.2 找到当前区间的最大元素以及对应的索引，以最大值为值构建当前结点 2.3 利用最大元素的左右区间分别递归构建左右子

标注一下：这个中文解法只是模拟操作灯的亮灭，并没有通过所有测试用例，但是这个解法是 pass 的解法的基础 1. 关于复杂度 1.1 时间复杂度为O(n^2) 1.2 空间负责度为O(1) 2. 我的解题思路 2.1 循环1到n盏灯，根据计算结果独立改变每一盏灯的状态 2.1

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 定义一个整数用于缓存计算结果 2.2 逆中序遍历(遍历右子树，根节点，左子树)二叉树，将当前节点值与缓存值相加后赋回给当前节点和缓存变量 3.提交记录 3.1 力扣中耗时1ms,

1. 关于复杂度 1.1 时间复杂度为O(log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 计算传入数字基于7次幂的倍数(power) 2.2 使用power计算拼接7进制的数字 3.提交记录 3.1 力扣中耗时3ms,消耗34.2MB内存

1.关于复杂度  1.1 时间复杂度为O()  1.2 空间负责度为O() 2.我的解题思路  2.1 这个算法基于深度优先遍历而来  2.2 定义一个整形变量用于存储节点数量  2.3 递归遍历树，每遍历一个节点自增缓存变量 3.提交记录  3.1 力扣中耗时1ms,消耗40MB内存  3.2 l

1.About Complexity 1.1 Time Complexity is O(n^2) 1.2 Space Complexity is O(1) 2.how I solve 2.1 as title say, double traverse array(i < j)

1.关于复杂度 1.1 时间复杂度为O(n^2) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 这个算法基于埃拉托斯特尼筛法 2.2 定义一个boolean数组记录是否为素数 2.3 循环遍历数组，判断marker，将marker的所有倍数的值设为t

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 简单的循环替换字符 3.提交记录 3.1 力扣中耗时 0ms,消耗 37.6MB 内存 3.2 leetcode 中耗时 0ms,消耗 37.5MB 内存 4.Q&A 1.

1.关于复杂度 1.1 时间复杂度为O(1) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个算法基本是删除下一节点的替换策略 2.2 存储待删除结点的下一节点的值 2.3 设定待删除结点的值为2.2的值 2.4 设定待删除结点的下一节点为

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 定义一个数组存储计算结果 2.2 强定义初始值 2.2.1 当 N = 1，没有符合条件的数字，结果为 false 2.2.2 当 N = 2，1 是符合

Returns whether the queue is empty.

1.About Complexity 1.1 Time Complexity is O(n) 1.2 Space Complexity is O(1) 2.how I solve 2.1 traverse string, have two three situation

1.About Complexity 1.1 Time Complexity is O(n) 1.2 Space Complexity is O(1) 2.how I solve 2.1 use a pointer to record current num's index

1.About Complexity 1.1 Time Complexity is O(n) 1.2 Space Complexity is O(n) 2.how I solve 2.1 use a stack to cache operate result 2.2

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 这个解法基于BFS 2.2 传统的BFS，但是在元素入队时右孩子先入队，左孩子后入队 3.提交记录 3.1 力扣中耗时4ms,消耗38.9MB内存 3

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于记录当前层数的DFS 2.2 传统的先序遍历，当当前遍历结点没有孩子（叶结点），对比当前层数以及最大已遍历层数，设置结果val 3.提交记录 3.

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 计算num的位数 2.2 对num的位置以及num进行异或运算后返回 3.提交记录 3.1 力扣中耗时1ms,消耗32.7MB内存 3.2 leetc

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 将num转换成二进制字符串 2.2 循环取反每个元素 2.3 将2.2转换字符串转成int输出 3.提交记录 3.1 力扣中耗时3ms,消耗32.8M

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 循环遍历数组，若nums[index]!=nums[nums[index]-1]，循环交换直到相等 2.2 循环遍历数组，若nums[index]!=index+1，

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 因为题目要求不要申请额外的空间，而数组所有元素都大于 0 ，所以我们可以利用数组索引标记重复元素 2.2 循环遍历数组，获取以当前元素为索引的元素，若此元素小于0，此元素为重复元

1.关于复杂度 1.1 时间复杂度为O(log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于二分查找，用右边界的值作为对比值 2.2 传统的查找，但是在当前值等于对比值的情况下，右指针移向左一位 3.提交记录 3.1 力扣中耗时1ms,消耗38.9M

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 我觉得这道题的关键是在BST上，中序遍历BST可以得到升序的数组，而这个意味着我们可以利用升序数组的特性进行解题 2.2 定义四个变量 2.2.1 l

1.About Complexity 1.1 Time Complexity is O(sqrt(n)) 1.2 Space Complexity is O(1) 2.how I solve 2.1 in a word,there have a rule 2.2 re

1. 关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2. 我的解题思路 2.1 循环1到n，按照题目意思加上字符串 3. 提交记录 3.1 力扣中耗时3ms,消耗42.8MB内存 3.2 leetcode中耗时1ms,消耗38.9MB

1. 关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2. 我的解题思路 2.1 这个解法基于后序遍历 2.2 传统的后序遍历，对每一遍历结点进行如下操作 2.2.1 保存右孩子 2.2.2 将左孩子设置为右孩子

1.关于复杂度 1.1 时间复杂度为O(n+m)(n，m为两个链表的长度) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 当两个链表有相交结点时，无论从长链表或短链表出发，他们的路程是相同的 2.2 定义两个指针分别从长短链表开始遍历，遍历完当前链表换个链表

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 因为题目给出的是二叉搜索树，所以中序遍历后可以得到升序的有序数组 2.2 中序遍历树，用一个暂存变量记录上次遍历的结点值 3.提交记录 3.1 力扣中耗时2m

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 这个解法基于一条公式：G(i)=i^i>>1 2.2 定义循环计算格雷编码 3.提交记录 3.1 力扣中耗时1ms,消耗34.3MB内存 3.2 le

1.关于复杂度 1.1 时间复杂度为 O(log n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 这个解法基于二分查找 2.2 定义左右指针 2.3 使用二分查找寻找待猜数字 2.3.1 计算中间索引 2.3.2 当前中间元素对比 gues

1.关于复杂度 1.1 时间复杂度为O(log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 利用n与n-1的位与运算去除最后一个1，result自增 3.提交记录 3.1 力扣中耗时1ms,消耗33.5MB内存 3.2 leetcode中耗时1ms,消耗33.6

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 转换源数字成为二进制字符串 2.2 遍历字符串，统计1的个数 3.提交记录 3.1 力扣中耗时1ms,消耗33.3MB内存 3.2 leetcode中耗时1ms,消耗33.5

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 将传入的数转换成二进制字符串 2.2 标记第一个字符 2.3 循环第二个到最后一个字符，对比交换2.2的字符，如果当前字符等于2.2中的字符，返回false 3.提交记录

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 位与操作获取源数的最后一位 2.2 循环直到源数为0 2.2.1 右移源数一位 2.2.2 获取当前源数的最后一位 2.2.3 对比并更新2.

@return whether we have a next smallest number

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 这个解法基于深度遍历 2.2 对比当前结点以及sum的值 3.提交记录 3.1 力扣中耗时1ms,消耗37MB内存 3.2 leetcode中耗时0m

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 保存左子树节点 2.2 递归遍历将右子树节点赋给左子树 2.3 递归遍历将左子树节点(2.1保存的)赋给右子树 3.提交记录 3.1 力扣中耗时0ms

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 解法基于深度优先遍历 2.2 递归获取左右子树的深度 2.3 对比左右子树的深度 2.3.1 若出现深度为-1的情况，返回-1到上一层 2.

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 使用两个整数存储计算过程的结果 2.2 使用二重循环计算，又两种情况 2.2.1 计算复原结果为1，这是happy number，返回true

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 定义hash记录当前位置的元素对应关系 2.2 遍历字符串 2.2.1 当前元素已经在hash中，检查value以及另一字符的对应关系

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 将传入数字转换成字符串 2.2 双指针遍历字符，若当前两个字符不相等返回false 3.提交记录 3.1 力扣中耗时10ms,消耗36.2MB内存 3

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 排除能被10整除的数或者负数 2.2 循环构建与传入数相反的数 2.3 判断传入数与构建数是否相等 3.提交记录 3.1 力扣中耗时9ms,消耗36.

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 定义哈希表判断是否含有相交路径，定义两个临时变量存储当前位置 2.2 循环遍历给定路径中所有方向，按照题目要求移动两个临时变量，利用形成的临时字符串判断hash内是否有相交的路径

1.关于复杂度 1.1 时间复杂度为O(log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于二分查找思想，而采用二分的原因是如果一个数字是完全平方数，他的开方必然小于等于他的一半 2.2 使用二分查找去试探获得平方数 2.

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 排除n<=1的情况 2.2 判断当前n取余4是否等于4 2.3 如果当前n%4!=0，递归n/4继续判断 3.提交记录 3.1 力扣中耗时6ms,消耗

用取余跟除法计算结果 1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 手动排除n<=1的情况 2.2 循环n判断结果 2.2.1 如果n%3!=0，就明显表明了没有可能返回true，所以返回fals

1.关于复杂度 1.1 时间复杂度为O(log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于一些位运算的规律 2.2 如果一个数是2的幂，它的二进制表示一定是第一位是1，后面所有都是0 2.3 如果一个数是2的幂，它的减1的结果二

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 主要解法是同时前序遍历两棵树 2.2 树相等，要遵循以下的情况之一 2.2.1 左子树都为空 2.2.2 右子树都为空 2.2.3 当前节点值相等

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 判断树是否为空，若为空肯定是对称二叉树 2.2 递归对比左右子树，有5个情况 2.2.1 左右子树同时为空，返回true 2.2.2

关于复杂度  1.1 时间复杂度为O(n)  1.2 空间负责度为O(1) 我的解题思路  2.1 根据题意可知，丑数的定义为只含有2，3，5任一个质数，重点是在只这个字上  2.2 根据丑数的定义，其实我们可以用原来的数据分别整除掉2，3，5  2.3 在整除完后，如果结果不等于1，就意味着原始数

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 traversal

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2。我的解题思路 2.1 这个解法是基于二叉树的中序遍历 2.2 定义一个变量用于存储上一遍历结点的值 2.3 递归遍历二叉树 2.4 如果左子树返回true，对比根节点与缓存

1. 关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2. 我的解题思路 2.1 获取数组最大元素 2.3 对比 extraCandies 与当前元素相加的结果以及最大值，记录对比结果 3. 提交记录 3.1 力扣中耗时1ms,消耗39.9MB内存

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于中序遍历 2.2 定义两个指针记录遍历的次数以及最后结果 2.3 自减count直到0去除当前遍历结点的值 3.提交记录 3.1 力扣中耗

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于深度优先遍历 2.2 定义一个变量记录当前遍历的层数 2.2.1 list的大小等于当前层数，将当前遍历结点的值加入list中

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于广度优先遍历，定义需要使用的四个变量 2.1.1 list，用于记录返回的结果 2.1.2 queue，用于缓存待遍历的结点

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 level order travers

1.About Complexity 1.1 Time Complexity is O(log n^2) 1.2 Space Complexity is O(log n) 2.how I solve 2.1 use a queue to cache current floor

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 定义队列存储遍历的每一层结点 2.2 在进行出队操作时，获取当前队列的长度 2.3 出队直到到达2.2记录的长度，将出队结点的值放在暂存list中，左右孩子入

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 这个算法基于深度遍历 2.2 统计左右子树的深度，同时判断当前结点val是否等于父节点的val 3.提交记录 3.1 力扣中耗时9ms,消耗51.8MB内存

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 题目指出遍历的树为BST，所以我们可以利用这个点去解题 2.2 当前点与p，q的关系 2.2.1 p，q的值都小于当前结点值，p，q都在左子树上

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 解法基于深度优先遍历 2.2 递归获取左右子树的深度 2.3 对比左右子树的深度，返回较大的一个加上1 3.提交记录 3.1 力扣中耗时1ms,消耗38.2MB内存

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 切割字符串为字符数组 2.2 循环遍历数组，统计括号数量，左括号加 1，右括号减 1，暂存最大值 3.提交记录 3.1 力扣中耗时 1ms,消耗 36.6MB 内存 3.

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 定义一个长度为26的数组存储字母出现次数 2.2 循环遍历字符串统计字母出现的次数 2.3 从数组获取次数，对比并返回最小的次数 3.提交记录 3.1 力扣中耗时 1ms

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 定义哈希存储统计次数 2.2 循环统计字母出现的次数 2.3 从哈希获取次数，对比返回最小值 3.提交记录 3.1 力扣中耗时 12ms,消耗 39.8MB 内存 3

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 因为需要计算任意节点到任意节点的最大路径和，所以下面是我的一点思路 2.1.1 分别计算左右子树的最大路径和，并将他们与0进行比较(如果是负数就不要)

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 因为传入数组所有元素都大于 0，所以我们找出最大的两个元素并相乘就是结果 3.提交记录 3.1 力扣中耗时 0ms,消耗 39.8MB 内存 3.2 leetcode 中耗时

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 定义cost以及pro分别记录当前最大花费以及最大利润 2.2 循环遍历数组对比设计cost以及pro 3.提交记录 3.1 力扣中耗时10ms,消耗73.8

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个算法基于备忘录式的动态规划 2.2 定义两个变量记录当前最小价钱以及最大利润 2.3 循环遍历数组 2.3.1 对比当前价钱以及最小价钱，