-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathindex.xml
431 lines (371 loc) · 39.7 KB
/
index.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
<channel>
<title>My Blog</title>
<link>https://lyrace.github.io/</link>
<description>Recent content on My Blog</description>
<image>
<url>https://lyrace.github.io/papermod-cover.png</url>
<link>https://lyrace.github.io/papermod-cover.png</link>
</image>
<generator>Hugo -- gohugo.io</generator>
<lastBuildDate>Sun, 27 Feb 2022 19:44:36 +0800</lastBuildDate><atom:link href="https://lyrace.github.io/index.xml" rel="self" type="application/rss+xml" />
<item>
<title>【Leetcode】844.比较含退格的字符串</title>
<link>https://lyrace.github.io/post/leetcode844/</link>
<pubDate>Sun, 27 Feb 2022 19:44:36 +0800</pubDate>
<guid>https://lyrace.github.io/post/leetcode844/</guid>
<description>844.比较含退格的字符串 题目链接
给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。
**注意：**如果对空文本输入退格字符，文本继续为空。
示例1：
输入：s = &quot;ab#c&quot;, t = &quot;ad#c&quot; 输出：true 解释：s 和 t 都会变成 &quot;ac&quot;。 示例2：
输入：s = &quot;ab##&quot;, t = &quot;c#d#&quot; 输出：true 解释：s 和 t 都会变成 &quot;&quot;。 示例 3：
输入：s = &quot;a#c&quot;, t = &quot;b&quot; 输出：false 解释：s 会变成 &quot;c&quot;，但 t 仍然是 &quot;b&quot;。 提示：
1 &lt;= s.length, t.length &lt;= 200 s 和 t 只含有小写字母以及字符 '#' 重构字符串 当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类</description>
</item>
<item>
<title>【Leetcode】283.移动零</title>
<link>https://lyrace.github.io/post/leetcode283/</link>
<pubDate>Sat, 26 Feb 2022 18:01:08 +0800</pubDate>
<guid>https://lyrace.github.io/post/leetcode283/</guid>
<description>283.移动零 题目链接
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。
示例1：
输入: nums = [0,1,0,3,12] 输出: [1,3,12,0,0] 示例2：
输入: nums = [0] 输出: [0] 提示：
1 &lt;= nums.length &lt;= 10^4^ -2^31^ &lt;= nums[i] &lt;= 2^31^ - 1 解 fast指针遍历
fast指针位置不为0时，把fast位置的元素赋值给slow位置
fast指针为0时，代表数组中有一个0元素
将slow-&gt;结尾的元素赋值0
class Solution { public void moveZeroes(int[] nums) { int slow = 0; int n = nums.length; for (int fast = 0; fast &lt; nums.length; fast++) { if (nums[fast] !</description>
</item>
<item>
<title>【Java笔记】17.接口</title>
<link>https://lyrace.github.io/post/java17/</link>
<pubDate>Sat, 26 Feb 2022 16:12:18 +0800</pubDate>
<guid>https://lyrace.github.io/post/java17/</guid>
<description>接口 一、基本介绍 接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来
interface 接口名{
//属性
//方法：抽象方法、默认实现方法或静态方法
}
class 类名 implements 接口{
// 自己的属性
// 自己的方法
// 必须实现的接口的抽象方法
}
jdk7前，接口的所有方法都没有方法体，即都是抽象方法；jdK8后接口可以有静态方法，默认方法，即接口中可以有方法的具体实现
public interface Inter { // 属性 public int n1 = 10; // 方法 // 接口中抽象方法可以省略abstract public void hi(); // jdk8后，可以有默认实现方法，使用default关键字实现 default public void ok(){ System.out.println(&#34;ok...&#34;); } // jdk8后，可以有静态方法 public static void cry(){ System.out.println(&#34;cry..&#34;); } } // 类实现一个接口，需要将该接口的所有抽象方法都实现 class A implements Inter{ @Override public void hi() { System.</description>
</item>
<item>
<title>【Java笔记】16.抽象类</title>
<link>https://lyrace.github.io/post/java16/</link>
<pubDate>Sat, 26 Feb 2022 14:55:37 +0800</pubDate>
<guid>https://lyrace.github.io/post/java16/</guid>
<description>抽象类 一、介绍 当父类的某些方法需要声明，但又不确定如何实现时，将其声明为抽象方法，这个类就是抽象类
用abstract关键字修饰一个类时，这个类就叫抽象类
访问修饰符 abstract 类名{}
用abstract关键字来修饰一个方法时，这个方法就是抽象方法
访问修饰符 abstract 返回类型 方法名（参数列表）; // 没有方法体
抽象类一般会被继承，其子类来实现抽象方法
二、注意事项 抽象类不能被实例化 抽象类不一定要包含abstract方法，即抽象类可以没有abstract方法，可以有实现的方法 一旦类包含了abstract方法，则这个类必须声明为abstract abstract只能修饰类和方法，不能修饰属性和其它的 抽象类可以有任意成员，比如非抽象方法、构造器、静态属性.. 抽象方法不能有主体，即不能实现 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类 抽象方法不能使用private、final和static来修饰，因为这些关键字都是和重写相违背 public class Abstract01 { } abstract class H{ public abstract void hi(); // 抽象方法 } // 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类 abstract class E{ public abstract void hi(); } abstract class F extends E{ } class G extends E{ @Override public void hi() { // 实现方法，有方法体就行 } } 三、抽象类实践——模板设计模式 3.</description>
</item>
<item>
<title>【Leetcode】26删除有序数组中的重复项</title>
<link>https://lyrace.github.io/post/leetcode26/</link>
<pubDate>Fri, 25 Feb 2022 19:20:32 +0800</pubDate>
<guid>https://lyrace.github.io/post/leetcode26/</guid>
<description>26.删除有序数组中的重复项 题目链接
给你一个升序排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次 ，返回删除后数组的新长度。元素的相对顺序应该保持 一致 。
由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。
将最终结果插入 nums 的前 k 个位置后返回 k 。
不要使用额外的空间，你必须在原地修改输入数组 并在使用O(1)额外空间的条件下完成。
判题标准:
系统会用下面的代码来测试你的题解:
int[] nums = [...]; // 输入数组 int[] expectedNums = [...]; // 长度正确的期望答案 int k = removeDuplicates(nums); // 调用 assert k == expectedNums.length; for (int i = 0; i &lt; k; i++) { assert nums[i] == expectedNums[i]; } 示例1：
输入：nums = [1,1,2] 输出：2, nums = [1,2,_] 解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。 示例2：</description>
</item>
<item>
<title>【Java笔记】15.final</title>
<link>https://lyrace.github.io/post/java15/</link>
<pubDate>Fri, 25 Feb 2022 11:52:31 +0800</pubDate>
<guid>https://lyrace.github.io/post/java15/</guid>
<description>final 一、介绍 final可以修饰类、属性、方法和局部变量
使用final:
不希望类被继承时
final class A{} // class B extends A{} 此时A类不能被继承 不希望父类的某个方法被子类覆盖/重写时
class C{ // 要求hi不能被子类重写，可以使用final修饰hi方法 public final void hi(){} } class D extends C{ //此时不能重写hi()方法 // @Override // public void hi(){ // System.out.println(&#34;重写&#34;); // } } 不希望类的某个属性的值被修改
public class final_ { public static void main(String[] args) { E e = new E(); // e.TAX_RATE = 0.09; 此时不能更改 } } class E{ public final double TAX_RATE = 0.</description>
</item>
<item>
<title>【Java笔记】14.单例设计模式</title>
<link>https://lyrace.github.io/post/java14/</link>
<pubDate>Fri, 25 Feb 2022 11:12:45 +0800</pubDate>
<guid>https://lyrace.github.io/post/java14/</guid>
<description>单例设计模式 一、什么是单例设计模式 采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法 两种方式：饿汉式和懒汉式 二、饿汉式 类加载时创建，不存在线程安全问题
构造器私有化，防止直接new
类的内部创建对象 static
向外暴露一个静态的公共方法
饿汉式可能造成创建了对象但是没有使用
public class SingleTon01 { public static void main(String[] args) { A a = A.getInstance(); //通过方法获取对象 } } class A{ private String name; // 2. 在类的内部直接创建,此时外部不可用 private static A a = new A(&#34;aaa&#34;); // 保证只能创建一个对象 // 1. 将构造器私有化 private A(String name){ this.name = name; } // 3.</description>
</item>
<item>
<title>【Leetcode】27.移除元素</title>
<link>https://lyrace.github.io/post/leetcode27/</link>
<pubDate>Wed, 23 Feb 2022 19:20:29 +0800</pubDate>
<guid>https://lyrace.github.io/post/leetcode27/</guid>
<description>27.移除元素 题目链接
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
说明:
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝 int len = removeElement(nums, val); // 在函数里修改输入数组对于调用者是可见的。 // 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。 for (int i = 0; i &lt; len; i++) { print(nums[i]); } 示例1：
输入：nums = [3,2,2,3], val = 3 输出：2, nums = [2,2] 解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。 示例2：</description>
</item>
<item>
<title>【Java笔记】13.代码块</title>
<link>https://lyrace.github.io/post/java13/</link>
<pubDate>Tue, 22 Feb 2022 15:30:06 +0800</pubDate>
<guid>https://lyrace.github.io/post/java13/</guid>
<description>代码块 一、基本介绍 代码化块又称为初始化块，属于类中的成员，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。
但没有方法名，没有返回，没有参数，只有方法体，且不用通过对象或类显式调用，而是==加载类时==，创建对象时隐式调用。
二、基本语法 1.语法 [修饰符]{
代码
};
修饰符可选，但写的话只能写static 代码块分两类，使用static修饰的交静态代码块，没有static修饰的，叫普通代码块/非静态代码块。 逻辑语句可以为任何逻辑语句 输入、输出、方法调用、循环、判断等 ;可以写，也可以省略 2.用处 如果多个构造器中都有重复的语句，可以抽取到初始化块中。
public class CodeBlock01 { public static void main(String[] args) { Movie movie = new Movie(&#34;xxx电影&#34;); System.out.println(&#34;-----------&#34;); new Movie(&#34;电影&#34;,50,&#34;xx&#34;); } } class Movie{ private String name; private double price; private String director; // 把三个构造器的相同语句放入一个代码块中 // 不管调用那个构造器，创建对象，都会先调用代码块的内容 // 代码块调用的顺序优先于构造器 { System.out.println(&#34;屏幕打开..&#34;); System.out.println(&#34;广告开始..&#34;); System.out.println(&#34;电影开始..&#34;); } public Movie(String name){ System.out.println(&#34;Movie(String name)被调用&#34;); this.name = name; } public Movie(String name,double price){ System.</description>
</item>
<item>
<title>【Java笔记】12.main</title>
<link>https://lyrace.github.io/post/java12/</link>
<pubDate>Tue, 22 Feb 2022 09:28:56 +0800</pubDate>
<guid>https://lyrace.github.io/post/java12/</guid>
<description>main public static void main(String[] args){}
main方法由虚拟机调用
java虚拟机需要调用类的main()方法，该方法的访问权限必须是public
java虚拟机在执行main()方法时不必创建对象&ndash;&gt;该方法必须是static
该方法接收String类型的数组参数，该数组保存执行java命令时传递给所运行的类的参数
cmd中java 执行的程序 参数1 参数2 参数3&hellip; e.g.:java HelloWorld n1 n2 n3
args数组 第一个参数为n1 第二个参数为n2 第三个参数为n3
IDEA中传参数
main()方法中，可以直接调用main方法所在类的静态方法或静态属性，但不能访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象访问类中的非静态成员
</description>
</item>
<item>
<title>【Leetcode】367.有效的完全平方数</title>
<link>https://lyrace.github.io/post/leetcode367/</link>
<pubDate>Mon, 21 Feb 2022 20:14:42 +0800</pubDate>
<guid>https://lyrace.github.io/post/leetcode367/</guid>
<description>367.有效的完全平方数 题目链接
给定一个 正整数 num ，编写一个函数，如果 num 是一个完全平方数，则返回 true ，否则返回 false 。
进阶：不要 使用任何内置的库函数，如 sqrt 。
示例1：
输入：num = 16 输出：true 示例2：
输入：num = 14 输出：false 提示：
1 &lt;= num &lt;= 2^31^ - 1 二分查找 class Solution { public boolean isPerfectSquare(int num) { int left = 1; int right = num; int mid = left + (right - left) / 2; while(left &lt;= right){ if((long)mid * mid == num){ return true; }else if((long)mid * mid &lt; num){ left = mid + 1; }else{ right = mid -1; } mid = left + (right - left) / 2; } return false; } } 乘法可能会越界，强转一下</description>
</item>
<item>
<title>【LeetCode】69.x的平方根(未完)</title>
<link>https://lyrace.github.io/post/leetcode69/</link>
<pubDate>Sun, 13 Feb 2022 12:26:32 +0800</pubDate>
<guid>https://lyrace.github.io/post/leetcode69/</guid>
<description>69.x的平方根 题目链接
给你一个非负整数 x ，计算并返回 x 的算术平方根 。
由于返回类型是整数，结果只保留整数部分 ，小数部分将被舍去 。
注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。
示例1：
输入：x = 4 输出：2 示例2：
输入：x = 8 输出：2 解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。 提示：
0 &lt;= x &lt;= 2 ^31^ - 1 二分查找 class Solution { public int mySqrt(int x) { int left = 1; int right = x; int mid = x / 2; while(left &lt;= right){ if(mid * mid == x){ // 算数平方根是整数的 return mid; } // 乘法超出int范围-&gt;long else if((long)mid * mid &lt; x){ // mid * mid 比 x 小 if((long)(mid + 1) * (mid + 1) &gt; x){ // mid * mid 比 x 小且(mid + 1) * (mid + 1)比 x 大 return mid; }else if((long)(mid + 1) * (mid + 1) == x) { // mid * mid 比 x 小且(mid + 1) * (mid + 1)等于x return mid + 1; }else{ // 否则查找范围在右半边 left = mid + 1; } }else if((long)mid * mid &gt; x){ // 查找范围在左半边 right = mid - 1; } mid = left + (right - left) / 2; } return 0; } } 官方题解 class Solution { public int mySqrt(int x) { int l = 0, r = x, ans = -1; while (l &lt;= r) { int mid = l + (r - l) / 2; if ((long) mid * mid &lt;= x) { ans = mid; l = mid + 1; } else { r = mid - 1; } } return ans; } } 牛顿迭代法 </description>
</item>
<item>
<title>【Java笔记】11 类变量和类方法</title>
<link>https://lyrace.github.io/post/java11/</link>
<pubDate>Thu, 10 Feb 2022 17:39:46 +0800</pubDate>
<guid>https://lyrace.github.io/post/java11/</guid>
<description>类变量和类方法 一、类变量 1.1 什么是类变量 类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象访问时，取到的都是相同值，任何一个该类的对象去修改时，修改的也是同一个变量。
1.2 定义类变量 访问修饰符 static 数据类型 变量名；[推荐]
static 访问修饰符 数据类型 变量名；
1.3 访问类变量 类名.类变量名 或 对象名.类变量名
静态变量的访问修饰符的访问权限和范围和普通属性是一样的。
public class VisticStatic { public static void main(String[] args) { //类名.类变量名 //类变量随着类的加载而创建，没有创建对象实例也可以访问 System.out.println(A.name); A a = new A(); //对象名.类变量名 System.out.println(&#34;a.name=&#34; + a.name); } } class A{ // 类变量的访问必须遵守访问权限 public static String name = &#34;lll&#34;; // 类变量 private int num = 10; // 普通属性/普通成员变量/非静态属性/非静态成员变量/实例变量 } 1.</description>
</item>
<item>
<title>【LeetCode】34. 在排序数组中查找元素的第一个和最后一个位置</title>
<link>https://lyrace.github.io/post/leetcode34/</link>
<pubDate>Sun, 30 Jan 2022 17:08:25 +0800</pubDate>
<guid>https://lyrace.github.io/post/leetcode34/</guid>
<description>34.在排序数组中查找元素的第一个和最后一个位置 题目链接
给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。
示例1：
输入：nums = [5,7,7,8,8,10], target = 8 输出：[3,4] 示例2：
输入：nums = [5,7,7,8,8,10], target = 6 输出：[-1,-1] 示例3：
输入：nums = [], target = 0 输出：[-1,-1] 提示：
0 &lt;= nums.length &lt;= 10^5^
-10^9^ &lt;= nums[i] &lt;= 10^9^
nums 是一个非递减数组
-10^9^ &lt;= target &lt;= 10^9^
二分查找 分三种情况讨论，且在二分查找是，nums[mid]==target时仍更新，才能保证取到的是边界值
class Solution{ int[] searchRange(int[] nums, int target) { // target的左边界 比target小的那个 int leftBorder = getLeftBorder(nums, target); // target的右边界 比target大的那个 int rightBorder = getRightBorder(nums, target); // 情况一 // target 在数组范围的右边或者左边，例如数组{3, 4, 5}，target为2或者数组{3, 4, 5},target为6，此时应该返回{-1, -1} if (leftBorder == -2 || rightBorder == -2) return new int[]{-1, -1}; // 情况三 // target 在数组范围中，且数组中存在target，例如数组{3,6,7},target为6，此时应该返回{1, 1} if (rightBorder - leftBorder &gt; 1) return new int[]{leftBorder + 1, rightBorder - 1}; // 情况二 // target 在数组范围中，且数组中不存在target，例如数组{3,6,7},target为5，此时应该返回{-1, -1} return new int[]{-1, -1}; } // 寻找target的右边界 int getRightBorder(int[] nums, int target) { int left = 0; int right = nums.</description>
</item>
<item>
<title>【LeetCode】35.搜索插入位置</title>
<link>https://lyrace.github.io/post/leetcode35/</link>
<pubDate>Sun, 30 Jan 2022 08:08:25 +0800</pubDate>
<guid>https://lyrace.github.io/post/leetcode35/</guid>
<description>35.搜索插入位置 题目链接
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为O(log n)的算法。
示例1：
输入: nums = [1,3,5,6], target = 5 输出: 2 示例2：
输入: nums = [1,3,5,6], target = 2 输出: 1 示例3：
输入: nums = [1,3,5,6], target = 7 输出: 4 示例4：
输入: nums = [1,3,5,6], target = 0 输出: 0 示例5：
输入: nums = [1], target = 0 输出: 0 提示：
1 &lt;= nums.length &lt;= 104 -104 &lt;= nums[i] &lt;= 104 nums 为无重复元素的升序排列数组 -104 &lt;= target &lt;= 104 二分法 class Solution { public int searchInsert(int[] nums, int target) { int left = 0; int right = nums.</description>
</item>
<item>
<title>【LeetCode】704.二分查找</title>
<link>https://lyrace.github.io/post/leetcode704/</link>
<pubDate>Sun, 30 Jan 2022 08:08:25 +0800</pubDate>
<guid>https://lyrace.github.io/post/leetcode704/</guid>
<description>704.二分查找 题目链接
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例1：
输入: nums = [-1,0,3,5,9,12], target = 9 输出: 4 解释: 9 出现在 nums 中并且下标为 4 示例2：
输入: nums = [-1,0,3,5,9,12], target = 2 输出: -1 解释: 2 不存在 nums 中因此返回 -1 提示：
你可以假设 nums 中的所有元素是不重复的。 n 将在 [1, 10000]之间。 nums 的每个元素都将在 [-9999, 9999]之间。 二分查找 class Solution { public int search(int[] nums, int target) { int left = 0; int right = nums.</description>
</item>
<item>
<title>【LeetCode】4.寻找两个正序数组的中位数（未完）</title>
<link>https://lyrace.github.io/post/leetcode4/</link>
<pubDate>Sat, 29 Jan 2022 18:49:13 +0800</pubDate>
<guid>https://lyrace.github.io/post/leetcode4/</guid>
<description>4.寻找两个正序数组的中位数 题目链接
给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
算法的时间复杂度应该为 O(log (m+n)) 。
示例1：
输入：nums1 = [1,3], nums2 = [2] 输出：2.00000 解释：合并数组 = [1,2,3] ，中位数 2 示例2：
输入：nums1 = [1,2], nums2 = [3,4] 输出：2.50000 解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5 示例3：
输入：nums1 = [0,0], nums2 = [0,0] 输出：0.00000 示例4：
输入：nums1 = [], nums2 = [1] 输出：1.00000 示例5：
输入：nums1 = [2], nums2 = [] 输出：2.</description>
</item>
<item>
<title>【LeetCode】1.两数之和（未完）</title>
<link>https://lyrace.github.io/post/leetcode1/</link>
<pubDate>Fri, 28 Jan 2022 22:19:42 +0800</pubDate>
<guid>https://lyrace.github.io/post/leetcode1/</guid>
<description>1.两数之和 题目链接
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。 示例2：
输入：nums = [3,2,4], target = 6 输出：[1,2] 示例 3：
输入：nums = [3,3], target = 6 输出：[0,1] 提示：
2 &lt;= nums.length &lt;= 104 -109 &lt;= nums[i] &lt;= 109 -109 &lt;= target &lt;= 109 只会存在一个有效答案 遍历 class Solution { public int[] twoSum(int[] nums, int target) { int[] c = new int[2]; for(int i = 0; i &lt; nums.</description>
</item>
<item>
<title>【Java笔记】10 递归</title>
<link>https://lyrace.github.io/post/java10/</link>
<pubDate>Fri, 21 Jan 2022 00:43:56 +0800</pubDate>
<guid>https://lyrace.github.io/post/java10/</guid>
<description>【Java笔记】10 递归 猴子吃桃 有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个。以后每天猴子都吃其中的一半，然后再多吃一个。当到第10天时，想再吃时，发现只有一个桃子了。问：最初共多少个桃子？
public calss Recursion{ public static void main(String[] args){ T t1 = new T(); int day = 0; int peachNum = t1.peach(day); if(peachNum != -1){ System.out.println(&#34;第&#34;+day+&#34;天有&#34;+peachNum+&#34;个桃子&#34;); } } } class T{ /* 1.day=10时 有1个桃子 2.day=9时 有(day10+1)*2=4 3.day=8时 有(day9+1)*2=10 前一天的桃子=(后一天的桃子+1)*2 */ public int peach(int day){ if(day == 10){//第10天，只有1个桃 return 1; }else if(day &gt;= 1&amp;&amp;day &lt;= 9){ return (peach(day+1)+1)*2; }else{ System.out.println(&#34;day在1-10&#34;); return -1; } } } 迷宫问题 public class MiGong{ public static void main(String[] args){ //先创建迷宫，用二维数组表示 int[][] map=new int[8][7]; //先规定map数组的元素值：0表示可以走 1表示障碍物 int[][] map = new int[8][7]; //设置障碍物 for(int i = 0;i &lt; 7;i++){ map[0][i] = 1; map[7][i] = 1; } for(int i = 0;i &lt; 8;i++){ map[i][0] = 1; map[i][6] = 1; } //输出当前的地图 System.</description>
</item>
<item>
<title>【Java笔记】09 面向对象</title>
<link>https://lyrace.github.io/post/java9/</link>
<pubDate>Fri, 21 Jan 2022 00:43:49 +0800</pubDate>
<guid>https://lyrace.github.io/post/java9/</guid>
<description>【Java笔记】09 面向对象 一、类与对象 属性 成员属性=属性=field 访问修饰符 属性类型 属性名； 访问修饰符：public protected 默认 private 属性不赋值有默认值，跟数组默认值相同 方法（成员方法） 当程序执行到方法时，开辟一个独立的栈空间； 执行完毕，或者到return语句时，返回； 返回到调用方法的语句，继续执行后面的代码 方法的定义： 访问修饰符 返回数据类型 方法名（形参列表..）{//方法体 语句； return 返回值； } 同一个类中的方法调用，直接调用即可，不需要创建对象
class A{ //同一个类中的方法调用，直接调用即可，不需要创建对象 pubilc void print(int n){ System.out.println(&#34;输出&#34;); } public void test(){ print(); } } 跨类中的方法调用：A类调用B类方法，需要通过对象名调用。即创建B类的对象，再调用方法
二、方法重载 java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致 方法名：必须相同 形参列表：必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求） 返回类型：无要求
三、可变参数 java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法 可变参数的实参可以为0个或任意多个 可变参数的实参可以为数组 可变参数的本质就是数组 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后 一个形参列表中最多只能出现一个可变参数
public class VarParameter{ public static void main(String[] args){ //求2个、3个、4个...参数的和 HspMethod m = new HspMethod(); System.</description>
</item>
<item>
<title>【Java笔记】08数组</title>
<link>https://lyrace.github.io/post/java8/</link>
<pubDate>Fri, 21 Jan 2022 00:43:44 +0800</pubDate>
<guid>https://lyrace.github.io/post/java8/</guid>
<description>【Java笔记】08数组 一、介绍 数组存放多个同一类型的数据，是引用类型
数组的定义 数据类型[] 数组名 = new 数据类型[大小] int[] a = new int[5]; 先声明，再创建 声明：数据类型 数组名[]；或 数据类型[] 数组名；此时为null 创建：数组名=new 数据类型[大小];
静态初始化 数据类型 数组名[]={元素值，元素值,&hellip;}
注意 1.数组创建后，如果没有赋值，有默认值 int 0,short 0,byte 0,long 0 ,float 0.0,double 0.0,char \u0000,boolean false，String null 2.数组属引用类型，数组型数据是对象（object） 二、数组赋值机制 数组在默认情况下是引用传递，赋的值是地址——&gt;赋值方式为引用传递
//arr2变化会影响到arr1 int[] arr1 = {1,2,3}; int[] arr2 = arr1; arr2[0] = 10; //arr1={10,2,3} 三、应用 排序 内部排序：所有数据加载到内存 外部排序：借助外部存储 冒泡排序 通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素 的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部 //数组[24,69,80,57,13] //第一轮 最大数放最后 24,69,80,57,13-&gt;24,69,80,57,13-&gt;24,69,57,80,13-&gt;24,69,57,13,80 //第二轮 第二大的数放在倒数第二位置 24,69,57,13,80-&gt;24 57 69 13 80-&gt;24 57 13 69 80 //第三轮 第三大的数放在倒数第三位置 24 57 13 69 80-&gt;24 13 57 69 80 //第四轮 第四大的数放在倒数第四位置 13 24 57 69 80 public class BubbleSort { public static void main(String []args) { int[] arr = {24,69,80,57,13}; int temp = 0; for(int i=0;i&lt;arr.</description>
</item>
<item>
<title>【Java笔记】07 控制结构</title>
<link>https://lyrace.github.io/post/java7/</link>
<pubDate>Fri, 21 Jan 2022 00:43:38 +0800</pubDate>
<guid>https://lyrace.github.io/post/java7/</guid>
<description>【Java笔记】07 控制结构 三大流程控制语句：顺序控制、分支控制、循环控制
分支控制 switch 表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以相互比较的类型 switch（表达式）中表达式的返回值必须是byte,short,int,char,enum,String case子句中的值必须是常量，而不能是变量、
//3，4，5月春季，6，7，8月夏季，9，10，11秋季，12，1，2月冬季 Scanner myScanner = new Scanner(System.in); System.out.println(&#34;输入月份&#34;); int m = myScanner.nextInt(); switch(m){ case 3: case 4: case 5: System.out.println(&#34;春季&#34;); break; case 6: case 7: case 8: System.out.println(&#34;夏季&#34;); break; case 9: case 10: case 11: System.out.println(&#34;秋季&#34;); break; case 12: case 1: case 2: System.out.println(&#34;冬季&#34;); break; default: System.out.println(&#34;输入的月份不对&#34;); } break break语句出现在多层嵌套的语句块中，可以通过标签指明要终止的是哪一层语句块 continue语句出现在多层嵌套的语句块中，可以通过标签指明要终止的是哪一层语句块
label1: for(int j=0;j&lt;4;j++){ label2: for(int i=0;i&lt;10;i++){ if(i == 2){ break lable1; } System.</description>
</item>
<item>
<title>【Java笔记】06 进制</title>
<link>https://lyrace.github.io/post/java6/</link>
<pubDate>Fri, 21 Jan 2022 00:40:09 +0800</pubDate>
<guid>https://lyrace.github.io/post/java6/</guid>
<description>【Java笔记】06 进制 一、四种进制 整数的四种表示方法： 1.二进制：0，1，满2进1，以0b或0B开头 2.十进制：0-9，满10进1 3.八进制：0-7，满8进1，以数字0开头表示 4.十六进制：0-15，满16进1，以0x或0X开头表示
int n1 = 0b1010;//二进制，10 int n2 = 1010;//十进制，1010 int n3 = 01010;//八进制，01010 int n4 = 0X10101//十六进制，0X10101 二、进制转换 十进制转二进制 除2取余，注意一个字节8位 34=0B0010 0010 十进制转八进制 除8取余，131=0203 十进制转十六进制 除16取余，237=0xED 二进制转八进制 低位开始，二进制数三位一组，转成八进制 0B11 010 101=&gt;0 3 2 5 二进制转十六进制 低位开始，四位一组 0b1101 0101 =&gt; 0x D 5 三、原码、反码、补码 对于有符号： 1.二进制的最高位是符号位，0表示整数，1表示负数 2.正数的原码、反码、补码都一样 3.负数的反码=原码符号位不变，其它位取反 4.负数的补码=反码+1，负数的反码=负数的补码-1 5.0的反码，补码都是0 6.Java没有无符号数 7.计算机都是以补码的方式运算的 8.看运算结果时，看原码
四、位运算符 按位与&amp; 两位全为1，结果为1，否则为0 2&amp;3 1.2的原码=&gt;00000000 00000000 00000000 00000010 2的补码=&gt;00000000 00000000 00000000 00000010 2.</description>
</item>
<item>
<title>【Java笔记】05 键盘输入</title>
<link>https://lyrace.github.io/post/java5/</link>
<pubDate>Fri, 21 Jan 2022 00:40:08 +0800</pubDate>
<guid>https://lyrace.github.io/post/java5/</guid>
<description>【Java笔记】05 键盘输入 键盘输入语句 扫描器 Scanner java.util.* 1.导入该类所在的包 2.创建Scanner对象
import java.util.Scanner; public class Input{ public static void main(String[] args){ Scanner myScanner = new Scanner(System.in); //执行到next方法时，会等待用户输入 String name = myScanner.next();//接收用户输入字符串 int age = myScanner.nextInt(); double sal = myScanner.nextDouble(); } } </description>
</item>
<item>
<title>【Java笔记】04 运算符</title>
<link>https://lyrace.github.io/post/java4/</link>
<pubDate>Fri, 21 Jan 2022 00:40:06 +0800</pubDate>
<guid>https://lyrace.github.io/post/java4/</guid>
<description>【Java笔记】04 运算符 一、算数运算符 运算符：+（正号）、-（负号）、+、-、*、/、%、++、&ndash;、 +（字符串相加） 1./
System.out.println(10 / 4); //2 System.out.println(10.0 / 4); //2.5 double d = 10 / 4;//2.0 2.% 取模，取余 %运算， a % b = a - a / b * b 10%3=1 //10-10/33=1 -10%3=-1 //(-10)-(-10)/33=-1 10%-3=1 //10-10/(-3)(-3)=1 %运算，a是小数的情况下， a % b = a - (int)a / b * b -10.5%3 = -10.5 - (-10)/33 = -10.5+9=-1.5 3.++
作为独立语句 i++;//自增，等价于 i=i+1； ++i;//自增，等价于i=i+1; 作为表达式使用 前++：++i先自增，后赋值 后++：i++先赋值，后自增 int i = 8; int k = ++i;//i=i+1;k=i; System.</description>
</item>
<item>
<title>【Java笔记】03 变量</title>
<link>https://lyrace.github.io/post/java3/</link>
<pubDate>Fri, 21 Jan 2022 00:40:05 +0800</pubDate>
<guid>https://lyrace.github.io/post/java3/</guid>
<description>【Java笔记】03 变量 一、变量基本 概念 变量是程序的基本组成单位，相当于内存中一个数据存储空间的表示，基本要素（类型、名称、值）
步骤 声明变量 int a; 赋值 a=60; 使用 System.out.println(a); 注意事项 1.变量表示内存中的一个存储区域 2.该区域有名称和内存 3.先声明后使用 4.该区域的数据在同一类型范围内变化 5.变量在同一作用域不能重名 二、+的使用 1.左右都是数值型=&gt;加法运算 2.左右两边有一方为字符串=&gt;拼接运算
System.out.println(100+98);//198 System.out.println(&#34;100&#34;+98);//10098 System.out.println(100+3+&#34;hello&#34;);//103hello System.out.println(&#34;hello&#34;+100+3);//hello1003 三、数据类型 1.基本数据类型
数值型 整数类型，存放整数 byte(字节)[1],short[2],int[4],long[8] 浮点类型 float[4],double[8] 字符型 存放单个字符 char[2] 布尔型 存放true,false boolean[1] 2.引用数据类型 类 接口 数组 四、整数类型 类型 占用存储空间 范围 byte,字节 1字节 -128~127 short,短整型 2字节 -2^15^ ~ 2^15^-1，-32768~32767 int,整型 4字节 -2^31^ ~ 2^31^-1，-2147483648~2147483647 long,长整型 8字节 -2^63^ ~ 2^63^-1 坑 double num1 = 2.</description>
</item>
<item>
<title>【Java笔记】02 DOS</title>
<link>https://lyrace.github.io/post/java2/</link>
<pubDate>Fri, 21 Jan 2022 00:40:04 +0800</pubDate>
<guid>https://lyrace.github.io/post/java2/</guid>
<description>【Java笔记】02 DOS 一、DOS命令 Dos：Disk Operating System磁盘操作系统
二、路径 相对路径：从当前目录开始定位形成的一个路径 ..-&gt;上一层 绝对路径：从顶级目录开始定位形成的一个路径
三、常用的Dos命令 1.查看当前目录有什么内容 dir 路径 2.切换到其他盘 切换到c盘 cd \D c: 3.切换到当前盘的其他目录下、 cd d:\abc\test cd ....\abc\test 4.切换到上一级 cd .. 5.切换到根目录 cd 6.查看指定的目录下所有的子级目录 tree 7.清屏 cls 8.推出Dos exit 9.md[创建目录]，rd[删除目录]，copy[拷贝文件]，del[删除文件]，echo[输入内容到文件，echo hello &gt; ok.txt],move[剪切/移动]</description>
</item>
<item>
<title>【Java笔记】01 概述</title>
<link>https://lyrace.github.io/post/java1/</link>
<pubDate>Fri, 21 Jan 2022 00:34:50 +0800</pubDate>
<guid>https://lyrace.github.io/post/java1/</guid>
<description>【Java笔记】01 概述 一、java特性 1.面向对象的（oop) 2.健壮的，由强制类型机制、异常处理、垃圾的自动收集等保证 3.跨平台性的，一个编译好的class文件可在多个操作系统下运行 4.解释性的 解释性：编译后的代码，不能直接被机器执行，需要解释器来执行,javascript,PHP,java 编译性：编译后的代码，可以直接被机器执行，c/c++
二、java运行机制及运行过程 JVM让同一个java程序在三个不同的操作系统中都可以执行——&gt;跨平台性 1.java核心机制——java虚拟机[JVM java virtual machine]
基本介绍 1.JVM是一个虚拟的计算机，具有指令集并使用不同的存储区域。负责执行指令，管理数据、内存、寄存器，包含在JDK中 2.不同的平台有不同的虚拟机 3.虚拟机机制屏蔽了底层运行平台的差别，实现了一次编译，到处运行 JDK &amp; JRE 1.JDK 全称Java Development Kit，java开发工具包 JDK=JRE+java的开发工具java，javac，javadoc,javap等 2.JRE Java Runtime Environment，java运行环境 JRE=JVM+Java的核心类库 =&gt;JDK=JVM+Java SE标准类库+开发工具集 三、Java开发注意事项 一个源文件最多只能有一个public类。其它类的个数不限。编译后每一个类都对应一个.class 也可以将main方法写在非public类中，然后指定运行非public类这样入口方法就是非public的main方法
public class Hello{ public static void main (String []args){ System.out.println(&#34;Hello,l&#34;); } } public class Hello{ public static void main (String []args){ System.out.println(&#34;Hello,l&#34;); } } class Dog{ public static void main (String []args){ System.</description>
</item>
</channel>
</rss>