Skip to content

Commit 5ad35b8

Browse files
hi-dhlhi-dhl
committed
feat: update question
1 parent ec24dd8 commit 5ad35b8

File tree

50 files changed

+520
-202
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

50 files changed

+520
-202
lines changed

‎leetcode/arrays/01-two-sum-ii-input-array-is-sorted.md‎

Lines changed: 12 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -56,7 +56,9 @@ public int[] twoSum(int[] numbers, int target) {
5656
2. 如果numbers[low] 和 numbers[height]的和sum小于target，则low++
5757
3. 如果numbers[low] 和 numbers[height]的和sum大于target，则height--
5858

59-
### Java实现
59+
<!-- tabs:start -->
60+
61+
### **Java 实现**
6062

6163
```
6264
public class Solution {
@@ -78,7 +80,7 @@ public class Solution {
7880
}
7981
```
8082

81-
### Kotlin实现
83+
### **Kotlin 实现**
8284

8385
```
8486
class Solution {
@@ -98,6 +100,8 @@ class Solution {
98100
}
99101
```
100102

103+
<!-- tabs:end -->
104+
101105
## 思路三：二分法查找
102106

103107
题目可知找两个数之和 a+b = taget，循环数组每一个元素a, 从剩余的元素里面用二分法查找另外一个元素 b= taget-a 即可，时间复杂度为o(nlogn)
@@ -106,7 +110,9 @@ class Solution {
106110
2. 从剩余元素用二分法查找元素b = taget-a，返回索引idnex,
107111
3. 如果index ==-1 ，则无结果返回，如果index!=-1，则直接返回a+1,index+1
108112

109-
### Java实现
113+
<!-- tabs:start -->
114+
115+
### **Java 实现**
110116

111117
```
112118
public class Solution {
@@ -136,7 +142,7 @@ public class Solution {
136142
}
137143
```
138144

139-
### kotlin 实现
145+
### **kotlin 实现**
140146

141147
```
142148
class Solution {
@@ -168,3 +174,5 @@ class Solution {
168174
}
169175
```
170176

177+
<!-- tabs:end -->
178+

‎leetcode/binary-search/01-square.md‎

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -44,14 +44,16 @@
4444

4545
**如何确定 x 的区间范围：[low, height]？**
4646

47-
根据上面的概念 **完全平方数** 是某个整数的平方的数，也就是说 **完全平方数 = n *n**，例如，9 = 3 × 3
47+
根据上面的概念 **完全平方数** 是某个整数的平方的数，也就是说 **完全平方数 = n \* n**，例如，9 = 3 × 3
4848

4949
* 当 x >= 2 时：它的整数平方根一定小于 x / 2 且大于 0，即 0 < a < x / 2
5050
* 当 x =1 时：即 1 / 2 的值为0了，所以为了兼顾 1 的特殊情况，需要将边界设为 x / 2 +1
5151

5252
综合以上两种情况 x 的区间范围：[0, x / 2 + 1]，为了提高效率所以使用了位运算符，即 x/2 等价于 x >>> 1
5353

54-
### Java实现
54+
<!-- tabs:start -->
55+
56+
### **Java 实现**
5557

5658
```
5759
public class Solution {
@@ -74,7 +76,7 @@ public class Solution {
7476
}
7577
```
7678

77-
### Koltin实现
79+
### **Koltin 实现**
7880

7981
```
8082
class Solution {
@@ -96,3 +98,5 @@ class Solution {
9698
}
9799
```
98100

101+
<!-- tabs:end -->
102+

‎leetcode/binary-search/02-x-square.md‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,9 @@
4646

4747
综合以上两种情况 x 的区间范围：[0, x / 4 + 1]，为了提高效率所以使用了位运算符，即 x/4 等价于 x >>> 2
4848

49-
### Java实现
49+
<!-- tabs:start -->
50+
51+
### **Java 实现**
5052

5153
```
5254
class Solution {
@@ -70,7 +72,7 @@ class Solution {
7072
}
7173
```
7274

73-
### Kotlin 实现
75+
### **Kotlin 实现**
7476

7577
```
7678
class Solution {
@@ -92,3 +94,5 @@ class Solution {
9294
}
9395
```
9496

97+
<!-- tabs:end -->
98+

‎leetcode/binary-search/03-find-letter.md‎

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -59,10 +59,11 @@ target = "k"
5959

6060
但是这题目有个坑，就是题意给的不准确，笔者也提交几次才通过，总结规律如下：
6161

62-
* 当 target < letters[0] 时，即 letters[0] 是比目标字母大的最小字母，返回 letters[0]
63-
* 当 target >= letters[height -1], 即返回 letters[0]
62+
当 `target < letters[0]` 或者 `target >= letters[height -1]` 时，即 letters[0] 是比目标字母大的最小字母，返回 letters[0]
6463

65-
### Java 实现
64+
<!-- tabs:start -->
65+
66+
### **Java 实现**
6667

6768
```
6869
class Solution {
@@ -83,7 +84,7 @@ class Solution {
8384
}
8485
```
8586

86-
### Koltin 实现
87+
### **Koltin 实现**
8788

8889
```
8990
class Solution {
@@ -108,3 +109,5 @@ class Solution {
108109
}
109110
```
110111

112+
<!-- tabs:end -->
113+

‎leetcode/binary-tree/01-binary-tree-preorder.md‎

Lines changed: 13 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,9 @@ Output: [1,2,3]
3838
* 时间复杂度：O(n)，n 为节点的数量
3939
* 空间复杂度：O(n)，n 为节点的数量
4040

41-
### Java 实现
41+
<!-- tabs:start -->
42+
43+
### **Java 实现**
4244

4345
```
4446
class Solution {
@@ -85,7 +87,7 @@ class Solution {
8587
}
8688
```
8789

88-
### Kotlin 实现
90+
### **Kotlin 实现**
8991

9092
```
9193
class Solution {
@@ -105,6 +107,8 @@ class Solution {
105107
}
106108
```
107109

110+
<!-- tabs:end -->
111+
108112
## 思路二：递归
109113

110114
**递归的两个特点：**
@@ -134,7 +138,10 @@ preorder(root) = preorder(root->left) + preorder(root->right)
134138
* 时间复杂度：O(n)，n 为节点的数量
135139
* 空间复杂度：O(n)，n 为节点的数量，最坏情况下需要空间O(n)，平均情况为O(log2^n)
136140

137-
### Java 实现
141+
<!-- tabs:start -->
142+
143+
144+
### **Java 实现**
138145

139146
```
140147
class Solution {
@@ -151,7 +158,7 @@ class Solution {
151158
}
152159
```
153160

154-
### Kotlin 实现
161+
### **Kotlin 实现**
155162

156163
```
157164
class Solution {
@@ -172,3 +179,5 @@ class Solution {
172179
}
173180
```
174181

182+
<!-- tabs:end -->
183+

‎leetcode/binary-tree/02-binary-tree-inorder.md‎

Lines changed: 12 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -36,7 +36,9 @@
3636
* 时间复杂度：O(n)，n 为节点的数量
3737
* 空间复杂度：O(n)，n 为节点的数量
3838

39-
### Java 实现
39+
<!-- tabs:start -->
40+
41+
### **Java 实现**
4042

4143
```
4244
class Solution {
@@ -64,7 +66,7 @@ class Solution {
6466
}
6567
```
6668

67-
## kotlin 实现
69+
### **kotlin 实现**
6870

6971
```
7072
class Solution {
@@ -87,6 +89,8 @@ class Solution {
8789
}
8890
```
8991

92+
<!-- tabs:end -->
93+
9094
## 思路二：递归
9195

9296
中序遍历递归思路和前序遍历大概一致，根据递归的两个特点去思考
@@ -101,7 +105,9 @@ class Solution {
101105
* 时间复杂度：O(n)，n 为节点的数量
102106
* 空间复杂度：O(n)，n 为节点的数量，最坏情况下需要空间O(n)，平均情况为O(log2^n)
103107

104-
### java 实现
108+
<!-- tabs:start -->
109+
110+
### **Java 实现**
105111

106112
```
107113
class Solution {
@@ -117,7 +123,7 @@ class Solution {
117123
}
118124
```
119125

120-
### kotlin 实现
126+
### **kotlin 实现**
121127

122128
```
123129
class Solution {
@@ -139,3 +145,5 @@ class Solution {
139145
```
140146

141147

148+
<!-- tabs:end -->
149+

‎leetcode/binary-tree/03-binary-tree-postorder.md‎

Lines changed: 12 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -40,7 +40,9 @@
4040
* 时间复杂度：O(n)，n 为节点的数量
4141
* 空间复杂度：O(n)，n 为节点的数量
4242

43-
### Java 实现
43+
<!-- tabs:start -->
44+
45+
### **Java 实现**
4446

4547
```
4648
class Solution {
@@ -67,7 +69,7 @@ class Solution {
6769
}
6870
```
6971

70-
### Kotlin 实现
72+
### **Kotlin 实现**
7173

7274
```
7375
class Solution {
@@ -88,6 +90,8 @@ class Solution {
8890
}
8991
```
9092

93+
<!-- tabs:end -->
94+
9195
## 思路二：递归
9296

9397
后序遍历的递归思路和中序遍历、前序遍历大概一致，根据递归的两个特点去思考
@@ -102,7 +106,9 @@ class Solution {
102106
* 时间复杂度：O(n)，n 为节点的数量
103107
* 空间复杂度：O(n)，n 为节点的数量，最坏情况下需要空间O(n)，平均情况为O(log2^n)
104108

105-
### Java 实现
109+
<!-- tabs:start -->
110+
111+
### **Java 实现**
106112

107113
```
108114
class Solution {
@@ -118,7 +124,7 @@ class Solution {
118124
}
119125
```
120126

121-
### Kotlin 实现
127+
### **Kotlin 实现**
122128

123129
```
124130
class Solution {
@@ -139,3 +145,5 @@ class Solution {
139145
}
140146
```
141147

148+
<!-- tabs:end -->
149+

‎leetcode/binary-tree/04-binary-tree-level-order.md‎

Lines changed: 11 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -81,7 +81,9 @@ element 与 peek 方法用于在队列的头部查询元素，如果队列为空
8181
* 时间复杂度：O(n)，n 是二叉树中的节点个数
8282
* 空间复杂度：O(n)，n 是二叉树中的节点个数，需要一个 list 存储访问的所有节点
8383

84-
### Java 实现
84+
<!-- tabs:start -->
85+
86+
### **Java 实现**
8587

8688
```
8789
class Solution {
@@ -112,7 +114,7 @@ class Solution {
112114
}
113115
```
114116

115-
### Kotlin 实现
117+
### **Kotlin 实现**
116118

117119
```
118120
class Solution {
@@ -140,6 +142,7 @@ class Solution {
140142
}
141143
```
142144

145+
<!-- tabs:end -->
143146

144147
## 思路二：DFS
145148

@@ -150,7 +153,9 @@ DFS: 深度优先搜索算法（Depth-First-Search），是搜索算法的一种
150153
* 时间复杂度：O(n)，n 是二叉树中的节点个数
151154
* 空间复杂度：O(height)，height 为树的高度，递归函数需要栈空间，而栈空间取决于递归的深度，因此空间复杂度等价于二叉树的高度
152155

153-
### Java 实现
156+
<!-- tabs:start -->
157+
158+
### **Java 实现**
154159

155160
```
156161
class Solution {
@@ -173,7 +178,7 @@ class Solution {
173178
}
174179
```
175180

176-
### Kotlin 实现
181+
### **Kotlin 实现**
177182

178183
```
179184
class Solution {
@@ -197,3 +202,5 @@ class Solution {
197202
}
198203
```
199204

205+
<!-- tabs:end -->
206+

‎leetcode/binary-tree/05-binary-tree-construct.md‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -67,7 +67,9 @@
6767
* 时间复杂度：O(n), 遍历每一个节点，重建二叉树
6868
* 空间复杂度：O(height)，height 为树的高度，递归函数需要栈空间，而栈空间取决于递归的深度，因此空间复杂度等价于二叉树的高度
6969

70-
### Kotlin 实现
70+
<!-- tabs:start -->
71+
72+
### **Kotlin 实现**
7173

7274
```
7375
class Solution {
@@ -112,7 +114,7 @@ class Solution {
112114
}
113115
```
114116

115-
### Java 实现
117+
### **Java 实现**
116118

117119
```
118120
class Solution {
@@ -153,4 +155,6 @@ class Solution {
153155
}
154156
```
155157

158+
<!-- tabs:end -->
159+
156160

0 commit comments

Comments
 (0)