();
-public static void main(String[] args) {
- while (true) {
- for (int i = 0; i < 10; i++) {
- vector.add(i);
- }
+public static void main(String[] args) {
+ while (true) {
+ for (int i = 0; i < 10; i++) {
+ vector.add(i);
+ }
- Thread removeThread = new Thread(new Runnable() {
- @Override
- public void run() {
- for (int i = 0; i < vector.size(); i++) {
- vector.remove(i);
- }
- }
- });
+ Thread removeThread = new Thread(new Runnable() {
+ @Override
+ public void run() {
+ for (int i = 0; i < vector.size(); i++) {
+ vector.remove(i);
+ }
+ }
+ });
- Thread printThread = new Thread(new Runnable() {
- @Override
- public void run() {
- for (int i = 0; i < vector.size(); i++) {
- System.out.println((vector.get(i)));
- }
- }
- });
+ Thread printThread = new Thread(new Runnable() {
+ @Override
+ public void run() {
+ for (int i = 0; i < vector.size(); i++) {
+ System.out.println((vector.get(i)));
+ }
+ }
+ });
- removeThread.start();
- printThread.start();
+ removeThread.start();
+ printThread.start();
- //不要同时产生过多的线程，否则会导致操作系统假死
- while (Thread.activeCount() > 20);
- }
+ //不要同时产生过多的线程，否则会导致操作系统假死
+ while (Thread.activeCount() > 20);
+ }
}
```
```html
-Exception in thread"Thread-132"java.lang.ArrayIndexOutOfBoundsException：
-Array index out of range：17
-at java.util.Vector.remove（Vector.java：777）
-at org.fenixsoft.mulithread.VectorTest$1.run（VectorTest.java：21）
-at java.lang.Thread.run（Thread.java：662）
+Exception in thread"Thread-132"java.lang.ArrayIndexOutOfBoundsException：
+Array index out of range：17
+at java.util.Vector.remove（Vector.java：777）
+at org.fenixsoft.mulithread.VectorTest$1.run（VectorTest.java：21）
+at java.lang.Thread.run（Thread.java：662）
```
-很明显，尽管这里使用到的 Vector 的 get()、remove() 和 size() 方法都是同步的，但是在多线程的环境中，如果不在方法调用端做额外的同步措施的话，使用这段代码仍然是不安全的，因为如果另一个线程恰好在错误的时间里删除了一个元素，导致序号 i 已经不再可用的话，再用 i 访问数组就会抛出一个 ArrayIndexOutOfBoundsException。如果要保证这段代码能正确执行下去，我们不得不把 removeThread 和 printThread 的定义改成如下所示的样子：
+很明显，尽管这里使用到的 Vector 的 get()、remove() 和 size() 方法都是同步的，但是在多线程的环境中，如果不在方法调用端做额外的同步措施的话，使用这段代码仍然是不安全的，因为如果另一个线程恰好在错误的时间里删除了一个元素，导致序号 i 已经不再可用的话，再用 i 访问数组就会抛出一个 ArrayIndexOutOfBoundsException。如果要保证这段代码能正确执行下去，我们不得不把 removeThread 和 printThread 的定义改成如下所示的样子：
```java
- Thread removeThread = new Thread(new Runnable() {
- @Override
- public void run() {
- synchronized (vector) {
- for (int i = 0; i < vector.size(); i++) {
- vector.remove(i);
- }
- }
- }
+ Thread removeThread = new Thread(new Runnable() {
+ @Override
+ public void run() {
+ synchronized (vector) {
+ for (int i = 0; i < vector.size(); i++) {
+ vector.remove(i);
+ }
+ }
+ }
});
-Thread printThread = new Thread(new Runnable() {
- @Override
- public void run() {
- synchronized (vector) {
- for (int i = 0; i < vector.size(); i++) {
- System.out.println((vector.get(i)));
- }
- }
- }
+Thread printThread = new Thread(new Runnable() {
+ @Override
+ public void run() {
+ synchronized (vector) {
+ for (int i = 0; i < vector.size(); i++) {
+ System.out.println((vector.get(i)));
+ }
+ }
+ }
});
```
-### 1.3 相对线程安全
+### 1.3 相对线程安全
相对的线程安全就是我们通常意义上所讲的线程安全，它需要保证对这个对象单独的操作是线程安全的，我们在调用的时候不需要做额外的保障措施，但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性。
-在 Java 语言中，大部分的线程安全类都属于这种类型，例如 Vector、HashTable、Collections 的 synchronizedCollection() 方法包装的集合等。
+在 Java 语言中，大部分的线程安全类都属于这种类型，例如 Vector、HashTable、Collections 的 synchronizedCollection() 方法包装的集合等。
-### 1.4 线程兼容
+### 1.4 线程兼容
-线程兼容是指对象本身并不是线程安全的，但是可以通过在调用端正确地使用同步手段来保证对象在并发环境中可以安全地使用，我们平常说一个类不是线程安全的，绝大多数时候指的是这一种情况。Java API 中大部分的类都是属于线程兼容的，如与前面的 Vector 和 HashTable 相对应的集合类 ArrayList 和 HashMap 等。
+线程兼容是指对象本身并不是线程安全的，但是可以通过在调用端正确地使用同步手段来保证对象在并发环境中可以安全地使用，我们平常说一个类不是线程安全的，绝大多数时候指的是这一种情况。Java API 中大部分的类都是属于线程兼容的，如与前面的 Vector 和 HashTable 相对应的集合类 ArrayList 和 HashMap 等。
-### 1.5 线程对立
+### 1.5 线程对立
-线程对立是指无论调用端是否采取了同步措施，都无法在多线程环境中并发使用的代码。由于 Java 语言天生就具备多线程特性，线程对立这种排斥多线程的代码是很少出现的，而且通常都是有害的，应当尽量避免。
+线程对立是指无论调用端是否采取了同步措施，都无法在多线程环境中并发使用的代码。由于 Java 语言天生就具备多线程特性，线程对立这种排斥多线程的代码是很少出现的，而且通常都是有害的，应当尽量避免。
-一个线程对立的例子是 Thread 类的 suspend() 和 resume() 方法，如果有两个线程同时持有一个线程对象，一个尝试去中断线程，另一个尝试去恢复线程，如果并发进行的话，无论调用时是否进行了同步，目标线程都是存在死锁风险的，如果 suspend() 中断的线程就是即将要执行 resume() 的那个线程，那就肯定要产生死锁了。也正是由于这个原因，suspend() 和 resume() 方法已经被 JDK 声明废弃（@Deprecated）了。常见的线程对立的操作还有 System.setIn()、Sytem.setOut() 和 System.runFinalizersOnExit() 等。
+一个线程对立的例子是 Thread 类的 suspend() 和 resume() 方法，如果有两个线程同时持有一个线程对象，一个尝试去中断线程，另一个尝试去恢复线程，如果并发进行的话，无论调用时是否进行了同步，目标线程都是存在死锁风险的，如果 suspend() 中断的线程就是即将要执行 resume() 的那个线程，那就肯定要产生死锁了。也正是由于这个原因，suspend() 和 resume() 方法已经被 JDK 声明废弃（@Deprecated）了。常见的线程对立的操作还有 System.setIn()、Sytem.setOut() 和 System.runFinalizersOnExit() 等。
-## 2. 线程安全的实现方法
+## 2. 线程安全的实现方法
如何实现线程安全与代码编写有很大的关系，但虚拟机提供的同步和锁机制也起到了非常重要的作用。本节中，代码编写如何实现线程安全和虚拟机如何实现同步与锁这两者都会有所涉及，相对而言更偏重后者一些，只要读者了解了虚拟机线程安全手段的运作过程，自己去思考代码如何编写并不是一件困难的事情。
-### 2.1 互斥同步
+### 2.1 互斥同步
-互斥同步（Mutual Exclusion＆Synchronization）是常见的一种并发正确性保障手段。同步是指在多个线程并发访问共享数据时，保证共享数据在同一个时刻只被一个（或者是一些，使用信号量的时候）线程使用。而互斥是实现同步的一种手段，临界区（Critical Section）、互斥量（Mutex）和信号量（Semaphore）都是主要的互斥实现方式。因此，在这 4 个字里面，互斥是因，同步是果；互斥是方法，同步是目的。
+互斥同步（Mutual Exclusion＆Synchronization）是常见的一种并发正确性保障手段。同步是指在多个线程并发访问共享数据时，保证共享数据在同一个时刻只被一个（或者是一些，使用信号量的时候）线程使用。而互斥是实现同步的一种手段，临界区（Critical Section）、互斥量（Mutex）和信号量（Semaphore）都是主要的互斥实现方式。因此，在这 4 个字里面，互斥是因，同步是果；互斥是方法，同步是目的。
-在 Java 中，最基本的互斥同步手段就是 synchronized 关键字，synchronized 关键字经过编译之后，会在同步块的前后分别形成 monitorenter 和 monitorexit 这两个字节码指令，这两个字节码都需要一个 reference 类型的参数来指明要锁定和解锁的对象。如果 Java 程序中的 synchronized 明确指定了对象参数，那就是这个对象的 reference；如果没有明确指定，那就根据 synchronized 修饰的是实例方法还是类方法，去取对应的对象实例或 Class 对象来作为锁对象。
+在 Java 中，最基本的互斥同步手段就是 synchronized 关键字，synchronized 关键字经过编译之后，会在同步块的前后分别形成 monitorenter 和 monitorexit 这两个字节码指令，这两个字节码都需要一个 reference 类型的参数来指明要锁定和解锁的对象。如果 Java 程序中的 synchronized 明确指定了对象参数，那就是这个对象的 reference；如果没有明确指定，那就根据 synchronized 修饰的是实例方法还是类方法，去取对应的对象实例或 Class 对象来作为锁对象。
-根据虚拟机规范的要求，在执行 monitorenter 指令时，首先要尝试获取对象的锁。如果这个对象没被锁定，或者当前线程已经拥有了那个对象的锁，把锁的计数器加 1，相应的，在执行 monitorexit 指令时会将锁计数器减 1，当计数器为 0 时，锁就被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到对象锁被另外一个线程释放为止。
+根据虚拟机规范的要求，在执行 monitorenter 指令时，首先要尝试获取对象的锁。如果这个对象没被锁定，或者当前线程已经拥有了那个对象的锁，把锁的计数器加 1，相应的，在执行 monitorexit 指令时会将锁计数器减 1，当计数器为 0 时，锁就被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到对象锁被另外一个线程释放为止。
-在虚拟机规范对 monitorenter 和 monitorexit 的行为描述中，有两点是需要特别注意的。首先，synchronized 同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题。其次，同步块在已进入的线程执行完之前，会阻塞后面其他线程的进入。Java 的线程是映射到操作系统的原生线程之上的，如果要阻塞或唤醒一个线程，都需要操作系统来帮忙完成，这就需要从用户态转换到核心态中，因此状态转换需要耗费很多的处理器时间。对于代码简单的同步块（如被 synchronized 修饰的 getter() 或 setter() 方法），状态转换消耗的时间有可能比用户代码执行的时间还要长。所以 synchronized 是 Java 语言中一个重量级（Heavyweight）的操作，有经验的程序员都会在确实必要的情况下才使用这种操作。而虚拟机本身也会进行一些优化，譬如在通知操作系统阻塞线程之前加入一段自旋等待过程，避免频繁地切入到核心态之中。
+在虚拟机规范对 monitorenter 和 monitorexit 的行为描述中，有两点是需要特别注意的。首先，synchronized 同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题。其次，同步块在已进入的线程执行完之前，会阻塞后面其他线程的进入。Java 的线程是映射到操作系统的原生线程之上的，如果要阻塞或唤醒一个线程，都需要操作系统来帮忙完成，这就需要从用户态转换到核心态中，因此状态转换需要耗费很多的处理器时间。对于代码简单的同步块（如被 synchronized 修饰的 getter() 或 setter() 方法），状态转换消耗的时间有可能比用户代码执行的时间还要长。所以 synchronized 是 Java 语言中一个重量级（Heavyweight）的操作，有经验的程序员都会在确实必要的情况下才使用这种操作。而虚拟机本身也会进行一些优化，譬如在通知操作系统阻塞线程之前加入一段自旋等待过程，避免频繁地切入到核心态之中。
-除了 synchronized 之外，我们还可以使用 java.util.concurrent（下文称 J.U.C）包中的重入锁（ReentrantLock）来实现同步，在基本用法上，ReentrantLock 与 synchronized 很相似，他们都具备一样的线程重入特性，只是代码写法上有点区别，一个表现为 API 层面的互斥锁（lock() 和 unlock() 方法配合 try/finally 语句块来完成），另一个表现为原生语法层面的互斥锁。不过，相比 synchronized,ReentrantLock 增加了一些高级功能，主要有以下 3 项：等待可中断、可实现公平锁，以及锁可以绑定多个条件。
+除了 synchronized 之外，我们还可以使用 java.util.concurrent（下文称 J.U.C）包中的重入锁（ReentrantLock）来实现同步，在基本用法上，ReentrantLock 与 synchronized 很相似，他们都具备一样的线程重入特性，只是代码写法上有点区别，一个表现为 API 层面的互斥锁（lock() 和 unlock() 方法配合 try/finally 语句块来完成），另一个表现为原生语法层面的互斥锁。不过，相比 synchronized,ReentrantLock 增加了一些高级功能，主要有以下 3 项：等待可中断、可实现公平锁，以及锁可以绑定多个条件。
-- 等待可中断是指当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情，可中断特性对处理执行时间非常长的同步块很有帮助。
+- 等待可中断是指当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情，可中断特性对处理执行时间非常长的同步块很有帮助。
-- 公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁；而非公平锁则不保证这一点，在锁被释放时，任何一个等待锁的线程都有机会获得锁。synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但可以通过带布尔值的构造函数要求使用公平锁。
+- 公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁；而非公平锁则不保证这一点，在锁被释放时，任何一个等待锁的线程都有机会获得锁。synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但可以通过带布尔值的构造函数要求使用公平锁。
-- 锁绑定多个条件是指一个 ReentrantLock 对象可以同时绑定多个 Condition 对象，而在 synchronized 中，锁对象的 wait() 和 notify() 或 notifyAll() 方法可以实现一个隐含的条件，如果要和多于一个的条件关联的时候，就不得不额外地添加一个锁，而 ReentrantLock 则无须这样做，只需要多次调用 newCondition() 方法即可。
+- 锁绑定多个条件是指一个 ReentrantLock 对象可以同时绑定多个 Condition 对象，而在 synchronized 中，锁对象的 wait() 和 notify() 或 notifyAll() 方法可以实现一个隐含的条件，如果要和多于一个的条件关联的时候，就不得不额外地添加一个锁，而 ReentrantLock 则无须这样做，只需要多次调用 newCondition() 方法即可。
-如果需要使用上述功能，选用 ReentrantLock 是一个很好的选择，那如果是基于性能考虑呢？关于 synchronized 和 ReentrantLock 的性能问题，Brian Goetz 对这两种锁在 JDK 1.5 与单核处理器，以及 JDK 1.5 与双 Xeon 处理器环境下做了一组吞吐量对比的实验，实验结果如图 13-1 和图 13-2 所示。
+如果需要使用上述功能，选用 ReentrantLock 是一个很好的选择，那如果是基于性能考虑呢？关于 synchronized 和 ReentrantLock 的性能问题，Brian Goetz 对这两种锁在 JDK 1.5 与单核处理器，以及 JDK 1.5 与双 Xeon 处理器环境下做了一组吞吐量对比的实验，实验结果如图 13-1 和图 13-2 所示。
- 
- JDK 1.5、单核处理器下两种锁的吞吐量对比
+
+ JDK 1.5、单核处理器下两种锁的吞吐量对比
- 
-JDK 1.5、双 Xeon 处理器下两种锁的吞吐量对比
+
+ JDK 1.5、双 Xeon 处理器下两种锁的吞吐量对比
-多线程环境下 synchronized 的吞吐量下降得非常严重，而 ReentrantLock 则能基本保持在同一个比较稳定的水平上。与其说 ReentrantLock 性能好，还不如说 synchronized 还有非常大的优化余地。后续的技术发展也证明了这一点，JDK 1.6 中加入了很多针对锁的优化措施，JDK 1.6 发布之后，人们就发现 synchronized 与 ReentrantLock 的性能基本上是完全持平了。因此，如果读者的程序是使用 JDK 1.6 或以上部署的话，性能因素就不再是选择 ReentrantLock 的理由了，虚拟机在未来的性能改进中肯定也会更加偏向于原生的 synchronized，所以还是提倡在 synchronized 能实现需求的情况下，优先考虑使用 synchronized 来进行同步。
+多线程环境下 synchronized 的吞吐量下降得非常严重，而 ReentrantLock 则能基本保持在同一个比较稳定的水平上。与其说 ReentrantLock 性能好，还不如说 synchronized 还有非常大的优化余地。后续的技术发展也证明了这一点，JDK 1.6 中加入了很多针对锁的优化措施，JDK 1.6 发布之后，人们就发现 synchronized 与 ReentrantLock 的性能基本上是完全持平了。因此，如果读者的程序是使用 JDK 1.6 或以上部署的话，性能因素就不再是选择 ReentrantLock 的理由了，虚拟机在未来的性能改进中肯定也会更加偏向于原生的 synchronized，所以还是提倡在 synchronized 能实现需求的情况下，优先考虑使用 synchronized 来进行同步。
-### 2.2 非阻塞同步
+### 2.2 非阻塞同步
-互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步（Blocking Synchronization）。从处理问题的方式上说，互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施（例如加锁），那就肯定会出现问题，无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。随着硬件指令集的发展，我们有了另外一个选择：基于冲突检测的乐观并发策略，通俗地说，就是先进行操作，如果没有其他线程争用共享数据，那操作就成功了；如果共享数据有争用，产生了冲突，那就再采取其他的补偿措施（最常见的补偿措施就是不断地重试，直到成功为止），这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步（Non-Blocking Synchronization）。
+互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步（Blocking Synchronization）。从处理问题的方式上说，互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施（例如加锁），那就肯定会出现问题，无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。随着硬件指令集的发展，我们有了另外一个选择：基于冲突检测的乐观并发策略，通俗地说，就是先进行操作，如果没有其他线程争用共享数据，那操作就成功了；如果共享数据有争用，产生了冲突，那就再采取其他的补偿措施（最常见的补偿措施就是不断地重试，直到成功为止），这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步（Non-Blocking Synchronization）。
为什么笔者说使用乐观并发策略需要“硬件指令集的发展”才能进行呢？因为我们需要操作和冲突检测这两个步骤具备原子性，靠什么来保证呢？如果这里再使用互斥同步来保证就失去意义了，所以我们只能靠硬件来完成这件事情，硬件保证一个从语义上看起来需要多次操作的行为只通过一条处理器指令就能完成，这类指令常用的有：
-- 测试并设置（Test-and-Set）
-- 获取并增加（Fetch-and-Increment）
-- 交换（Swap）
-- 比较并交换（Compare-and-Swap，下文称 CAS）
-- 加载链接/条件存储（Load-Linked/Store-Conditional，下文称 LL/SC）
+- 测试并设置（Test-and-Set）
+- 获取并增加（Fetch-and-Increment）
+- 交换（Swap）
+- 比较并交换（Compare-and-Swap，下文称 CAS）
+- 加载链接/条件存储（Load-Linked/Store-Conditional，下文称 LL/SC）
-其中，前面的 3 条是 20 世纪就已经存在于大多数指令集之中的处理器指令，后面的两条是现代处理器新增的，而且这两条指令的目的和功能是类似的。在 IA64、x86 指令集中有 cmpxchg 指令完成 CAS 功能，在 sparc-TSO 也有 casa 指令实现，而在 ARM 和 PowerPC 架构下，则需要使用一对 ldrex/strex 指令来完成 LL/SC 的功能。
+其中，前面的 3 条是 20 世纪就已经存在于大多数指令集之中的处理器指令，后面的两条是现代处理器新增的，而且这两条指令的目的和功能是类似的。在 IA64、x86 指令集中有 cmpxchg 指令完成 CAS 功能，在 sparc-TSO 也有 casa 指令实现，而在 ARM 和 PowerPC 架构下，则需要使用一对 ldrex/strex 指令来完成 LL/SC 的功能。
-**CAS** 指令需要有 3 个操作数，分别是内存位置（在 Java 中可以简单理解为变量的内存地址，用 V 表示）、旧的预期值（用 A 表示）和新值（用 B 表示）。CAS 指令执行时，当且仅当 V 符合旧预期值 A 时，处理器用新值 B 更新 V 的值，否则它就不执行更新，但是无论是否更新了 V 的值，都会返回 V 的旧值，上述的处理过程是一个原子操作。
+**CAS** 指令需要有 3 个操作数，分别是内存位置（在 Java 中可以简单理解为变量的内存地址，用 V 表示）、旧的预期值（用 A 表示）和新值（用 B 表示）。CAS 指令执行时，当且仅当 V 符合旧预期值 A 时，处理器用新值 B 更新 V 的值，否则它就不执行更新，但是无论是否更新了 V 的值，都会返回 V 的旧值，上述的处理过程是一个原子操作。
-在 JDK 1.5 之后，Java 程序中才可以使用 CAS 操作，该操作由 sun.misc.Unsafe 类里面的 compareAndSwapInt() 和 compareAndSwapLong() 等几个方法包装提供，虚拟机在内部对这些方法做了特殊处理，即时编译出来的结果就是一条平台相关的处理器 CAS 指令，没有方法调用的过程，或者可以认为是无条件内联进去了。
+在 JDK 1.5 之后，Java 程序中才可以使用 CAS 操作，该操作由 sun.misc.Unsafe 类里面的 compareAndSwapInt() 和 compareAndSwapLong() 等几个方法包装提供，虚拟机在内部对这些方法做了特殊处理，即时编译出来的结果就是一条平台相关的处理器 CAS 指令，没有方法调用的过程，或者可以认为是无条件内联进去了。
-由于 Unsafe 类不是提供给用户程序调用的类（Unsafe.getUnsafe() 的代码中限制了只有启动类加载器（Bootstrap ClassLoader）加载的 Class 才能访问它），因此，如果不采用反射手段，我们只能通过其他的 Java API 来间接使用它，如 J.U.C 包里面的整数原子类，其中的 compareAndSet() 和 getAndIncrement() 等方法都使用了 Unsafe 类的 CAS 操作。
+由于 Unsafe 类不是提供给用户程序调用的类（Unsafe.getUnsafe() 的代码中限制了只有启动类加载器（Bootstrap ClassLoader）加载的 Class 才能访问它），因此，如果不采用反射手段，我们只能通过其他的 Java API 来间接使用它，如 J.U.C 包里面的整数原子类，其中的 compareAndSet() 和 getAndIncrement() 等方法都使用了 Unsafe 类的 CAS 操作。
-这段 20 个线程自增 10000 次的代码使用了 AtomicInteger 之后程序输出了正确结果，一切都要归功于 incrementAndGet() 方法的原子性。
+这段 20 个线程自增 10000 次的代码使用了 AtomicInteger 之后程序输出了正确结果，一切都要归功于 incrementAndGet() 方法的原子性。
-代码清单 4：Atomic 的原子自增运算
+代码清单 4：Atomic 的原子自增运算
```java
/**
- * Atomic 变量自增运算测试
- *
- * @author zzm
+ * Atomic 变量自增运算测试
+ *
+ * @author zzm
*/
-public class AtomicTest {
+public class AtomicTest {
- public static AtomicInteger race = new AtomicInteger(0);
+ public static AtomicInteger race = new AtomicInteger(0);
- public static void increase() {
- race.incrementAndGet();
- }
+ public static void increase() {
+ race.incrementAndGet();
+ }
- private static final int THREADS_COUNT = 20;
+ private static final int THREADS_COUNT = 20;
- public static void main(String[] args) throws Exception {
- Thread[] threads = new Thread[THREADS_COUNT];
- for (int i = 0; i < THREADS_COUNT; i++) {
- threads[i] = new Thread(new Runnable() {
- @Override
- public void run() {
- for (int i = 0; i < 10000; i++) {
- increase();
- }
- }
- });
- threads[i].start();
- }
+ public static void main(String[] args) throws Exception {
+ Thread[] threads = new Thread[THREADS_COUNT];
+ for (int i = 0; i < THREADS_COUNT; i++) {
+ threads[i] = new Thread(new Runnable() {
+ @Override
+ public void run() {
+ for (int i = 0; i < 10000; i++) {
+ increase();
+ }
+ }
+ });
+ threads[i].start();
+ }
- while (Thread.activeCount() > 1)
- Thread.yield();
+ while (Thread.activeCount() > 1)
+ Thread.yield();
- System.out.println(race);
- }
+ System.out.println(race);
+ }
}
```
@@ -714,142 +766,142 @@ public class AtomicTest {
200000
```
-incrementAndGet() 的实现其实非常简单。
+incrementAndGet() 的实现其实非常简单。
-代码清单 5：incrementAndGet() 方法的 JDK 源码
+代码清单 5：incrementAndGet() 方法的 JDK 源码
```java
/**
- * Atomically increment by one the current value.
- * @return the updated value
- */
-public final int incrementAndGet() {
- for (;;) {
- int current = get();
- int next = current + 1;
- if (compareAndSet(current, next))
- return next;
- }
+ * Atomically increment by one the current value.
+ * @return the updated value
+ */
+public final int incrementAndGet() {
+ for (;;) {
+ int current = get();
+ int next = current + 1;
+ if (compareAndSet(current, next))
+ return next;
+ }
}
```
-incrementAndGet() 方法在一个无限循环中，不断尝试将一个比当前值大 1 的新值赋给自己。如果失败了，那说明在执行“获取-设置”操作的时候值已经有了修改，于是再次循环进行下一次操作，直到设置成功为止。
+incrementAndGet() 方法在一个无限循环中，不断尝试将一个比当前值大 1 的新值赋给自己。如果失败了，那说明在执行“获取-设置”操作的时候值已经有了修改，于是再次循环进行下一次操作，直到设置成功为止。
-尽管 CAS 看起来很美，但显然这种操作无法涵盖互斥同步的所有使用场景，并且 CAS 从语义上来说并不是完美的，存在这样的一个逻辑漏洞：如果一个变量 V 初次读取的时候是 A 值，并且在准备赋值的时候检查到它仍然为 A 值，那我们就能说它的值没有被其他线程改变过了吗？如果在这段期间它的值曾经被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。这个漏洞称为 CAS 操作的“ABA”问题。J.U.C 包为了解决这个问题，提供了一个带有标记的原子引用类“AtomicStampedReference”，它可以通过控制变量值的版本来保证 CAS 的正确性。不过目前来说这个类比较“鸡肋”，大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
+尽管 CAS 看起来很美，但显然这种操作无法涵盖互斥同步的所有使用场景，并且 CAS 从语义上来说并不是完美的，存在这样的一个逻辑漏洞：如果一个变量 V 初次读取的时候是 A 值，并且在准备赋值的时候检查到它仍然为 A 值，那我们就能说它的值没有被其他线程改变过了吗？如果在这段期间它的值曾经被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。这个漏洞称为 CAS 操作的“ABA”问题。J.U.C 包为了解决这个问题，提供了一个带有标记的原子引用类“AtomicStampedReference”，它可以通过控制变量值的版本来保证 CAS 的正确性。不过目前来说这个类比较“鸡肋”，大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
-### 2.3 无同步方案
+### 2.3 无同步方案
要保证线程安全，并不是一定就要进行同步，两者没有因果关系。同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的，笔者简单地介绍其中的两类。
-**可重入代码**（Reentrant Code）：这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。相对线程安全来说，可重入性是更基本的特性，它可以保证线程安全，即所有的可重入的代码都是线程安全的，但是并非所有的线程安全的代码都是可重入的。
+**可重入代码** （Reentrant Code）：这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。相对线程安全来说，可重入性是更基本的特性，它可以保证线程安全，即所有的可重入的代码都是线程安全的，但是并非所有的线程安全的代码都是可重入的。
可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。我们可以通过一个简单的原则来判断代码是否具备可重入性：如果一个方法，它的返回结果是可以预测的，只要输入了相同的数据，就都能返回相同的结果，那它就满足可重入性的要求，当然也就是线程安全的。
-**线程本地存储**（Thread Local Storage）：如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行？如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。
+**线程本地存储** （Thread Local Storage）：如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行？如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。
-符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完，其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。
+符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完，其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。
-Java 语言中，如果一个变量要被多线程访问，可以使用 volatile 关键字声明它为“易变的”；如果一个变量要被某个线程独享，Java 中就没有类似 C++中 \_\_declspec（thread）这样的关键字，不过还是可以通过 java.lang.ThreadLocal 类来实现线程本地存储的功能。每一个线程的 Thread 对象中都有一个 ThreadLocalMap 对象，这个对象存储了一组以 ThreadLocal.threadLocalHashCode 为键，以本地线程变量为值的 K-V 值对，ThreadLocal 对象就是当前线程的 ThreadLocalMap 的访问入口，每一个 ThreadLocal 对象都包含了一个独一无二的 threadLocalHashCode 值，使用这个值就可以在线程 K-V 值对中找回对应的本地线程变量。
+Java 语言中，如果一个变量要被多线程访问，可以使用 volatile 关键字声明它为“易变的”；如果一个变量要被某个线程独享，Java 中就没有类似 C++中 \_\_declspec（thread）这样的关键字，不过还是可以通过 java.lang.ThreadLocal 类来实现线程本地存储的功能。每一个线程的 Thread 对象中都有一个 ThreadLocalMap 对象，这个对象存储了一组以 ThreadLocal.threadLocalHashCode 为键，以本地线程变量为值的 K-V 值对，ThreadLocal 对象就是当前线程的 ThreadLocalMap 的访问入口，每一个 ThreadLocal 对象都包含了一个独一无二的 threadLocalHashCode 值，使用这个值就可以在线程 K-V 值对中找回对应的本地线程变量。
-# 锁优化
+# 锁优化
-高效并发是从 JDK 1.5 到 JDK 1.6 的一个重要改进，HotSpot 虚拟机开发团队在这个版本上花费了大量的精力去实现各种锁优化技术，如适应性自旋（Adaptive Spinning）、锁消除（Lock Elimination）、锁粗化（Lock Coarsening）、轻量级锁（Lightweight Locking）和偏向锁（Biased Locking）等。这些技术都是为了在线程之间更高效地共享数据，以及解决竞争问题，从而提高程序的执行效率。
+高效并发是从 JDK 1.5 到 JDK 1.6 的一个重要改进，HotSpot 虚拟机开发团队在这个版本上花费了大量的精力去实现各种锁优化技术，如适应性自旋（Adaptive Spinning）、锁消除（Lock Elimination）、锁粗化（Lock Coarsening）、轻量级锁（Lightweight Locking）和偏向锁（Biased Locking）等。这些技术都是为了在线程之间更高效地共享数据，以及解决竞争问题，从而提高程序的执行效率。
-## 1. 自旋锁与自适应自旋
+## 1. 自旋锁与自适应自旋
-前面我们讨论互斥同步的时候，提到了互斥同步对性能最大的营销阻塞的实现，挂起线程和恢复线程的操作都需要转入内核态完成，这些操作给系统的并发性能带来了很大的压力。同时，虚拟机的开发团队也注意到在许多应用上，共享数据的锁定状态只会持续很短的一段时间，为了这段时间去挂起和恢复线程并不值得。如果物理机器有一个以上的处理器，能让两个或以上的线程同时并行执行，我们就可以让后面请求锁的那个线程 “稍等一下”，但不放弃处理器的执行时间，看看持有锁的线程是否很快就会释放锁。为了让线程等待，我们只需让线程执行一个忙循环（自旋），这项技术就是所谓的自旋锁。
+前面我们讨论互斥同步的时候，提到了互斥同步对性能最大的营销阻塞的实现，挂起线程和恢复线程的操作都需要转入内核态完成，这些操作给系统的并发性能带来了很大的压力。同时，虚拟机的开发团队也注意到在许多应用上，共享数据的锁定状态只会持续很短的一段时间，为了这段时间去挂起和恢复线程并不值得。如果物理机器有一个以上的处理器，能让两个或以上的线程同时并行执行，我们就可以让后面请求锁的那个线程 “稍等一下”，但不放弃处理器的执行时间，看看持有锁的线程是否很快就会释放锁。为了让线程等待，我们只需让线程执行一个忙循环（自旋），这项技术就是所谓的自旋锁。
-自旋锁在 JDK 1.4.2 中就已经引入，只不过默认是关闭的，可以使用 -XX:+UseSpinning 参数来开启，在 JDK 1.6 就已经改为默认开启了。自旋等待不能代替阻塞，且先不说对处理器数量的要求，自旋等待本身虽然避免了线程切换的开销，但它是要占用处理器时间的，因此，如果锁被占用的时间很短，自旋等待的效果就会非常好，反之，如果锁被占用的时候很长，那么自旋的线程只会白白消耗处理器资源，而不会做任何有用的工作，反而会带来性能上的浪费。因此，自旋等待的时间必须要有一定的限度，如果自旋超过了限定的次数仍然没有成功获得锁，就应当使用传统的方式去挂起线程了。自旋次数的默认值是 10 次，用户可以使用参数 -XX:PreBlockSpin 来更改。
+自旋锁在 JDK 1.4.2 中就已经引入，只不过默认是关闭的，可以使用 -XX:+UseSpinning 参数来开启，在 JDK 1.6 就已经改为默认开启了。自旋等待不能代替阻塞，且先不说对处理器数量的要求，自旋等待本身虽然避免了线程切换的开销，但它是要占用处理器时间的，因此，如果锁被占用的时间很短，自旋等待的效果就会非常好，反之，如果锁被占用的时候很长，那么自旋的线程只会白白消耗处理器资源，而不会做任何有用的工作，反而会带来性能上的浪费。因此，自旋等待的时间必须要有一定的限度，如果自旋超过了限定的次数仍然没有成功获得锁，就应当使用传统的方式去挂起线程了。自旋次数的默认值是 10 次，用户可以使用参数 -XX:PreBlockSpin 来更改。
-自旋锁在 JDK 1.4.2 中就已经引入，只不过默认是关闭的，可以使用 -XX:+UseSpinning 参数来开启，在 JDK 1.6 就已经改为默认开启了。自旋等待不能代替阻塞，且先不说对处理器数量的要求，自旋等待本身虽然避免了线程切换的开销，但它是要占用处理器时间的，因此，如果锁被占用的时间很短，自旋等待的效果就会非常好，反之，如果锁被占用的时候很长，那么自旋的线程只会白白消耗处理器资源，而不会做任何有用的工作，反而会带来性能上的浪费。因此，自旋等待的时间必须要有一定的限度，如果自旋超过了限定的次数仍然没有成功获得锁，就应当使用传统的方式去挂起线程了。自旋次数的默认值是 10 次，用户可以使用参数 -XX:PreBlockSpin 来更改。
+自旋锁在 JDK 1.4.2 中就已经引入，只不过默认是关闭的，可以使用 -XX:+UseSpinning 参数来开启，在 JDK 1.6 就已经改为默认开启了。自旋等待不能代替阻塞，且先不说对处理器数量的要求，自旋等待本身虽然避免了线程切换的开销，但它是要占用处理器时间的，因此，如果锁被占用的时间很短，自旋等待的效果就会非常好，反之，如果锁被占用的时候很长，那么自旋的线程只会白白消耗处理器资源，而不会做任何有用的工作，反而会带来性能上的浪费。因此，自旋等待的时间必须要有一定的限度，如果自旋超过了限定的次数仍然没有成功获得锁，就应当使用传统的方式去挂起线程了。自旋次数的默认值是 10 次，用户可以使用参数 -XX:PreBlockSpin 来更改。
-## 2. 锁消除
+## 2. 锁消除
锁消除是指虚拟机即时编译器在运行时，对一些代码上要求同步，但是被检测到不可能存在共享数据竞争的锁进行消除。锁消除的主要判定依据来源于逃逸分析的数据支持，如果判定在一段代码中，堆上的所有数据都不会逃逸出去从而被其他线程访问到，那就可以把他们当做栈上数据对待，认为它们是线程私有的，同步加锁自然就无须进行。
-也许读者会有疑问，变量是否逃逸，对于虚拟机来说需要使用数据流分析来确定，但是程序自己应该是很清楚的，怎么会在明知道不存在数据争用的情况下要求同步呢？答案是有许多同步措施并不是程序员自己加入的。同步的代码在 Java 程序中的普遍程度也许超过了大部分读者的想象。下面段非常简单的代码仅仅是输出 3 个字符串相加的结果，无论是源码字面上还是程序语义上都没有同步。
+也许读者会有疑问，变量是否逃逸，对于虚拟机来说需要使用数据流分析来确定，但是程序自己应该是很清楚的，怎么会在明知道不存在数据争用的情况下要求同步呢？答案是有许多同步措施并不是程序员自己加入的。同步的代码在 Java 程序中的普遍程度也许超过了大部分读者的想象。下面段非常简单的代码仅仅是输出 3 个字符串相加的结果，无论是源码字面上还是程序语义上都没有同步。
-代码清单 6：一段看起来没有同步的代码
+代码清单 6：一段看起来没有同步的代码
```java
-public static String concatString(String s1, String s2, String s3) {
- return s1 + s2 + s3;
+public static String concatString(String s1, String s2, String s3) {
+ return s1 + s2 + s3;
}
```
-我们也知道，由于 String 是一个不可变的类，对字符串的连接操作总是通过生成新的 String 对象来进行的，因此 Javac 编译器会对 String 连接做自动优化。在 JDK 1.5 之前，会转化为 StringBuffer 对象的连续 append() 操作，在 JDK 1.5 及以后的版本中，会转化为 StringBuilder 对象的连续 append() 操作，即上面的代码可能会变成下面的样子：
+我们也知道，由于 String 是一个不可变的类，对字符串的连接操作总是通过生成新的 String 对象来进行的，因此 Javac 编译器会对 String 连接做自动优化。在 JDK 1.5 之前，会转化为 StringBuffer 对象的连续 append() 操作，在 JDK 1.5 及以后的版本中，会转化为 StringBuilder 对象的连续 append() 操作，即上面的代码可能会变成下面的样子：
-代码清单 7：Javac 转化后的字符串连接操作
+代码清单 7：Javac 转化后的字符串连接操作
```java
-public static String concatString(String s1, String s2, String s3) {
- StringBuffer sb = new StringBuffer();
- sb.append(s1);
- sb.append(s2);
- sb.append(s3);
- return sb.toString();
+public static String concatString(String s1, String s2, String s3) {
+ StringBuffer sb = new StringBuffer();
+ sb.append(s1);
+ sb.append(s2);
+ sb.append(s3);
+ return sb.toString();
}
```
-每个 StringBuffer.append() 方法中都有一个同步块，锁就是 sb 对象。虚拟机观察变量 sb，很快就会发现它的动态作用域被限制在 concatString() 方法内部。也就是说，sb 的所有引用永远不会 “逃逸” 到 concatString() 方法之外，其他线程无法访问到它，因此，虽然这里有锁，但是可以被安全地消除掉，在即时编译之后，这段代码就会忽略掉所有的同步而直接执行了。
+每个 StringBuffer.append() 方法中都有一个同步块，锁就是 sb 对象。虚拟机观察变量 sb，很快就会发现它的动态作用域被限制在 concatString() 方法内部。也就是说，sb 的所有引用永远不会 “逃逸” 到 concatString() 方法之外，其他线程无法访问到它，因此，虽然这里有锁，但是可以被安全地消除掉，在即时编译之后，这段代码就会忽略掉所有的同步而直接执行了。
-## 3. 锁粗化
+## 3. 锁粗化
原则上，我们在编写代码的时候，总是推荐将同步块的作用范围限制得尽量小——只在共享数据的实际作用域中才进行同步，这样是为了使得需要同步的操作数量尽可能变小，如果存在锁竞争，那等待锁的线程也能尽快拿到锁。
大部分情况下，上面的原则都是正确的，但是如果一系列的连续操作都对同一个对象反复加锁和解锁，甚至加锁操作是出现在循环体中，那即使没有线程竞争，频繁地进行互斥同步操作也会导致不必要的性能损耗。
-代码清单 7 中连续的 append() 方法就属于这类情况。如果虚拟机探测到由这样的一串零碎的操作都对同一个对象加锁，将会把加锁同步的范围扩展（粗化）到整个操作序列的外部，以代码清单 7 为例，就是扩展到第一个 append() 操作之前直至最后一个 append() 操作之后，这样只需要加锁一次就可以了。
+代码清单 7 中连续的 append() 方法就属于这类情况。如果虚拟机探测到由这样的一串零碎的操作都对同一个对象加锁，将会把加锁同步的范围扩展（粗化）到整个操作序列的外部，以代码清单 7 为例，就是扩展到第一个 append() 操作之前直至最后一个 append() 操作之后，这样只需要加锁一次就可以了。
-## 4. 轻量级锁
+## 4. 轻量级锁
-轻量级锁是 JDK 1.6 之中加入的新型锁机制，它名字中的 “轻量级” 是相对于使用操作系统互斥量来实现的传统锁而言的，因此传统的锁机制就称为 “重量级” 锁。首先需要强调一点的是，轻量级锁并不是用来代替重要级锁的，它的本意是在没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗。
+轻量级锁是 JDK 1.6 之中加入的新型锁机制，它名字中的 “轻量级” 是相对于使用操作系统互斥量来实现的传统锁而言的，因此传统的锁机制就称为 “重量级” 锁。首先需要强调一点的是，轻量级锁并不是用来代替重要级锁的，它的本意是在没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗。
-要理解轻量级锁，以及后面会讲到的偏向锁的原理和运作过程，必须从 HotSpot 虚拟机的对象（对象头部分）的内存布局开始介绍。HotSpot 虚拟机的对象头（Object Header）分为两部分信息，第一部分用于存储对象自身的运行时数据，如哈希码（HashCode）、GC 分代年龄（Generational GC Age）等，这部分数据是长度在 32 位和 64 位的虚拟机中分别为 32 bit 和 64 bit，官方称它为 “Mark Word”，它是实现轻量级锁和偏向锁的关键。另外一部分用于存储指向方法区对象类型数据的指针，如果是数组对象的话，还会有一个额外的部分用于存储数组长度。
+要理解轻量级锁，以及后面会讲到的偏向锁的原理和运作过程，必须从 HotSpot 虚拟机的对象（对象头部分）的内存布局开始介绍。HotSpot 虚拟机的对象头（Object Header）分为两部分信息，第一部分用于存储对象自身的运行时数据，如哈希码（HashCode）、GC 分代年龄（Generational GC Age）等，这部分数据是长度在 32 位和 64 位的虚拟机中分别为 32 bit 和 64 bit，官方称它为 “Mark Word”，它是实现轻量级锁和偏向锁的关键。另外一部分用于存储指向方法区对象类型数据的指针，如果是数组对象的话，还会有一个额外的部分用于存储数组长度。
-对象头信息是与对象自身定义的数据无关的额外存储成本，考虑到虚拟机的空间效率，Mark Work 被设计成一个非固定的数据结构以便在极小的空间内存储尽量多的信息，它会根据对象的状态复用自己的存储空间。例如，在 32 位的 HotSpot 虚拟机中对象未被锁定的状态下，Mark Word 的 32bit 空间中的 25bit 用于存储对象哈希码（HashCode），4bit 用于存储对象分代年龄，2bit 用于存储锁标志位，1bit 固定为 0，在其他状态（轻量级锁定、重量级锁定、GC 标记、可偏向）下对象的存储内容见表 13-1。
+对象头信息是与对象自身定义的数据无关的额外存储成本，考虑到虚拟机的空间效率，Mark Work 被设计成一个非固定的数据结构以便在极小的空间内存储尽量多的信息，它会根据对象的状态复用自己的存储空间。例如，在 32 位的 HotSpot 虚拟机中对象未被锁定的状态下，Mark Word 的 32bit 空间中的 25bit 用于存储对象哈希码（HashCode），4bit 用于存储对象分代年龄，2bit 用于存储锁标志位，1bit 固定为 0，在其他状态（轻量级锁定、重量级锁定、GC 标记、可偏向）下对象的存储内容见表 13-1。
-
+ 
-简单地介绍了对象的内存布局后，我们把话题返回到轻量级锁的执行过程上。在代码进入同步块的时候，如果此同步对象没有被锁定（锁标志位为 “01” 状态）虚拟机首先将在当前线程的栈帧中建立一个名为锁记录（Lock Record）的空间，用于存储锁对象目前的 Mark Word 的拷贝（官方把这份拷贝加上了一个 Displaced 前缀，即 Displaced Mark Word），这时候线程堆栈与对象头的状态如图 13-3 所示。
+简单地介绍了对象的内存布局后，我们把话题返回到轻量级锁的执行过程上。在代码进入同步块的时候，如果此同步对象没有被锁定（锁标志位为 “01” 状态）虚拟机首先将在当前线程的栈帧中建立一个名为锁记录（Lock Record）的空间，用于存储锁对象目前的 Mark Word 的拷贝（官方把这份拷贝加上了一个 Displaced 前缀，即 Displaced Mark Word），这时候线程堆栈与对象头的状态如图 13-3 所示。
-
+ 
-然后，虚拟机将使用 CAS 操作尝试将对象的 Mark Word 更新为指向 Lock Record 的指针。如果这个更新动作成功了，那么这个线程就拥有了该对象的锁，并且对象 Mark Word 的锁标志位 （Mark Word 的最后 2bit）将转变为 “00”，即表示此对象处于轻量级锁定状态，这时候线程堆栈与对象头的状态如图 12-4 所示。
+然后，虚拟机将使用 CAS 操作尝试将对象的 Mark Word 更新为指向 Lock Record 的指针。如果这个更新动作成功了，那么这个线程就拥有了该对象的锁，并且对象 Mark Word 的锁标志位 （Mark Word 的最后 2bit）将转变为 “00”，即表示此对象处于轻量级锁定状态，这时候线程堆栈与对象头的状态如图 12-4 所示。
-
+ 
-如果这个更新操作失败了，虚拟机首先会检查对象的 Mark Word 是否指向当前线程的栈帧，如果只说明当前线程已经拥有了这个对象的锁，那就可以直接进入同步块继续执行，否则说明这个锁对象以及被其他线程线程抢占了。如果有两条以上的线程争用同一个锁，那轻量级锁就不再有效，要膨胀为重量级锁，所标志的状态变为 “10”，Mark Word 中存储的就是指向重量级锁（互斥量）的指针，后面等待锁的线程也要进入阻塞状态。
+如果这个更新操作失败了，虚拟机首先会检查对象的 Mark Word 是否指向当前线程的栈帧，如果只说明当前线程已经拥有了这个对象的锁，那就可以直接进入同步块继续执行，否则说明这个锁对象以及被其他线程线程抢占了。如果有两条以上的线程争用同一个锁，那轻量级锁就不再有效，要膨胀为重量级锁，所标志的状态变为 “10”，Mark Word 中存储的就是指向重量级锁（互斥量）的指针，后面等待锁的线程也要进入阻塞状态。
-上面描述的是轻量级锁的加锁过程，它的解锁过程也是通过 CAS 操作来进行的，如果对象的 Mark Word 仍然指向着线程的锁记录，那就用 CAS 操作把对象当前的 Mark Word 和线程中复制的 Displaced Mark Word 替换回来，如果替换成功，整个同步过程就完成了。如果替换失败，说明有其他线程尝试过获取该锁，那就要释放锁的同时，唤醒被挂起的线程。
+上面描述的是轻量级锁的加锁过程，它的解锁过程也是通过 CAS 操作来进行的，如果对象的 Mark Word 仍然指向着线程的锁记录，那就用 CAS 操作把对象当前的 Mark Word 和线程中复制的 Displaced Mark Word 替换回来，如果替换成功，整个同步过程就完成了。如果替换失败，说明有其他线程尝试过获取该锁，那就要释放锁的同时，唤醒被挂起的线程。
-轻量级锁能提升程序同步性能的依据是 “对于绝大部分的锁，在整个同步周期内都是不存在竞争的”，这是一个经验数据。如果没有竞争，轻量级锁使用 CAS 操作避免了使用互斥量的开销，但如果存在锁竞争，除了互斥量的开销外，还额外发生了 CAS 操作，因此在有竞争的情况下，轻量级锁会比传统的重量级锁更慢。
+轻量级锁能提升程序同步性能的依据是 “对于绝大部分的锁，在整个同步周期内都是不存在竞争的”，这是一个经验数据。如果没有竞争，轻量级锁使用 CAS 操作避免了使用互斥量的开销，但如果存在锁竞争，除了互斥量的开销外，还额外发生了 CAS 操作，因此在有竞争的情况下，轻量级锁会比传统的重量级锁更慢。
-## 5. 偏向锁
+## 5. 偏向锁
-偏向锁也是 JDK 1.6 中引入的一项锁优化，它的目的是消除数据在无竞争情况下的同步原语，进一步提高程序的运行性能。如果说轻量级锁是在无竞争的情况下使用 CAS 操作去消除同步使用的互斥量，那偏向锁就是在无竞争的情况下把整个同步都消除掉，连 CAS 操作都不做了。
+偏向锁也是 JDK 1.6 中引入的一项锁优化，它的目的是消除数据在无竞争情况下的同步原语，进一步提高程序的运行性能。如果说轻量级锁是在无竞争的情况下使用 CAS 操作去消除同步使用的互斥量，那偏向锁就是在无竞争的情况下把整个同步都消除掉，连 CAS 操作都不做了。
-偏向锁的 “偏”，就是偏心的 “偏”、偏袒的 “偏”，它的意思是这个锁会偏向于第一个获得它的线程，如果在接下来的执行过程中，该锁没有被其他的线程获取，则持有偏向锁的线程将永远不需要再进行同步。
+偏向锁的 “偏”，就是偏心的 “偏”、偏袒的 “偏”，它的意思是这个锁会偏向于第一个获得它的线程，如果在接下来的执行过程中，该锁没有被其他的线程获取，则持有偏向锁的线程将永远不需要再进行同步。
-如果读者读懂了前面轻量级锁中关于对象头 Mark Word 与线程之间的操作过程，那偏向锁的原理理解起来就会很简单。假设当前虚拟机启用了偏向锁（启用参数 -XX:+UseBiasedLocking，这是 JDK 1.6 的默认值），那么，当锁对象第一次被线程获取的时候，虚拟机将会把对象头中的标志位设为 “01”，即偏向模式。同时使用 CAS 操作把获取到这个锁的线程 ID 记录在对象的 Mark Word 之中，如果 CAS 操作成功，持有偏向锁的线程以后每次进入这个锁相关的同步块时，虚拟机都可以不再进行如何同步操作（例如 Locking、Unlocking 及对 Mark Word 的 Update 等）。
+如果读者读懂了前面轻量级锁中关于对象头 Mark Word 与线程之间的操作过程，那偏向锁的原理理解起来就会很简单。假设当前虚拟机启用了偏向锁（启用参数 -XX:+UseBiasedLocking，这是 JDK 1.6 的默认值），那么，当锁对象第一次被线程获取的时候，虚拟机将会把对象头中的标志位设为 “01”，即偏向模式。同时使用 CAS 操作把获取到这个锁的线程 ID 记录在对象的 Mark Word 之中，如果 CAS 操作成功，持有偏向锁的线程以后每次进入这个锁相关的同步块时，虚拟机都可以不再进行如何同步操作（例如 Locking、Unlocking 及对 Mark Word 的 Update 等）。
-当有另外一个线程去尝试获取这个锁时，偏向模式就宣告结束。根据锁对象目前是否处于被锁定的状态，撤销偏向（Revoke Bias）后恢复到未锁定（标志位为 “01”）或轻量级锁定（标志位为 “00”）的状态，后续的同步操作就如上面介绍的轻量级锁那样执行。偏向锁、轻量级锁的状态转换及对象 Mark Word 的关系如图 13-5 所示。
+当有另外一个线程去尝试获取这个锁时，偏向模式就宣告结束。根据锁对象目前是否处于被锁定的状态，撤销偏向（Revoke Bias）后恢复到未锁定（标志位为 “01”）或轻量级锁定（标志位为 “00”）的状态，后续的同步操作就如上面介绍的轻量级锁那样执行。偏向锁、轻量级锁的状态转换及对象 Mark Word 的关系如图 13-5 所示。
-
+ 
-偏向锁可以提高带有同步但无竞争的程序性能。它同样是一个带有效益权衡（Trade Off）性质的优化，也就是说，它并不一定总是对程序运行有利，如果程序中大多数的锁总是被多个不同的线程访问，那偏向模式就是多余的。在具体问题具体分析的前提下，有时候使用参数 -XX:-UseBiasedLocking 来禁止偏向锁优化反而可以提升性能。
+偏向锁可以提高带有同步但无竞争的程序性能。它同样是一个带有效益权衡（Trade Off）性质的优化，也就是说，它并不一定总是对程序运行有利，如果程序中大多数的锁总是被多个不同的线程访问，那偏向模式就是多余的。在具体问题具体分析的前提下，有时候使用参数 -XX:-UseBiasedLocking 来禁止偏向锁优化反而可以提升性能。
-# 多线程开发良好的实践
+# 多线程开发良好的实践
-- 给线程命名。
-- 最小化同步范围。
-- 优先使用 volatile。
-- 尽可能使用更高层次的并发工具而非 wait 和 notify() 来实现线程通信，如 BlockingQueue, Semeaphore。
-- 多用并发容器，少用同步容器，并发容器比同步容器的可扩展性更好。
-- 考虑使用线程池。
-- 最低限度的使用同步和锁，缩小临界区。因此相对于同步方法，同步块会更好。
+- 给线程命名。
+- 最小化同步范围。
+- 优先使用 volatile。
+- 尽可能使用更高层次的并发工具而非 wait 和 notify() 来实现线程通信，如 BlockingQueue, Semeaphore。
+- 多用并发容器，少用同步容器，并发容器比同步容器的可扩展性更好。
+- 考虑使用线程池。
+- 最低限度的使用同步和锁，缩小临界区。因此相对于同步方法，同步块会更好。
-# 参考资料
+# 参考资料
-- Java 编程思想
-- 深入理解 Java 虚拟机
-- [Java 线程面试题 Top 50](http://www.importnew.com/12773.html)
+- Java 编程思想
+- 深入理解 Java 虚拟机
+- [Java 线程面试题 Top 50](http://www.importnew.com/12773.html)
diff --git a/notes/Leetcode 题解.md b/notes/Leetcode 题解.md
index b3bd2597..cf67cdca 100644
--- a/notes/Leetcode 题解.md
+++ b/notes/Leetcode 题解.md
@@ -1,172 +1,223 @@
-[TOC]
+
+* [算法思想](#算法思想)
+ * [二分查找](#二分查找)
+ * [贪心思想](#贪心思想)
+ * [双指针](#双指针)
+ * [排序](#排序)
+ * [快速选择](#快速选择)
+ * [堆排序](#堆排序)
+ * [桶排序](#桶排序)
+ * [搜索](#搜索)
+ * [BFS](#bfs)
+ * [DFS](#dfs)
+ * [Backtracking](#backtracking)
+ * [分治](#分治)
+ * [动态规划](#动态规划)
+ * [分割整数](#分割整数)
+ * [矩阵路径](#矩阵路径)
+ * [斐波那契数列](#斐波那契数列)
+ * [最长递增子序列](#最长递增子序列)
+ * [最长公共子系列](#最长公共子系列)
+ * [0-1 背包](#0-1-背包)
+ * [数组区间](#数组区间)
+ * [字符串编辑](#字符串编辑)
+ * [其它问题](#其它问题)
+ * [数学](#数学)
+ * [素数](#素数)
+ * [最大公约数](#最大公约数)
+ * [进制转换](#进制转换)
+ * [阶乘](#阶乘)
+ * [字符串加法减法](#字符串加法减法)
+ * [相遇问题](#相遇问题)
+ * [多数投票问题](#多数投票问题)
+ * [其它](#其它)
+* [数据结构相关](#数据结构相关)
+ * [栈和队列](#栈和队列)
+ * [哈希表](#哈希表)
+ * [字符串](#字符串)
+ * [数组与矩阵](#数组与矩阵)
+ * [1-n 分布](#1-n-分布)
+ * [有序矩阵](#有序矩阵)
+ * [链表](#链表)
+ * [树](#树)
+ * [递归](#递归)
+ * [层次遍历](#层次遍历)
+ * [前中后序遍历](#前中后序遍历)
+ * [BST](#bst)
+ * [Trie](#trie)
+ * [图](#图)
+ * [位运算](#位运算)
+* [参考资料](#参考资料)
+
-# 算法思想
-## 二分查找
+# 算法思想
+
+## 二分查找
```java
-public int search(int key, int[] array) {
- int l = 0, h = array.length - 1;
- while (l <= h) {
- int mid = l + (h - l) / 2;
- if (key == array[mid]) return mid;
- if (key < array[mid]) h = mid - 1;
- else l = mid + 1;
- }
- return -1;
+public int search(int key, int[] array) {
+ int l = 0, h = array.length - 1;
+ while (l <= h) {
+ int mid = l + (h - l) / 2;
+ if (key == array[mid]) return mid;
+ if (key < array[mid]) h = mid - 1;
+ else l = mid + 1;
+ }
+ return -1;
}
```
实现时需要注意以下细节：
-1. 在计算 mid 时不能使用 mid = (l + h) / 2 这种方式，因为 l + h 可能会导致加法溢出，应该使用 mid = l + (h - l) / 2。
+1. 在计算 mid 时不能使用 mid = (l + h) / 2 这种方式，因为 l + h 可能会导致加法溢出，应该使用 mid = l + (h - l) / 2。
-2. 对 h 的赋值和循环条件有关，当循环条件为 l <= h 时，h = mid - 1；当循环条件为 l < h 时，h = mid。解释如下：在循环条件为 l <= h 时，如果 h = mid，会出现循环无法退出的情况，例如 l = 1，h = 1，此时 mid 也等于 1，如果此时继续执行 h = mid，那么就会无限循环；在循环条件为 l < h，如果 h = mid - 1，会错误跳过查找的数，例如对于数组 [1,2,3]，要查找 1，最开始 l = 0，h = 2，mid = 1，判断 key < arr[mid] 执行 h = mid - 1 = 0，此时循环退出，直接把查找的数跳过了。
+2. 对 h 的赋值和循环条件有关，当循环条件为 l <= h 时，h = mid - 1；当循环条件为 l < h 时，h = mid。解释如下：在循环条件为 l <= h 时，如果 h = mid，会出现循环无法退出的情况，例如 l = 1，h = 1，此时 mid 也等于 1，如果此时继续执行 h = mid，那么就会无限循环；在循环条件为 l < h，如果 h = mid - 1，会错误跳过查找的数，例如对于数组 [1,2,3]，要查找 1，最开始 l = 0，h = 2，mid = 1，判断 key < arr[mid] 执行 h = mid - 1 = 0，此时循环退出，直接把查找的数跳过了。
-3. l 的赋值一般都为 l = mid + 1。
+3. l 的赋值一般都为 l = mid + 1。
-**求开方**
+**求开方**
-[Leetcode : 69. Sqrt(x) (Easy)](https://leetcode.com/problems/sqrtx/description/)
+[Leetcode : 69. Sqrt(x) (Easy)](https://leetcode.com/problems/sqrtx/description/)
```html
-Input: 4
-Output: 2
+Input: 4
+Output: 2
-Input: 8
-Output: 2
-Explanation: The square root of 8 is 2.82842..., and since we want to return an integer, the decimal part will be truncated.
+Input: 8
+Output: 2
+Explanation: The square root of 8 is 2.82842..., and since we want to return an integer, the decimal part will be truncated.
```
-一个数 x 的开方 sqrt 一定在 0 ~ x 之间，并且满足 sqrt == x / sqrt 。可以利用二分查找在 0 ~ x 之间查找 sqrt。
+一个数 x 的开方 sqrt 一定在 0 \~ x 之间，并且满足 sqrt == x / sqrt 。可以利用二分查找在 0 \~ x 之间查找 sqrt。
```java
-public int mySqrt(int x) {
- if(x <= 1) return x;
- int l = 1, h = x;
- while(l <= h){
- int mid = l + (h - l) / 2;
- int sqrt = x / mid;
- if(sqrt == mid) return mid;
- else if(sqrt < mid) h = mid - 1;
- else l = mid + 1;
- }
- return h;
+public int mySqrt(int x) {
+ if(x <= 1) return x;
+ int l = 1, h = x;
+ while(l <= h){
+ int mid = l + (h - l) / 2;
+ int sqrt = x / mid;
+ if(sqrt == mid) return mid;
+ else if(sqrt < mid) h = mid - 1;
+ else l = mid + 1;
+ }
+ return h;
}
```
-**摆硬币**
+**摆硬币**
-[Leetcode : 441. Arranging Coins (Easy)](https://leetcode.com/problems/arranging-coins/description/)
+[Leetcode : 441. Arranging Coins (Easy)](https://leetcode.com/problems/arranging-coins/description/)
```html
-n = 8
-The coins can form the following rows:
+n = 8
+The coins can form the following rows:
¤
-¤ ¤
-¤ ¤ ¤
-¤ ¤
-Because the 4th row is incomplete, we return 3.
+¤ ¤
+¤ ¤ ¤
+¤ ¤
+Because the 4th row is incomplete, we return 3.
```
-题目描述：第 i 行摆 i 个，统计能够摆的行数。
+题目描述：第 i 行摆 i 个，统计能够摆的行数。
-返回 h 而不是 l，因为摆的硬币最后一行不能算进去。
+返回 h 而不是 l，因为摆的硬币最后一行不能算进去。
```java
-public int arrangeCoins(int n) {
- int l = 0, h = n;
- while(l <= h){
- int m = l + (h - l) / 2;
- long x = m * (m + 1L) / 2;
- if(x == n) return m;
- else if(x < n) l = m + 1;
- else h = m - 1;
- }
- return h;
+public int arrangeCoins(int n) {
+ int l = 0, h = n;
+ while(l <= h){
+ int m = l + (h - l) / 2;
+ long x = m * (m + 1L) / 2;
+ if(x == n) return m;
+ else if(x < n) l = m + 1;
+ else h = m - 1;
+ }
+ return h;
}
```
可以不用二分查找，更直观的解法如下：
```java
-public int arrangeCoins(int n) {
- int level = 1;
- while (n > 0) {
- n -= level;
- level++;
- }
- return n == 0 ? level - 1 : level - 2;
+public int arrangeCoins(int n) {
+ int level = 1;
+ while (n > 0) {
+ n -= level;
+ level++;
+ }
+ return n == 0 ? level - 1 : level - 2;
}
```
-**有序数组的 Single Element**
+**有序数组的 Single Element**
-[Leetcode : 540. Single Element in a Sorted Array (Medium)](https://leetcode.com/problems/single-element-in-a-sorted-array/description/)
+[Leetcode : 540. Single Element in a Sorted Array (Medium)](https://leetcode.com/problems/single-element-in-a-sorted-array/description/)
```html
-Input: [1,1,2,3,3,4,4,8,8]
-Output: 2
+Input: [1,1,2,3,3,4,4,8,8]
+Output: 2
```
题目描述：一个有序数组只有一个数不出现两次，找出这个数。
```java
-public int singleNonDuplicate(int[] nums) {
- int l = 0, h = nums.length - 1;
- while(l < h) {
- int m = l + (h - l) / 2;
- if(m % 2 == 1) m--; // 保证 l/h/m 都在偶数位，使得查找区间大小一直都是奇数
- if(nums[m] == nums[m + 1]) l = m + 2;
- else h = m;
- }
- return nums[l];
+public int singleNonDuplicate(int[] nums) {
+ int l = 0, h = nums.length - 1;
+ while(l < h) {
+ int m = l + (h - l) / 2;
+ if(m % 2 == 1) m--; // 保证 l/h/m 都在偶数位，使得查找区间大小一直都是奇数
+ if(nums[m] == nums[m + 1]) l = m + 2;
+ else h = m;
+ }
+ return nums[l];
}
```
-## 贪心思想
+## 贪心思想
贪心思想保证每次操作都是局部最优的，并且最后得到的结果是全局最优的。
-**分配饼干**
+**分配饼干**
-[Leetcode : 455. Assign Cookies (Easy)](https://leetcode.com/problems/assign-cookies/description/)
+[Leetcode : 455. Assign Cookies (Easy)](https://leetcode.com/problems/assign-cookies/description/)
```html
-Input: [1,2], [1,2,3]
-Output: 2
+Input: [1,2], [1,2,3]
+Output: 2
-Explanation: You have 2 children and 3 cookies. The greed factors of 2 children are 1, 2.
-You have 3 cookies and their sizes are big enough to gratify all of the children,
-You need to output 2.
+Explanation: You have 2 children and 3 cookies. The greed factors of 2 children are 1, 2.
+You have 3 cookies and their sizes are big enough to gratify all of the children,
+You need to output 2.
```
题目描述：每个孩子都有一个满足度，每个饼干都有一个大小，只有饼干的大小大于一个孩子的满足度，该孩子才会获得满足。求解最多可以获得满足的孩子数量。
因为最小的孩子最容易得到满足，因此先满足最小孩子。给一个孩子的饼干应当尽量小又能满足该孩子，这样大饼干就能拿来给满足度比较大的孩子。
-证明：假设在某次选择中，贪心策略选择给第 i 个孩子分配第 m 个饼干，并且第 i 个孩子满足度最小，第 m 个饼干为可以满足第 i 个孩子的最小饼干，利用贪心策略最终可以满足 k 个孩子。假设最优策略在这次选择中给 i 个孩子分配第 n 个饼干，并且这个饼干大于第 m 个饼干。我们发现使用第 m 个饼干去替代第 n 个饼干完全不影响后续的结果，因此不存在比贪心策略更优的策略，即贪心策略就是最优策略。
+证明：假设在某次选择中，贪心策略选择给第 i 个孩子分配第 m 个饼干，并且第 i 个孩子满足度最小，第 m 个饼干为可以满足第 i 个孩子的最小饼干，利用贪心策略最终可以满足 k 个孩子。假设最优策略在这次选择中给 i 个孩子分配第 n 个饼干，并且这个饼干大于第 m 个饼干。我们发现使用第 m 个饼干去替代第 n 个饼干完全不影响后续的结果，因此不存在比贪心策略更优的策略，即贪心策略就是最优策略。
```java
-public int findContentChildren(int[] g, int[] s) {
- Arrays.sort(g);
- Arrays.sort(s);
- int i = 0, j = 0;
- while(i < g.length && j < s.length){
- if(g[i] <= s[j]) i++;
- j++;
- }
- return i;
+public int findContentChildren(int[] g, int[] s) {
+ Arrays.sort(g);
+ Arrays.sort(s);
+ int i = 0, j = 0;
+ while(i < g.length && j < s.length){
+ if(g[i] <= s[j]) i++;
+ j++;
+ }
+ return i;
}
```
-**投飞镖刺破气球**
+**投飞镖刺破气球**
-[Leetcode : 452. Minimum Number of Arrows to Burst Balloons (Medium)](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/)
+[Leetcode : 452. Minimum Number of Arrows to Burst Balloons (Medium)](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/)
```
Input:
-[[10,16], [2,8], [1,6], [7,12]]
+[[10,16], [2,8], [1,6], [7,12]]
Output:
2
@@ -176,540 +227,540 @@ Output:
从左往右投飞镖，并且在每次投飞镖时满足以下条件：
-1. 左边已经没有气球了；
-2. 本次投飞镖能够刺破最多的气球。
+1. 左边已经没有气球了；
+2. 本次投飞镖能够刺破最多的气球。
```java
-public int findMinArrowShots(int[][] points) {
- if(points.length == 0) return 0;
- Arrays.sort(points,(a,b) -> (a[1] - b[1]));
- int curPos = points[0][1];
- int ret = 1;
- for (int i = 1; i < points.length; i++) {
- if(points[i][0] <= curPos) {
- continue;
- }
- curPos = points[i][1];
- ret++;
- }
- return ret;
- }
+public int findMinArrowShots(int[][] points) {
+ if(points.length == 0) return 0;
+ Arrays.sort(points,(a,b) -> (a[1] - b[1]));
+ int curPos = points[0][1];
+ int ret = 1;
+ for (int i = 1; i < points.length; i++) {
+ if(points[i][0] <= curPos) {
+ continue;
+ }
+ curPos = points[i][1];
+ ret++;
+ }
+ return ret;
+ }
```
-**股票的最大收益**
+**股票的最大收益**
-[Leetcode : 122. Best Time to Buy and Sell Stock II (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/)
+[Leetcode : 122. Best Time to Buy and Sell Stock II (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/)
题目描述：一次交易包含买入和卖出，多个交易之间不能交叉进行。
-对于 [a, b, c, d]，如果有 a <= b <= c <= d ，那么最大收益为 d - a。而 d - a = (d - c) + (c - b) + (b - a) ，因此当访问到一个 prices[i] 且 prices[i] - prices[i-1] > 0，那么就把 prices[i] - prices[i-1] 添加加到收益中，从而在局部最优的情况下也保证全局最优。
+对于 [a, b, c, d]，如果有 a <= b <= c <= d ，那么最大收益为 d - a。而 d - a = (d - c) + (c - b) + (b - a) ，因此当访问到一个 prices[i] 且 prices[i] - prices[i-1] > 0，那么就把 prices[i] - prices[i-1] 添加加到收益中，从而在局部最优的情况下也保证全局最优。
```java
-public int maxProfit(int[] prices) {
- int profit = 0;
- for(int i = 1; i < prices.length; i++){
- if(prices[i] > prices[i-1]) profit += (prices[i] - prices[i-1]);
- }
- return profit;
+public int maxProfit(int[] prices) {
+ int profit = 0;
+ for(int i = 1; i < prices.length; i++){
+ if(prices[i] > prices[i-1]) profit += (prices[i] - prices[i-1]);
+ }
+ return profit;
}
```
-**种植花朵**
+**种植花朵**
-[Leetcode : 605. Can Place Flowers (Easy)](https://leetcode.com/problems/can-place-flowers/description/)
+[Leetcode : 605. Can Place Flowers (Easy)](https://leetcode.com/problems/can-place-flowers/description/)
```html
-Input: flowerbed = [1,0,0,0,1], n = 1
-Output: True
+Input: flowerbed = [1,0,0,0,1], n = 1
+Output: True
```
题目描述：花朵之间至少需要一个单位的间隔。
```java
-public boolean canPlaceFlowers(int[] flowerbed, int n) {
- int cnt = 0;
- for(int i = 0; i < flowerbed.length; i++){
- if(flowerbed[i] == 1) continue;
- int pre = i == 0 ? 0 : flowerbed[i - 1];
- int next = i == flowerbed.length - 1 ? 0 : flowerbed[i + 1];
- if(pre == 0 && next == 0) {
- cnt++;
- flowerbed[i] = 1;
- }
- }
- return cnt >= n;
+public boolean canPlaceFlowers(int[] flowerbed, int n) {
+ int cnt = 0;
+ for(int i = 0; i < flowerbed.length; i++){
+ if(flowerbed[i] == 1) continue;
+ int pre = i == 0 ? 0 : flowerbed[i - 1];
+ int next = i == flowerbed.length - 1 ? 0 : flowerbed[i + 1];
+ if(pre == 0 && next == 0) {
+ cnt++;
+ flowerbed[i] = 1;
+ }
+ }
+ return cnt >= n;
}
```
-**修改一个数成为非递减数组**
+**修改一个数成为非递减数组**
-[Leetcode : 665. Non-decreasing Array (Easy)](https://leetcode.com/problems/non-decreasing-array/description/)
+[Leetcode : 665. Non-decreasing Array (Easy)](https://leetcode.com/problems/non-decreasing-array/description/)
```html
-Input: [4,2,3]
-Output: True
-Explanation: You could modify the first 4 to 1 to get a non-decreasing array.
+Input: [4,2,3]
+Output: True
+Explanation: You could modify the first 4 to 1 to get a non-decreasing array.
```
题目描述：判断一个数组能不能只修改一个数就成为非递减数组。
-在出现 nums[i] < nums[i - 1] 时，需要考虑的是应该修改数组的哪个数，使得本次修改能使 i 之前的数组成为非递减数组，并且 **不影响后续的操作**。优先考虑令 nums[i - 1] = nums[i]，因为如果修改 nums[i] = nums[i - 1] 的话，那么 nums[i] 这个数会变大，那么就有可能比 nums[i + 1] 大，从而影响了后续操作。还有一个比较特别的情况就是 nums[i] < nums[i - 2]，只修改 nums[i - 1] = nums[i] 不能令数组成为非递减，只能通过修改 nums[i] = nums[i - 1] 才行。
+在出现 nums[i] < nums[i - 1] 时，需要考虑的是应该修改数组的哪个数，使得本次修改能使 i 之前的数组成为非递减数组，并且 **不影响后续的操作** 。优先考虑令 nums[i - 1] = nums[i]，因为如果修改 nums[i] = nums[i - 1] 的话，那么 nums[i] 这个数会变大，那么就有可能比 nums[i + 1] 大，从而影响了后续操作。还有一个比较特别的情况就是 nums[i] < nums[i - 2]，只修改 nums[i - 1] = nums[i] 不能令数组成为非递减，只能通过修改 nums[i] = nums[i - 1] 才行。
```java
-public boolean checkPossibility(int[] nums) {
- int cnt = 0;
- for(int i = 1; i < nums.length; i++){
- if(nums[i] < nums[i - 1]){
- cnt++;
- if(i - 2 >= 0 && nums[i - 2] > nums[i]) nums[i] = nums[i-1];
- else nums[i - 1] = nums[i];
- }
- }
- return cnt <= 1;
+public boolean checkPossibility(int[] nums) {
+ int cnt = 0;
+ for(int i = 1; i < nums.length; i++){
+ if(nums[i] < nums[i - 1]){
+ cnt++;
+ if(i - 2 >= 0 && nums[i - 2] > nums[i]) nums[i] = nums[i-1];
+ else nums[i - 1] = nums[i];
+ }
+ }
+ return cnt <= 1;
}
```
-**判断是否为子串**
+**判断是否为子串**
-[Leetcode : 392. Is Subsequence (Medium)](https://leetcode.com/problems/is-subsequence/description/)
+[Leetcode : 392. Is Subsequence (Medium)](https://leetcode.com/problems/is-subsequence/description/)
```html
-s = "abc", t = "ahbgdc"
-Return true.
+s = "abc", t = "ahbgdc"
+Return true.
```
```java
-public boolean isSubsequence(String s, String t) {
- for (int i = 0, pos = 0; i < s.length(); i++, pos++) {
- pos = t.indexOf(s.charAt(i), pos);
- if(pos == -1) return false;
- }
- return true;
+public boolean isSubsequence(String s, String t) {
+ for (int i = 0, pos = 0; i < s.length(); i++, pos++) {
+ pos = t.indexOf(s.charAt(i), pos);
+ if(pos == -1) return false;
+ }
+ return true;
}
```
-**分隔字符串使同种字符出现在一起**
+**分隔字符串使同种字符出现在一起**
-[Leetcode : 763. Partition Labels (Medium)](https://leetcode.com/problems/partition-labels/description/)
+[Leetcode : 763. Partition Labels (Medium)](https://leetcode.com/problems/partition-labels/description/)
```html
-Input: S = "ababcbacadefegdehijhklij"
-Output: [9,7,8]
+Input: S = "ababcbacadefegdehijhklij"
+Output: [9,7,8]
Explanation:
-The partition is "ababcbaca", "defegde", "hijhklij".
-This is a partition so that each letter appears in at most one part.
-A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.
+The partition is "ababcbaca", "defegde", "hijhklij".
+This is a partition so that each letter appears in at most one part.
+A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.
```
```java
-public List partitionLabels(String S) {
- List ret = new ArrayList<>();
- int[] lastIdxs = new int[26];
- for(int i = 0; i < S.length(); i++) lastIdxs[S.charAt(i) - 'a'] = i;
- int startIdx = 0;
- while(startIdx < S.length()) {
- int endIdx = startIdx;
- for(int i = startIdx; i < S.length() && i <= endIdx; i++) {
- int lastIdx = lastIdxs[S.charAt(i) - 'a'];
- if(lastIdx == i) continue;
- if(lastIdx > endIdx) endIdx = lastIdx;
- }
- ret.add(endIdx - startIdx + 1);
- startIdx = endIdx + 1;
- }
- return ret;
+public List partitionLabels(String S) {
+ List ret = new ArrayList<>();
+ int[] lastIdxs = new int[26];
+ for(int i = 0; i < S.length(); i++) lastIdxs[S.charAt(i) - 'a'] = i;
+ int startIdx = 0;
+ while(startIdx < S.length()) {
+ int endIdx = startIdx;
+ for(int i = startIdx; i < S.length() && i <= endIdx; i++) {
+ int lastIdx = lastIdxs[S.charAt(i) - 'a'];
+ if(lastIdx == i) continue;
+ if(lastIdx > endIdx) endIdx = lastIdx;
+ }
+ ret.add(endIdx - startIdx + 1);
+ startIdx = endIdx + 1;
+ }
+ return ret;
}
```
-**根据身高和序号重组队列**
+**根据身高和序号重组队列**
-[Leetcode : 406. Queue Reconstruction by Height(Medium)](https://leetcode.com/problems/queue-reconstruction-by-height/description/)
+[Leetcode : 406. Queue Reconstruction by Height(Medium)](https://leetcode.com/problems/queue-reconstruction-by-height/description/)
```html
Input:
-[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
+[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
Output:
-[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]
+[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]
```
-题目描述：一个学生用两个分量 (h, k) 描述，h 表示身高，k 表示排在前面的有 k 个学生的身高比他高或者和他一样高。
+题目描述：一个学生用两个分量 (h, k) 描述，h 表示身高，k 表示排在前面的有 k 个学生的身高比他高或者和他一样高。
-为了在每次插入操作时不影响后续的操作，身高较高的学生应该先做插入操作，否则身高较小的学生原先正确插入第 k 个位置可能会变成第 k+1 个位置。
+为了在每次插入操作时不影响后续的操作，身高较高的学生应该先做插入操作，否则身高较小的学生原先正确插入第 k 个位置可能会变成第 k+1 个位置。
-身高降序、k 值升序，然后按排好序的顺序插入队列的第 k 个位置中。
+身高降序、k 值升序，然后按排好序的顺序插入队列的第 k 个位置中。
```java
-public int[][] reconstructQueue(int[][] people) {
- if(people == null || people.length == 0 || people[0].length == 0) return new int[0][0];
+public int[][] reconstructQueue(int[][] people) {
+ if(people == null || people.length == 0 || people[0].length == 0) return new int[0][0];
- Arrays.sort(people, new Comparator() {
- public int compare(int[] a, int[] b) {
- if(a[0] == b[0]) return a[1] - b[1];
- return b[0] - a[0];
- }
- });
+ Arrays.sort(people, new Comparator() {
+ public int compare(int[] a, int[] b) {
+ if(a[0] == b[0]) return a[1] - b[1];
+ return b[0] - a[0];
+ }
+ });
- int n = people.length;
- List tmp = new ArrayList<>();
- for(int i = 0; i < n; i++) {
- tmp.add(people[i][1], new int[]{people[i][0], people[i][1]});
- }
+ int n = people.length;
+ List tmp = new ArrayList<>();
+ for(int i = 0; i < n; i++) {
+ tmp.add(people[i][1], new int[]{people[i][0], people[i][1]});
+ }
- int[][] ret = new int[n][2];
- for(int i = 0; i < n; i++) {
- ret[i][0] = tmp.get(i)[0];
- ret[i][1] = tmp.get(i)[1];
- }
- return ret;
+ int[][] ret = new int[n][2];
+ for(int i = 0; i < n; i++) {
+ ret[i][0] = tmp.get(i)[0];
+ ret[i][1] = tmp.get(i)[1];
+ }
+ return ret;
}
```
-## 双指针
+## 双指针
双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。
-**从一个已经排序的数组中查找出两个数，使它们的和为 0**
+**从一个已经排序的数组中查找出两个数，使它们的和为 0**
-[Leetcode ：167. Two Sum II - Input array is sorted (Easy)](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/description/)
+[Leetcode ：167. Two Sum II - Input array is sorted (Easy)](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/description/)
```html
-Input: numbers={2, 7, 11, 15}, target=9
-Output: index1=1, index2=2
+Input: numbers={2, 7, 11, 15}, target=9
+Output: index1=1, index2=2
```
使用双指针，一个指针指向元素较小的值，一个指针指向元素较大的值。指向较小元素的指针从头向尾遍历，指向较大元素的指针从尾向头遍历。
-如果两个指针指向元素的和 sum == target，那么得到要求的结果；如果 sum > target，移动较大的元素，使 sum 变小一些；如果 sum < target，移动较小的元素，使 sum 变大一些。
+如果两个指针指向元素的和 sum == target，那么得到要求的结果；如果 sum > target，移动较大的元素，使 sum 变小一些；如果 sum < target，移动较小的元素，使 sum 变大一些。
```java
-public int[] twoSum(int[] numbers, int target) {
- int i = 0, j = numbers.length - 1;
- while (i < j) {
- int sum = numbers[i] + numbers[j];
- if (sum == target) return new int[]{i + 1, j + 1};
- else if (sum < target) i++;
- else j--;
- }
- return null;
+public int[] twoSum(int[] numbers, int target) {
+ int i = 0, j = numbers.length - 1;
+ while (i < j) {
+ int sum = numbers[i] + numbers[j];
+ if (sum == target) return new int[]{i + 1, j + 1};
+ else if (sum < target) i++;
+ else j--;
+ }
+ return null;
}
```
-**反转字符串中的元音字符**
+**反转字符串中的元音字符**
-[Leetcode : 345. Reverse Vowels of a String (Easy)](https://leetcode.com/problems/reverse-vowels-of-a-string/description/)
+[Leetcode : 345. Reverse Vowels of a String (Easy)](https://leetcode.com/problems/reverse-vowels-of-a-string/description/)
```html
-Given s = "leetcode", return "leotcede".
+Given s = "leetcode", return "leotcede".
```
使用双指针，指向待反转的两个元音字符，一个指针从头向尾遍历，一个指针从尾到头遍历。
```java
-private HashSet vowels = new HashSet<>(Arrays.asList('a','e','i','o','u','A','E','I','O','U'));
+private HashSet vowels = new HashSet<>(Arrays.asList('a','e','i','o','u','A','E','I','O','U'));
-public String reverseVowels(String s) {
- if(s.length() == 0) return s;
- int i = 0, j = s.length() - 1;
- char[] result = new char[s.length()];
- while(i <= j){
- char ci = s.charAt(i);
- char cj = s.charAt(j);
- if(!vowels.contains(ci)){
- result[i] = ci;
- i++;
- } else if(!vowels.contains(cj)){
- result[j] = cj;
- j--;
- } else{
- result[i] = cj;
- result[j] = ci;
- i++;
- j--;
- }
- }
- return new String(result);
+public String reverseVowels(String s) {
+ if(s.length() == 0) return s;
+ int i = 0, j = s.length() - 1;
+ char[] result = new char[s.length()];
+ while(i <= j){
+ char ci = s.charAt(i);
+ char cj = s.charAt(j);
+ if(!vowels.contains(ci)){
+ result[i] = ci;
+ i++;
+ } else if(!vowels.contains(cj)){
+ result[j] = cj;
+ j--;
+ } else{
+ result[i] = cj;
+ result[j] = ci;
+ i++;
+ j--;
+ }
+ }
+ return new String(result);
}
```
-**两数平方和**
+**两数平方和**
-[Leetcode : 633. Sum of Square Numbers (Easy)](https://leetcode.com/problems/sum-of-square-numbers/description/)
+[Leetcode : 633. Sum of Square Numbers (Easy)](https://leetcode.com/problems/sum-of-square-numbers/description/)
```html
-Input: 5
-Output: True
-Explanation: 1 * 1 + 2 * 2 = 5
+Input: 5
+Output: True
+Explanation: 1 * 1 + 2 * 2 = 5
```
-题目描述：判断一个数是否为两个数的平方和，例如 5 = 12 + 22。
+题目描述：判断一个数是否为两个数的平方和，例如 5 = 12 + 22。
```java
-public boolean judgeSquareSum(int c) {
- int left = 0, right = (int) Math.sqrt(c);
- while(left <= right){
- int powSum = left * left + right * right;
- if(powSum == c) return true;
- else if(powSum > c) right--;
- else left++;
- }
- return false;
+public boolean judgeSquareSum(int c) {
+ int left = 0, right = (int) Math.sqrt(c);
+ while(left <= right){
+ int powSum = left * left + right * right;
+ if(powSum == c) return true;
+ else if(powSum > c) right--;
+ else left++;
+ }
+ return false;
}
```
-**回文字符串**
+**回文字符串**
-[Leetcode : 680. Valid Palindrome II (Easy)](https://leetcode.com/problems/valid-palindrome-ii/description/)
+[Leetcode : 680. Valid Palindrome II (Easy)](https://leetcode.com/problems/valid-palindrome-ii/description/)
```html
-Input: "abca"
-Output: True
-Explanation: You could delete the character 'c'.
+Input: "abca"
+Output: True
+Explanation: You could delete the character 'c'.
```
题目描述：字符串可以删除一个字符，判断是否能构成回文字符串。
```java
-public boolean validPalindrome(String s) {
- int i = 0, j = s.length() -1;
- while(i < j){
- if(s.charAt(i) != s.charAt(j)){
- return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);
- }
- i++;
- j--;
- }
- return true;
+public boolean validPalindrome(String s) {
+ int i = 0, j = s.length() -1;
+ while(i < j){
+ if(s.charAt(i) != s.charAt(j)){
+ return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);
+ }
+ i++;
+ j--;
+ }
+ return true;
}
-private boolean isPalindrome(String s, int l, int r){
- while(l < r){
- if(s.charAt(l) != s.charAt(r))
- return false;
- l++;
- r--;
- }
- return true;
+private boolean isPalindrome(String s, int l, int r){
+ while(l < r){
+ if(s.charAt(l) != s.charAt(r))
+ return false;
+ l++;
+ r--;
+ }
+ return true;
}
```
-**归并两个有序数组**
+**归并两个有序数组**
-[Leetcode : 88. Merge Sorted Array (Easy)](https://leetcode.com/problems/merge-sorted-array/description/)
+[Leetcode : 88. Merge Sorted Array (Easy)](https://leetcode.com/problems/merge-sorted-array/description/)
题目描述：把归并结果存到第一个数组上
```java
-public void merge(int[] nums1, int m, int[] nums2, int n) {
- int i = m - 1, j = n - 1; // 需要从尾开始遍历，否则在 nums1 上归并得到的值会覆盖还未进行归并比较的值
- int idx = m + n - 1;
- while(i >= 0 || j >= 0){
- if(i < 0) nums1[idx] = nums2[j--];
- else if(j < 0) nums1[idx] = nums1[i--];
- else if(nums1[i] > nums2[j]) nums1[idx] = nums1[i--];
- else nums1[idx] = nums2[j--];
- idx--;
- }
+public void merge(int[] nums1, int m, int[] nums2, int n) {
+ int i = m - 1, j = n - 1; // 需要从尾开始遍历，否则在 nums1 上归并得到的值会覆盖还未进行归并比较的值
+ int idx = m + n - 1;
+ while(i >= 0 || j >= 0){
+ if(i < 0) nums1[idx] = nums2[j--];
+ else if(j < 0) nums1[idx] = nums1[i--];
+ else if(nums1[i] > nums2[j]) nums1[idx] = nums1[i--];
+ else nums1[idx] = nums2[j--];
+ idx--;
+ }
}
```
-**判断链表是否存在环**
+**判断链表是否存在环**
-[Leetcode : 141. Linked List Cycle (Easy)](https://leetcode.com/problems/linked-list-cycle/description/)
+[Leetcode : 141. Linked List Cycle (Easy)](https://leetcode.com/problems/linked-list-cycle/description/)
使用双指针，一个指针每次移动一个节点，一个指针每次移动两个节点，如果存在环，那么这两个指针一定会相遇。
```java
-public boolean hasCycle(ListNode head) {
- if(head == null) return false;
- ListNode l1 = head, l2 = head.next;
- while(l1 != null && l2 != null){
- if(l1 == l2) return true;
- l1 = l1.next;
- if(l2.next == null) break;
- l2 = l2.next.next;
- }
- return false;
+public boolean hasCycle(ListNode head) {
+ if(head == null) return false;
+ ListNode l1 = head, l2 = head.next;
+ while(l1 != null && l2 != null){
+ if(l1 == l2) return true;
+ l1 = l1.next;
+ if(l2.next == null) break;
+ l2 = l2.next.next;
+ }
+ return false;
}
```
-**最长子序列**
+**最长子序列**
-[Leetcode : 524. Longest Word in Dictionary through Deleting (Medium)](https://leetcode.com/problems/longest-word-in-dictionary-through-deleting/description/)
+[Leetcode : 524. Longest Word in Dictionary through Deleting (Medium)](https://leetcode.com/problems/longest-word-in-dictionary-through-deleting/description/)
```
Input:
-s = "abpcplea", d = ["ale","apple","monkey","plea"]
+s = "abpcplea", d = ["ale","apple","monkey","plea"]
Output:
"apple"
```
-题目描述：可以删除 s 中的一些字符，使得它成为字符串列表 d 中的一个字符串。要求在 d 中找到满足条件的最长字符串。
+题目描述：可以删除 s 中的一些字符，使得它成为字符串列表 d 中的一个字符串。要求在 d 中找到满足条件的最长字符串。
```java
-public String findLongestWord(String s, List d) {
- String ret = "";
- for (String str : d) {
- for (int i = 0, j = 0; i < s.length() && j < str.length(); i++) {
- if (s.charAt(i) == str.charAt(j)) j++;
- if (j == str.length()) {
- if (ret.length() < str.length()
- || (ret.length() == str.length() && ret.compareTo(str) > 0)) {
- ret = str;
- }
- }
- }
- }
- return ret;
+public String findLongestWord(String s, List d) {
+ String ret = "";
+ for (String str : d) {
+ for (int i = 0, j = 0; i < s.length() && j < str.length(); i++) {
+ if (s.charAt(i) == str.charAt(j)) j++;
+ if (j == str.length()) {
+ if (ret.length() < str.length()
+ || (ret.length() == str.length() && ret.compareTo(str) > 0)) {
+ ret = str;
+ }
+ }
+ }
+ }
+ return ret;
}
```
-## 排序
+## 排序
-### 快速选择
+### 快速选择
-一般用于求解 **Kth Element** 问题，可以在 O(n) 时间复杂度，O(1) 空间复杂度完成求解工作。
+一般用于求解 **Kth Element** 问题，可以在 O(n) 时间复杂度，O(1) 空间复杂度完成求解工作。
-与快速排序一样，快速选择一般需要先打乱数组，否则最坏情况下时间复杂度为 O(n2)。
+与快速排序一样，快速选择一般需要先打乱数组，否则最坏情况下时间复杂度为 O(n2)。
-### 堆排序
+### 堆排序
-堆排序用于求解 **TopK Elements** 问题，通过维护一个大小为 K 的堆，堆中的元素就是 TopK Elements。当然它也可以用于求解 Kth Element 问题，因为最后出堆的那个元素就是 Kth Element。快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。
+堆排序用于求解 **TopK Elements** 问题，通过维护一个大小为 K 的堆，堆中的元素就是 TopK Elements。当然它也可以用于求解 Kth Element 问题，因为最后出堆的那个元素就是 Kth Element。快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。
-**Kth Element**
+**Kth Element**
-[Leetocde : 215. Kth Largest Element in an Array (Medium)](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
+[Leetocde : 215. Kth Largest Element in an Array (Medium)](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
-**排序**：时间复杂度 O(nlgn)，空间复杂度 O(1) 解法
+**排序** ：时间复杂度 O(nlgn)，空间复杂度 O(1) 解法
```java
-public int findKthLargest(int[] nums, int k) {
- int N = nums.length;
- Arrays.sort(nums);
- return nums[N - k];
+public int findKthLargest(int[] nums, int k) {
+ int N = nums.length;
+ Arrays.sort(nums);
+ return nums[N - k];
}
```
-**堆排序**：时间复杂度 O(nlgk)，空间复杂度 O(k)
+**堆排序** ：时间复杂度 O(nlgk)，空间复杂度 O(k)
```java
-public int findKthLargest(int[] nums, int k) {
- PriorityQueue pq = new PriorityQueue<>();
- for(int val : nums) {
- pq.offer(val);
- if(pq.size() > k) {
- pq.poll();
- }
- }
- return pq.peek();
+public int findKthLargest(int[] nums, int k) {
+ PriorityQueue pq = new PriorityQueue<>();
+ for(int val : nums) {
+ pq.offer(val);
+ if(pq.size() > k) {
+ pq.poll();
+ }
+ }
+ return pq.peek();
}
```
-**快速选择**：时间复杂度 O(n)，空间复杂度 O(1)
+**快速选择** ：时间复杂度 O(n)，空间复杂度 O(1)
```java
-public int findKthLargest(int[] nums, int k) {
- k = nums.length - k;
- int lo = 0;
- int hi = nums.length - 1;
- while (lo < hi) {
- final int j = partition(nums, lo, hi);
- if(j < k) {
- lo = j + 1;
- } else if (j > k) {
- hi = j - 1;
- } else {
- break;
- }
- }
- return nums[k];
- }
+public int findKthLargest(int[] nums, int k) {
+ k = nums.length - k;
+ int lo = 0;
+ int hi = nums.length - 1;
+ while (lo < hi) {
+ final int j = partition(nums, lo, hi);
+ if(j < k) {
+ lo = j + 1;
+ } else if (j > k) {
+ hi = j - 1;
+ } else {
+ break;
+ }
+ }
+ return nums[k];
+ }
- private int partition(int[] a, int lo, int hi) {
- int i = lo;
- int j = hi + 1;
- while(true) {
- while(i < hi && less(a[++i], a[lo]));
- while(j > lo && less(a[lo], a[--j]));
- if(i >= j) {
- break;
- }
- exch(a, i, j);
- }
- exch(a, lo, j);
- return j;
- }
+ private int partition(int[] a, int lo, int hi) {
+ int i = lo;
+ int j = hi + 1;
+ while(true) {
+ while(i < hi && less(a[++i], a[lo]));
+ while(j > lo && less(a[lo], a[--j]));
+ if(i >= j) {
+ break;
+ }
+ exch(a, i, j);
+ }
+ exch(a, lo, j);
+ return j;
+ }
- private void exch(int[] a, int i, int j) {
- final int tmp = a[i];
- a[i] = a[j];
- a[j] = tmp;
- }
+ private void exch(int[] a, int i, int j) {
+ final int tmp = a[i];
+ a[i] = a[j];
+ a[j] = tmp;
+ }
- private boolean less(int v, int w) {
- return v < w;
- }
+ private boolean less(int v, int w) {
+ return v < w;
+ }
}
```
-### 桶排序
+### 桶排序
-**找出出现频率最多的 k 个数**
+**找出出现频率最多的 k 个数**
-[Leetcode : 347. Top K Frequent Elements (Medium)](https://leetcode.com/problems/top-k-frequent-elements/description/)
+[Leetcode : 347. Top K Frequent Elements (Medium)](https://leetcode.com/problems/top-k-frequent-elements/description/)
```html
-Given [1,1,1,2,2,3] and k = 2, return [1,2].
+Given [1,1,1,2,2,3] and k = 2, return [1,2].
```
```java
-public List topKFrequent(int[] nums, int k) {
- List ret = new ArrayList<>();
- Map map = new HashMap<>();
- for(int num : nums) {
- map.put(num, map.getOrDefault(num, 0) + 1);
- }
- List[] bucket = new List[nums.length + 1];
- for(int key : map.keySet()) {
- int frequency = map.get(key);
- if(bucket[frequency] == null) {
- bucket[frequency] = new ArrayList<>();
- }
- bucket[frequency].add(key);
- }
+public List topKFrequent(int[] nums, int k) {
+ List ret = new ArrayList<>();
+ Map map = new HashMap<>();
+ for(int num : nums) {
+ map.put(num, map.getOrDefault(num, 0) + 1);
+ }
+ List[] bucket = new List[nums.length + 1];
+ for(int key : map.keySet()) {
+ int frequency = map.get(key);
+ if(bucket[frequency] == null) {
+ bucket[frequency] = new ArrayList<>();
+ }
+ bucket[frequency].add(key);
+ }
- for(int i = bucket.length - 1; i >= 0 && ret.size() < k; i--) {
- if(bucket[i] != null) {
- ret.addAll(bucket[i]);
- }
- }
- return ret;
+ for(int i = bucket.length - 1; i >= 0 && ret.size() < k; i--) {
+ if(bucket[i] != null) {
+ ret.addAll(bucket[i]);
+ }
+ }
+ return ret;
}
```
-## 搜索
+## 搜索
深度优先搜索和广度优先搜索广泛运用于树和图中，但是它们的应用远远不止如此。
-### BFS
+### BFS
-
+
-广度优先搜索的搜索过程有点像一层一层地进行遍历：从节点 0 出发，遍历到 6、2、1 和 5 这四个新节点。
+广度优先搜索的搜索过程有点像一层一层地进行遍历：从节点 0 出发，遍历到 6、2、1 和 5 这四个新节点。
-继续从 6 开始遍历，得到节点 4 ；从 2 开始遍历，没有下一个节点；从 1 开始遍历，没有下一个节点；从 5 开始遍历，得到 3 和 4 节点。这一轮总共得到两个新节点：4 和 3 。
+继续从 6 开始遍历，得到节点 4 ；从 2 开始遍历，没有下一个节点；从 1 开始遍历，没有下一个节点；从 5 开始遍历，得到 3 和 4 节点。这一轮总共得到两个新节点：4 和 3 。
反复从新节点出发进行上述的遍历操作。
-可以看到，每一轮遍历的节点都与根节点路径长度相同。设 di 表示第 i 个节点与根节点的路径长度，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 di<=dj。利用这个结论，可以求解最短路径 **最优解** 问题：第一次遍历到目的节点，其所经过的路径为最短路径，如果继续遍历，之后再遍历到目的节点，所经过的路径就不是最短路径。
+可以看到，每一轮遍历的节点都与根节点路径长度相同。设 di 表示第 i 个节点与根节点的路径长度，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 di<=dj。利用这个结论，可以求解最短路径 **最优解** 问题：第一次遍历到目的节点，其所经过的路径为最短路径，如果继续遍历，之后再遍历到目的节点，所经过的路径就不是最短路径。
-在程序实现 BFS 时需要考虑以下问题：
+在程序实现 BFS 时需要考虑以下问题：
-- 队列：用来存储每一轮遍历的节点
-- 标记：对于遍历过得节点，应该将它标记，防止重复遍历；
+- 队列：用来存储每一轮遍历的节点
+- 标记：对于遍历过得节点，应该将它标记，防止重复遍历；
-**计算在网格中从原点到特定点的最短路径长度**
+**计算在网格中从原点到特定点的最短路径长度**
```html
[[1,1,0,1],
@@ -719,51 +770,51 @@ public List topKFrequent(int[] nums, int k) {
```
```java
-public int minPathLength(int[][] grids, int tr, int tc) {
- int[][] next = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
- int m = grids.length, n = grids[0].length;
- Queue queue = new LinkedList<>();
- queue.add(new Position(0, 0, 1));
- while (!queue.isEmpty()) {
- Position pos = queue.poll();
- for (int i = 0; i < 4; i++) {
- Position nextPos = new Position(pos.r + next[i][0], pos.c + next[i][1], pos.length + 1);
- if (nextPos.r < 0 || nextPos.r >= m || nextPos.c < 0 || nextPos.c >= n) continue;
- if (grids[nextPos.r][nextPos.c] != 1) continue;
- grids[nextPos.r][nextPos.c] = 0;
- if (nextPos.r == tr && nextPos.c == tc) return nextPos.length;
- queue.add(nextPos);
- }
- }
- return -1;
+public int minPathLength(int[][] grids, int tr, int tc) {
+ int[][] next = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+ int m = grids.length, n = grids[0].length;
+ Queue queue = new LinkedList<>();
+ queue.add(new Position(0, 0, 1));
+ while (!queue.isEmpty()) {
+ Position pos = queue.poll();
+ for (int i = 0; i < 4; i++) {
+ Position nextPos = new Position(pos.r + next[i][0], pos.c + next[i][1], pos.length + 1);
+ if (nextPos.r < 0 || nextPos.r >= m || nextPos.c < 0 || nextPos.c >= n) continue;
+ if (grids[nextPos.r][nextPos.c] != 1) continue;
+ grids[nextPos.r][nextPos.c] = 0;
+ if (nextPos.r == tr && nextPos.c == tc) return nextPos.length;
+ queue.add(nextPos);
+ }
+ }
+ return -1;
}
-private class Position {
- int r, c, length;
- public Position(int r, int c, int length) {
- this.r = r;
- this.c = c;
- this.length = length;
- }
+private class Position {
+ int r, c, length;
+ public Position(int r, int c, int length) {
+ this.r = r;
+ this.c = c;
+ this.length = length;
+ }
}
```
-### DFS
+### DFS
-
+ 
-广度优先搜索一层一层遍历，每一层遍历到的所有新节点，要用队列先存储起来以备下一层遍历的时候再遍历；而深度优先搜索在遍历到一个新节点时立马对新节点进行遍历：从节点 0 出发开始遍历，得到到新节点 6 时，立马对新节点 6 进行遍历，得到新节点 4；如此反复以这种方式遍历新节点，直到没有新节点了，此时返回。返回到根节点 0 的情况是，继续对根节点 0 进行遍历，得到新节点 2，然后继续以上步骤。
+广度优先搜索一层一层遍历，每一层遍历到的所有新节点，要用队列先存储起来以备下一层遍历的时候再遍历；而深度优先搜索在遍历到一个新节点时立马对新节点进行遍历：从节点 0 出发开始遍历，得到到新节点 6 时，立马对新节点 6 进行遍历，得到新节点 4；如此反复以这种方式遍历新节点，直到没有新节点了，此时返回。返回到根节点 0 的情况是，继续对根节点 0 进行遍历，得到新节点 2，然后继续以上步骤。
-从一个节点出发，使用 DFS 对一个图进行遍历时，能够遍历到的节点都是从初始节点可达的，DFS 常用来求解这种 **可达性** 问题。
+从一个节点出发，使用 DFS 对一个图进行遍历时，能够遍历到的节点都是从初始节点可达的，DFS 常用来求解这种 **可达性** 问题。
-在程序实现 DFS 时需要考虑以下问题：
+在程序实现 DFS 时需要考虑以下问题：
-- 栈：用栈来保存当前节点信息，当遍历新节点返回时能够继续遍历当前节点。也可以使用递归栈。
-- 标记：和 BFS 一样同样需要对已经遍历过得节点进行标记。
+- 栈：用栈来保存当前节点信息，当遍历新节点返回时能够继续遍历当前节点。也可以使用递归栈。
+- 标记：和 BFS 一样同样需要对已经遍历过得节点进行标记。
-**查找最大的连通面积**
+**查找最大的连通面积**
-[Leetcode : 695. Max Area of Island (Easy)](https://leetcode.com/problems/max-area-of-island/description/)
+[Leetcode : 695. Max Area of Island (Easy)](https://leetcode.com/problems/max-area-of-island/description/)
```html
[[0,0,1,0,0,0,0,1,0,0,0,0,0],
@@ -777,1999 +828,1999 @@ private class Position {
```
```java
-public int maxAreaOfIsland(int[][] grid) {
- int m = grid.length, n = grid[0].length;
- int max = 0;
- for(int i = 0; i < m; i++){
- for(int j = 0; j < n; j++){
- if(grid[i][j] == 1) max = Math.max(max, dfs(grid, i, j));
- }
- }
- return max;
+public int maxAreaOfIsland(int[][] grid) {
+ int m = grid.length, n = grid[0].length;
+ int max = 0;
+ for(int i = 0; i < m; i++){
+ for(int j = 0; j < n; j++){
+ if(grid[i][j] == 1) max = Math.max(max, dfs(grid, i, j));
+ }
+ }
+ return max;
}
-private int dfs(int[][] grid, int i, int j){
- int m = grid.length, n = grid[0].length;
- if(i < 0 || i >= m || j < 0 || j >= n) return 0;
- if(grid[i][j] == 0) return 0;
- grid[i][j] = 0;
- return dfs(grid, i + 1, j) + dfs(grid, i - 1, j) + dfs(grid, i, j + 1) + dfs(grid, i, j - 1) + 1;
+private int dfs(int[][] grid, int i, int j){
+ int m = grid.length, n = grid[0].length;
+ if(i < 0 || i >= m || j < 0 || j >= n) return 0;
+ if(grid[i][j] == 0) return 0;
+ grid[i][j] = 0;
+ return dfs(grid, i + 1, j) + dfs(grid, i - 1, j) + dfs(grid, i, j + 1) + dfs(grid, i, j - 1) + 1;
}
```
-**图的连通分量**
+**图的连通分量**
-[Leetcode : 547. Friend Circles (Medium)](https://leetcode.com/problems/friend-circles/description/)
+[Leetcode : 547. Friend Circles (Medium)](https://leetcode.com/problems/friend-circles/description/)
```html
Input:
[[1,1,0],
- [1,1,0],
- [0,0,1]]
-Output: 2
-Explanation:The 0th and 1st students are direct friends, so they are in a friend circle.
-The 2nd student himself is in a friend circle. So return 2.
+ [1,1,0],
+ [0,0,1]]
+Output: 2
+Explanation:The 0th and 1st students are direct friends, so they are in a friend circle.
+The 2nd student himself is in a friend circle. So return 2.
```
```java
-public int findCircleNum(int[][] M) {
- int n = M.length;
- int ret = 0;
- boolean[] hasFind = new boolean[n];
- for(int i = 0; i < n; i++) {
- if(!hasFind[i]) {
- dfs(M, i, hasFind);
- ret++;
- }
- }
- return ret;
+public int findCircleNum(int[][] M) {
+ int n = M.length;
+ int ret = 0;
+ boolean[] hasFind = new boolean[n];
+ for(int i = 0; i < n; i++) {
+ if(!hasFind[i]) {
+ dfs(M, i, hasFind);
+ ret++;
+ }
+ }
+ return ret;
}
-private void dfs(int[][] M, int i, boolean[] hasFind) {
- hasFind[i] = true;
- int n = M.length;
- for(int k = 0; k < n; k++) {
- if(M[i][k] == 1 && !hasFind[k]) {
- dfs(M, k, hasFind);
- }
- }
+private void dfs(int[][] M, int i, boolean[] hasFind) {
+ hasFind[i] = true;
+ int n = M.length;
+ for(int k = 0; k < n; k++) {
+ if(M[i][k] == 1 && !hasFind[k]) {
+ dfs(M, k, hasFind);
+ }
+ }
}
```
-**矩阵中的连通区域数量**
+**矩阵中的连通区域数量**
-[Leetcode : 200. Number of Islands (Medium)](https://leetcode.com/problems/number-of-islands/description/)
+[Leetcode : 200. Number of Islands (Medium)](https://leetcode.com/problems/number-of-islands/description/)
```html
11110
11010
11000
00000
-Answer: 1
+Answer: 1
```
```java
-private int m, n;
-private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+private int m, n;
+private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
-public int numIslands(char[][] grid) {
- if (grid == null || grid.length == 0) return 0;
- m = grid.length;
- n = grid[0].length;
- int ret = 0;
- for (int i = 0; i < m; i++) {
- for (int j = 0; j < n; j++) {
- if (grid[i][j] == '1') {
- dfs(grid, i, j);
- ret++;
- }
- }
- }
- return ret;
+public int numIslands(char[][] grid) {
+ if (grid == null || grid.length == 0) return 0;
+ m = grid.length;
+ n = grid[0].length;
+ int ret = 0;
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ if (grid[i][j] == '1') {
+ dfs(grid, i, j);
+ ret++;
+ }
+ }
+ }
+ return ret;
}
-private void dfs(char[][] grid, int i, int j) {
- if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == '0') return;
- grid[i][j] = '0';
- for (int k = 0; k < direction.length; k++) {
- dfs(grid, i + direction[k][0], j + direction[k][1]);
- }
+private void dfs(char[][] grid, int i, int j) {
+ if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == '0') return;
+ grid[i][j] = '0';
+ for (int k = 0; k < direction.length; k++) {
+ dfs(grid, i + direction[k][0], j + direction[k][1]);
+ }
}
```
-**输出二叉树中所有从根到叶子的路径**
+**输出二叉树中所有从根到叶子的路径**
-[Leetcode : 257. Binary Tree Paths (Easy)](https://leetcode.com/problems/binary-tree-paths/description/)
+[Leetcode : 257. Binary Tree Paths (Easy)](https://leetcode.com/problems/binary-tree-paths/description/)
```html
- 1
-/ \
-2 3
+ 1
+/ \
+2 3
\
- 5
+ 5
```
```html
-["1->2->5", "1->3"]
+["1->2->5", "1->3"]
```
```java
-public List binaryTreePaths(TreeNode root) {
- List ret = new ArrayList();
- if(root == null) return ret;
- dfs(root, "", ret);
- return ret;
+public List binaryTreePaths(TreeNode root) {
+ List ret = new ArrayList();
+ if(root == null) return ret;
+ dfs(root, "", ret);
+ return ret;
}
-private void dfs(TreeNode root, String prefix, List ret){
- if(root == null) return;
- if(root.left == null && root.right == null){
- ret.add(prefix + root.val);
- return;
- }
- prefix += (root.val + "->");
- dfs(root.left, prefix, ret);
- dfs(root.right, prefix, ret);
+private void dfs(TreeNode root, String prefix, List ret){
+ if(root == null) return;
+ if(root.left == null && root.right == null){
+ ret.add(prefix + root.val);
+ return;
+ }
+ prefix += (root.val + "->");
+ dfs(root.left, prefix, ret);
+ dfs(root.right, prefix, ret);
}
```
-**填充封闭区域**
+**填充封闭区域**
-[Leetcode : 130. Surrounded Regions (Medium)](https://leetcode.com/problems/surrounded-regions/description/)
+[Leetcode : 130. Surrounded Regions (Medium)](https://leetcode.com/problems/surrounded-regions/description/)
```html
-For example,
-X X X X
-X O O X
-X X O X
-X O X X
+For example,
+X X X X
+X O O X
+X X O X
+X O X X
-After running your function, the board should be:
-X X X X
-X X X X
-X X X X
-X O X X
+After running your function, the board should be:
+X X X X
+X X X X
+X X X X
+X O X X
```
-题目描述：使得被 'X' 的 'O' 转换为 'X'。
+题目描述：使得被 'X' 的 'O' 转换为 'X'。
先填充最外侧，剩下的就是里侧了。
```java
-private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
-private int m, n;
+private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+private int m, n;
-public void solve(char[][] board) {
- if (board == null || board.length == 0) return;
- m = board.length;
- n = board[0].length;
- for (int i = 0; i < m; i++) {
- dfs(board, i, 0);
- dfs(board, i, n - 1);
- }
- for (int i = 0; i < n; i++) {
- dfs(board, 0, i);
- dfs(board, m - 1, i);
- }
- for (int i = 0; i < m; i++) {
- for (int j = 0; j < n; j++) {
- if (board[i][j] == 'T') board[i][j] = 'O';
- else if (board[i][j] == 'O') board[i][j] = 'X';
- }
- }
+public void solve(char[][] board) {
+ if (board == null || board.length == 0) return;
+ m = board.length;
+ n = board[0].length;
+ for (int i = 0; i < m; i++) {
+ dfs(board, i, 0);
+ dfs(board, i, n - 1);
+ }
+ for (int i = 0; i < n; i++) {
+ dfs(board, 0, i);
+ dfs(board, m - 1, i);
+ }
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ if (board[i][j] == 'T') board[i][j] = 'O';
+ else if (board[i][j] == 'O') board[i][j] = 'X';
+ }
+ }
}
-private void dfs(char[][] board, int r, int c) {
- if (r < 0 || r >= m || c < 0 || c >= n || board[r][c] != 'O') return;
- board[r][c] = 'T';
- for (int i = 0; i < direction.length; i++) {
- dfs(board, r + direction[i][0], c + direction[i][1]);
- }
+private void dfs(char[][] board, int r, int c) {
+ if (r < 0 || r >= m || c < 0 || c >= n || board[r][c] != 'O') return;
+ board[r][c] = 'T';
+ for (int i = 0; i < direction.length; i++) {
+ dfs(board, r + direction[i][0], c + direction[i][1]);
+ }
}
```
-**从两个方向都能到达的区域**
+**从两个方向都能到达的区域**
-[Leetcode : 417. Pacific Atlantic Water Flow (Medium)](https://leetcode.com/problems/pacific-atlantic-water-flow/description/)
+[Leetcode : 417. Pacific Atlantic Water Flow (Medium)](https://leetcode.com/problems/pacific-atlantic-water-flow/description/)
```html
-Given the following 5x5 matrix:
+Given the following 5x5 matrix:
- Pacific ~ ~ ~ ~ ~
- ~ 1 2 2 3 (5) *
- ~ 3 2 3 (4) (4) *
- ~ 2 4 (5) 3 1 *
- ~ (6) (7) 1 4 5 *
- ~ (5) 1 1 2 4 *
- * * * * * Atlantic
+ Pacific ~ ~ ~ ~ ~
+ ~ 1 2 2 3 (5) *
+ ~ 3 2 3 (4) (4) *
+ ~ 2 4 (5) 3 1 *
+ ~ (6) (7) 1 4 5 *
+ ~ (5) 1 1 2 4 *
+ * * * * * Atlantic
Return:
-[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (positions with parentheses in above matrix).
+[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (positions with parentheses in above matrix).
```
题目描述：左边和上边是太平洋，右边和下边是大西洋，内部的数字代表海拔，海拔高的地方的水能够流到低的地方，求解水能够流到太平洋和大西洋的所有位置。
```java
-private int m, n;
-private int[][] matrix;
-private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+private int m, n;
+private int[][] matrix;
+private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
-public List pacificAtlantic(int[][] matrix) {
- List ret = new ArrayList<>();
- if (matrix == null || matrix.length == 0) return ret;
- this.m = matrix.length;
- this.n = matrix[0].length;
- this.matrix = matrix;
- boolean[][] canReachP = new boolean[m][n];
- boolean[][] canReachA = new boolean[m][n];
- for (int i = 0; i < m; i++) {
- dfs(i, 0, canReachP);
- dfs(i, n - 1, canReachA);
- }
- for (int i = 0; i < n; i++) {
- dfs(0, i, canReachP);
- dfs(m - 1, i, canReachA);
- }
- for (int i = 0; i < m; i++) {
- for (int j = 0; j < n; j++) {
- if (canReachP[i][j] && canReachA[i][j]) {
- ret.add(new int[]{i, j});
- }
- }
- }
- return ret;
+public List pacificAtlantic(int[][] matrix) {
+ List ret = new ArrayList<>();
+ if (matrix == null || matrix.length == 0) return ret;
+ this.m = matrix.length;
+ this.n = matrix[0].length;
+ this.matrix = matrix;
+ boolean[][] canReachP = new boolean[m][n];
+ boolean[][] canReachA = new boolean[m][n];
+ for (int i = 0; i < m; i++) {
+ dfs(i, 0, canReachP);
+ dfs(i, n - 1, canReachA);
+ }
+ for (int i = 0; i < n; i++) {
+ dfs(0, i, canReachP);
+ dfs(m - 1, i, canReachA);
+ }
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ if (canReachP[i][j] && canReachA[i][j]) {
+ ret.add(new int[]{i, j});
+ }
+ }
+ }
+ return ret;
}
-private void dfs(int r, int c, boolean[][] canReach) {
- if(canReach[r][c]) return;
- canReach[r][c] = true;
- for (int i = 0; i < direction.length; i++) {
- int nextR = direction[i][0] + r;
- int nextC = direction[i][1] + c;
- if (nextR < 0 || nextR >= m || nextC < 0 || nextC >= n
- || matrix[r][c] > matrix[nextR][nextC]) continue;
- dfs(nextR, nextC, canReach);
- }
+private void dfs(int r, int c, boolean[][] canReach) {
+ if(canReach[r][c]) return;
+ canReach[r][c] = true;
+ for (int i = 0; i < direction.length; i++) {
+ int nextR = direction[i][0] + r;
+ int nextC = direction[i][1] + c;
+ if (nextR < 0 || nextR >= m || nextC < 0 || nextC >= n
+ || matrix[r][c] > matrix[nextR][nextC]) continue;
+ dfs(nextR, nextC, canReach);
+ }
}
```
-**N 皇后**
+**N 皇后**
-[Leetcode : 51. N-Queens (Hard)](https://leetcode.com/problems/n-queens/description/)
+[Leetcode : 51. N-Queens (Hard)](https://leetcode.com/problems/n-queens/description/)
-
+ 
-题目描述：在 n\*n 的矩阵中摆放 n 个皇后，并且每个皇后不能在同一行，同一列，同一对角线上，要求解所有的 n 皇后解。
+题目描述：在 n\*n 的矩阵中摆放 n 个皇后，并且每个皇后不能在同一行，同一列，同一对角线上，要求解所有的 n 皇后解。
-一行一行地摆放，在确定一行中的那个皇后应该摆在哪一列时，需要用三个标记数组来确定某一列是否合法，这三个标记数组分别为：列标记数组、45 度对角线标记数组和 135 度对角线标记数组。
+一行一行地摆放，在确定一行中的那个皇后应该摆在哪一列时，需要用三个标记数组来确定某一列是否合法，这三个标记数组分别为：列标记数组、45 度对角线标记数组和 135 度对角线标记数组。
-45 度对角线标记数组的维度为 2\*n - 1，通过下图可以明确 (r,c) 的位置所在的数组下标为 r + c。
+45 度对角线标记数组的维度为 2\*n - 1，通过下图可以明确 (r,c) 的位置所在的数组下标为 r + c。
-
+ 
-135 度对角线标记数组的维度也是 2\*n - 1，(r,c) 的位置所在的数组下标为 n - 1 - (r - c)。
+135 度对角线标记数组的维度也是 2\*n - 1，(r,c) 的位置所在的数组下标为 n - 1 - (r - c)。
-
+ 
```java
-private List> ret;
-private char[][] nQueens;
-private boolean[] colUsed;
-private boolean[] diagonals45Used;
-private boolean[] diagonals135Used;
-private int n;
+private List> ret;
+private char[][] nQueens;
+private boolean[] colUsed;
+private boolean[] diagonals45Used;
+private boolean[] diagonals135Used;
+private int n;
-public List> solveNQueens(int n) {
- ret = new ArrayList<>();
- nQueens = new char[n][n];
- Arrays.fill(nQueens, '.');
- colUsed = new boolean[n];
- diagonals45Used = new boolean[2 * n - 1];
- diagonals135Used = new boolean[2 * n - 1];
- this.n = n;
- backstracking(0);
- return ret;
+public List> solveNQueens(int n) {
+ ret = new ArrayList<>();
+ nQueens = new char[n][n];
+ Arrays.fill(nQueens, '.');
+ colUsed = new boolean[n];
+ diagonals45Used = new boolean[2 * n - 1];
+ diagonals135Used = new boolean[2 * n - 1];
+ this.n = n;
+ backstracking(0);
+ return ret;
}
-private void backstracking(int row) {
- if (row == n) {
- List list = new ArrayList<>();
- for (char[] chars : nQueens) {
- list.add(new String(chars));
- }
- ret.add(list);
- return;
- }
+private void backstracking(int row) {
+ if (row == n) {
+ List list = new ArrayList<>();
+ for (char[] chars : nQueens) {
+ list.add(new String(chars));
+ }
+ ret.add(list);
+ return;
+ }
- for (int col = 0; col < n; col++) {
- int diagonals45Idx = row + col;
- int diagonals135Idx = n - 1 - (row - col);
- if (colUsed[col] || diagonals45Used[diagonals45Idx] || diagonals135Used[diagonals135Idx]) {
- continue;
- }
- nQueens[row][col] = 'Q';
- colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = true;
- backstracking(row + 1);
- colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = false;
- nQueens[row][col] = '.';
- }
+ for (int col = 0; col < n; col++) {
+ int diagonals45Idx = row + col;
+ int diagonals135Idx = n - 1 - (row - col);
+ if (colUsed[col] || diagonals45Used[diagonals45Idx] || diagonals135Used[diagonals135Idx]) {
+ continue;
+ }
+ nQueens[row][col] = 'Q';
+ colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = true;
+ backstracking(row + 1);
+ colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = false;
+ nQueens[row][col] = '.';
+ }
}
```
-### Backtracking
+### Backtracking
-回溯是 DFS 的一种，它不是用在遍历图的节点上，而是用于求解 **排列组合** 问题，例如有 { 'a','b','c' } 三个字符，求解所有由这三个字符排列得到的字符串。
+回溯是 DFS 的一种，它不是用在遍历图的节点上，而是用于求解 **排列组合** 问题，例如有 { 'a','b','c' } 三个字符，求解所有由这三个字符排列得到的字符串。
在程序实现时，回溯需要注意对元素进行标记的问题。使用递归实现的回溯，在访问一个新元素进入新的递归调用，此时需要将新元素标记为已经访问，这样才能在继续递归调用时不用重复访问该元素；但是在递归返回时，需要将该元素标记为未访问，因为只需要保证在一个递归链中不同时访问一个元素，而在不同的递归链是可以访问已经访问过但是不在当前递归链中的元素。
-**数字键盘组合**
+**数字键盘组合**
-[Leetcode : 17. Letter Combinations of a Phone Number (Medium)](https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/)
+[Leetcode : 17. Letter Combinations of a Phone Number (Medium)](https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/)
-
+ 
```html
-Input:Digit string "23"
-Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
+Input:Digit string "23"
+Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
```
```java
-private static final String[] KEYS = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+private static final String[] KEYS = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
-public List letterCombinations(String digits) {
- List ret = new ArrayList<>();
- if (digits != null && digits.length() != 0) {
- combination("", digits, 0, ret);
- }
- return ret;
+public List letterCombinations(String digits) {
+ List ret = new ArrayList<>();
+ if (digits != null && digits.length() != 0) {
+ combination("", digits, 0, ret);
+ }
+ return ret;
}
-private void combination(String prefix, String digits, int offset, List ret) {
- if (offset == digits.length()) {
- ret.add(prefix);
- return;
- }
- String letters = KEYS[digits.charAt(offset) - '0'];
- for (char c : letters.toCharArray()) {
- combination(prefix + c, digits, offset + 1, ret);
- }
+private void combination(String prefix, String digits, int offset, List ret) {
+ if (offset == digits.length()) {
+ ret.add(prefix);
+ return;
+ }
+ String letters = KEYS[digits.charAt(offset) - '0'];
+ for (char c : letters.toCharArray()) {
+ combination(prefix + c, digits, offset + 1, ret);
+ }
}
```
-**在矩阵中寻找字符串**
+**在矩阵中寻找字符串**
-[Leetcode : 79. Word Search (Medium)](https://leetcode.com/problems/word-search/description/)
+[Leetcode : 79. Word Search (Medium)](https://leetcode.com/problems/word-search/description/)
```html
-For example,
-Given board =
+For example,
+Given board =
[
- ['A','B','C','E'],
- ['S','F','C','S'],
- ['A','D','E','E']
+ ['A','B','C','E'],
+ ['S','F','C','S'],
+ ['A','D','E','E']
]
-word = "ABCCED", -> returns true,
-word = "SEE", -> returns true,
-word = "ABCB", -> returns false.
+word = "ABCCED", -> returns true,
+word = "SEE", -> returns true,
+word = "ABCB", -> returns false.
```
```java
-private static int[][] shift = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
-private static boolean[][] visited;
-private int m;
-private int n;
+private static int[][] shift = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+private static boolean[][] visited;
+private int m;
+private int n;
-public boolean exist(char[][] board, String word) {
- if (word == null || word.length() == 0) return true;
- if (board == null || board.length == 0 || board[0].length == 0) return false;
- m = board.length;
- n = board[0].length;
- visited = new boolean[m][n];
- for (int i = 0; i < m; i++) {
- for (int j = 0; j < n; j++) {
- if (dfs(board, word, 0, i, j)) return true;
- }
- }
- return false;
+public boolean exist(char[][] board, String word) {
+ if (word == null || word.length() == 0) return true;
+ if (board == null || board.length == 0 || board[0].length == 0) return false;
+ m = board.length;
+ n = board[0].length;
+ visited = new boolean[m][n];
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ if (dfs(board, word, 0, i, j)) return true;
+ }
+ }
+ return false;
}
-private boolean dfs(char[][] board, String word, int start, int r, int c) {
- if (start == word.length()) {
- return true;
- }
- if (r < 0 || r >= m || c < 0 || c >= n || board[r][c] != word.charAt(start) || visited[r][c] ) {
- return false;
- }
- visited[r][c] = true;
- for (int i = 0; i < shift.length; i++) {
- int nextR = r + shift[i][0];
- int nextC = c + shift[i][1];
- if (dfs(board, word, start + 1, nextR, nextC)) return true;
- }
- visited[r][c] = false;
- return false;
+private boolean dfs(char[][] board, String word, int start, int r, int c) {
+ if (start == word.length()) {
+ return true;
+ }
+ if (r < 0 || r >= m || c < 0 || c >= n || board[r][c] != word.charAt(start) || visited[r][c] ) {
+ return false;
+ }
+ visited[r][c] = true;
+ for (int i = 0; i < shift.length; i++) {
+ int nextR = r + shift[i][0];
+ int nextC = c + shift[i][1];
+ if (dfs(board, word, start + 1, nextR, nextC)) return true;
+ }
+ visited[r][c] = false;
+ return false;
}
```
-**IP 地址划分**
+**IP 地址划分**
-[Leetcode : 93. Restore IP Addresses(Medium)](https://leetcode.com/problems/restore-ip-addresses/description/)
+[Leetcode : 93. Restore IP Addresses(Medium)](https://leetcode.com/problems/restore-ip-addresses/description/)
```html
-Given "25525511135",
-return ["255.255.11.135", "255.255.111.35"].
+Given "25525511135",
+return ["255.255.11.135", "255.255.111.35"].
```
```java
-private List ret;
+private List ret;
-public List restoreIpAddresses(String s) {
- ret = new ArrayList<>();
- doRestore(0, "", s);
- return ret;
+public List restoreIpAddresses(String s) {
+ ret = new ArrayList<>();
+ doRestore(0, "", s);
+ return ret;
}
-private void doRestore(int k, String path, String s) {
- if (k == 4 || s.length() == 0) {
- if (k == 4 && s.length() == 0) {
- ret.add(path);
- }
- return;
- }
- for (int i = 0; i < s.length() && i <= 2; i++) {
- if (i != 0 && s.charAt(0) == '0') break;
- String part = s.substring(0, i + 1);
- if (Integer.valueOf(part) <= 255) {
- doRestore(k + 1, path.length() != 0 ? path + "." + part : part, s.substring(i + 1));
- }
- }
+private void doRestore(int k, String path, String s) {
+ if (k == 4 || s.length() == 0) {
+ if (k == 4 && s.length() == 0) {
+ ret.add(path);
+ }
+ return;
+ }
+ for (int i = 0; i < s.length() && i <= 2; i++) {
+ if (i != 0 && s.charAt(0) == '0') break;
+ String part = s.substring(0, i + 1);
+ if (Integer.valueOf(part) <= 255) {
+ doRestore(k + 1, path.length() != 0 ? path + "." + part : part, s.substring(i + 1));
+ }
+ }
}
```
-**排列**
+**排列**
-[Leetcode : 46. Permutations (Medium)](https://leetcode.com/problems/permutations/description/)
+[Leetcode : 46. Permutations (Medium)](https://leetcode.com/problems/permutations/description/)
```html
-[1,2,3] have the following permutations:
+[1,2,3] have the following permutations:
[
- [1,2,3],
- [1,3,2],
- [2,1,3],
- [2,3,1],
- [3,1,2],
- [3,2,1]
+ [1,2,3],
+ [1,3,2],
+ [2,1,3],
+ [2,3,1],
+ [3,1,2],
+ [3,2,1]
]
```
```java
-public List> permute(int[] nums) {
- List> ret = new ArrayList<>();
- List permuteList = new ArrayList<>();
- boolean[] visited = new boolean[nums.length];
- backtracking(permuteList, visited, nums, ret);
- return ret;
+public List> permute(int[] nums) {
+ List> ret = new ArrayList<>();
+ List permuteList = new ArrayList<>();
+ boolean[] visited = new boolean[nums.length];
+ backtracking(permuteList, visited, nums, ret);
+ return ret;
}
-private void backtracking(List permuteList, boolean[] visited, int[] nums, List> ret){
- if(permuteList.size() == nums.length){
- ret.add(new ArrayList(permuteList));
- return;
- }
+private void backtracking(List permuteList, boolean[] visited, int[] nums, List> ret){
+ if(permuteList.size() == nums.length){
+ ret.add(new ArrayList(permuteList));
+ return;
+ }
- for(int i = 0; i < visited.length; i++){
- if(visited[i]) continue;
- visited[i] = true;
- permuteList.add(nums[i]);
- backtracking(permuteList, visited, nums, ret);
- permuteList.remove(permuteList.size() - 1);
- visited[i] = false;
- }
+ for(int i = 0; i < visited.length; i++){
+ if(visited[i]) continue;
+ visited[i] = true;
+ permuteList.add(nums[i]);
+ backtracking(permuteList, visited, nums, ret);
+ permuteList.remove(permuteList.size() - 1);
+ visited[i] = false;
+ }
}
```
-**含有相同元素求排列**
+**含有相同元素求排列**
-[Leetcode : 47. Permutations II (Medium)](https://leetcode.com/problems/permutations-ii/description/)
+[Leetcode : 47. Permutations II (Medium)](https://leetcode.com/problems/permutations-ii/description/)
```html
-[1,1,2] have the following unique permutations:
-[[1,1,2], [1,2,1], [2,1,1]]
+[1,1,2] have the following unique permutations:
+[[1,1,2], [1,2,1], [2,1,1]]
```
题目描述：数组元素可能含有相同的元素，进行排列时就有可能出先重复的排列，要求重复的排列只返回一个。
-在实现上，和 Permutations 不同的是要先排序，然后在添加一个元素时，判断这个元素是否等于前一个元素，如果等于，并且前一个元素还未访问，那么就跳过这个元素。
+在实现上，和 Permutations 不同的是要先排序，然后在添加一个元素时，判断这个元素是否等于前一个元素，如果等于，并且前一个元素还未访问，那么就跳过这个元素。
```java
-public List> permuteUnique(int[] nums) {
- List> ret = new ArrayList<>();
- List permuteList = new ArrayList<>();
- Arrays.sort(nums);
- boolean[] visited = new boolean[nums.length];
- backtracking(permuteList, visited, nums, ret);
- return ret;
+public List> permuteUnique(int[] nums) {
+ List> ret = new ArrayList<>();
+ List permuteList = new ArrayList<>();
+ Arrays.sort(nums);
+ boolean[] visited = new boolean[nums.length];
+ backtracking(permuteList, visited, nums, ret);
+ return ret;
}
-private void backtracking(List permuteList, boolean[] visited, int[] nums, List> ret) {
- if (permuteList.size() == nums.length) {
- ret.add(new ArrayList(permuteList));
- return;
- }
+private void backtracking(List permuteList, boolean[] visited, int[] nums, List> ret) {
+ if (permuteList.size() == nums.length) {
+ ret.add(new ArrayList(permuteList));
+ return;
+ }
- for (int i = 0; i < visited.length; i++) {
- if (i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) continue;
- if (visited[i]) continue;
- visited[i] = true;
- permuteList.add(nums[i]);
- backtracking(permuteList, visited, nums, ret);
- permuteList.remove(permuteList.size() - 1);
- visited[i] = false;
- }
+ for (int i = 0; i < visited.length; i++) {
+ if (i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) continue;
+ if (visited[i]) continue;
+ visited[i] = true;
+ permuteList.add(nums[i]);
+ backtracking(permuteList, visited, nums, ret);
+ permuteList.remove(permuteList.size() - 1);
+ visited[i] = false;
+ }
}
```
-**组合**
+**组合**
-[Leetcode : 77. Combinations (Medium)](https://leetcode.com/problems/combinations/description/)
+[Leetcode : 77. Combinations (Medium)](https://leetcode.com/problems/combinations/description/)
```html
-If n = 4 and k = 2, a solution is:
+If n = 4 and k = 2, a solution is:
[
- [2,4],
- [3,4],
- [2,3],
- [1,2],
- [1,3],
- [1,4],
+ [2,4],
+ [3,4],
+ [2,3],
+ [1,2],
+ [1,3],
+ [1,4],
]
```
```java
-public List> combine(int n, int k) {
- List> ret = new ArrayList<>();
- List combineList = new ArrayList<>();
- backtracking(1, n, k, combineList, ret);
- return ret;
+public List> combine(int n, int k) {
+ List> ret = new ArrayList<>();
+ List combineList = new ArrayList<>();
+ backtracking(1, n, k, combineList, ret);
+ return ret;
}
-private void backtracking(int start, int n, int k, List combineList, List> ret){
- if(k == 0){
- ret.add(new ArrayList(combineList)); // 这里要重新构造一个 List
- return;
- }
+private void backtracking(int start, int n, int k, List combineList, List> ret){
+ if(k == 0){
+ ret.add(new ArrayList(combineList)); // 这里要重新构造一个 List
+ return;
+ }
- for(int i = start; i <= n - k + 1; i++){ // 剪枝
+ for(int i = start; i <= n - k + 1; i++){ // 剪枝
- combineList.add(i); // 把 i 标记为已访问
- backtracking(i + 1, n, k - 1, combineList, ret);
- combineList.remove(combineList.size() - 1); // 把 i 标记为未访问
- }
+ combineList.add(i); // 把 i 标记为已访问
+ backtracking(i + 1, n, k - 1, combineList, ret);
+ combineList.remove(combineList.size() - 1); // 把 i 标记为未访问
+ }
}
```
-**组合求和**
+**组合求和**
-[Leetcode : 39. Combination Sum (Medium)](https://leetcode.com/problems/combination-sum/description/)
+[Leetcode : 39. Combination Sum (Medium)](https://leetcode.com/problems/combination-sum/description/)
```html
-given candidate set [2, 3, 6, 7] and target 7,
-A solution set is:
-[[7],[2, 2, 3]]
+given candidate set [2, 3, 6, 7] and target 7,
+A solution set is:
+[[7],[2, 2, 3]]
```
```java
- private List> ret;
+ private List> ret;
- public List> combinationSum(int[] candidates, int target) {
- ret = new ArrayList<>();
- doCombination(candidates, target, 0, new ArrayList<>());
- return ret;
- }
+ public List> combinationSum(int[] candidates, int target) {
+ ret = new ArrayList<>();
+ doCombination(candidates, target, 0, new ArrayList<>());
+ return ret;
+ }
- private void doCombination(int[] candidates, int target, int start, List list) {
- if (target == 0) {
- ret.add(new ArrayList<>(list));
- return;
- }
- for (int i = start; i < candidates.length; i++) {
- if (candidates[i] <= target) {
- list.add(candidates[i]);
- doCombination(candidates, target - candidates[i], i, list);
- list.remove(list.size() - 1);
- }
- }
- }
+ private void doCombination(int[] candidates, int target, int start, List list) {
+ if (target == 0) {
+ ret.add(new ArrayList<>(list));
+ return;
+ }
+ for (int i = start; i < candidates.length; i++) {
+ if (candidates[i] <= target) {
+ list.add(candidates[i]);
+ doCombination(candidates, target - candidates[i], i, list);
+ list.remove(list.size() - 1);
+ }
+ }
+ }
```
-**含有相同元素的求组合求和**
+**含有相同元素的求组合求和**
-[Leetcode : 40. Combination Sum II (Medium)](https://leetcode.com/problems/combination-sum-ii/description/)
+[Leetcode : 40. Combination Sum II (Medium)](https://leetcode.com/problems/combination-sum-ii/description/)
```html
-For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8,
-A solution set is:
+For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8,
+A solution set is:
[
- [1, 7],
- [1, 2, 5],
- [2, 6],
- [1, 1, 6]
+ [1, 7],
+ [1, 2, 5],
+ [2, 6],
+ [1, 1, 6]
]
```
```java
-private List> ret;
+private List> ret;
-public List> combinationSum2(int[] candidates, int target) {
- ret = new ArrayList<>();
- Arrays.sort(candidates);
- doCombination(candidates, target, 0, new ArrayList<>(), new boolean[candidates.length]);
- return ret;
+public List> combinationSum2(int[] candidates, int target) {
+ ret = new ArrayList<>();
+ Arrays.sort(candidates);
+ doCombination(candidates, target, 0, new ArrayList<>(), new boolean[candidates.length]);
+ return ret;
}
-private void doCombination(int[] candidates, int target, int start, List list, boolean[] visited) {
- if (target == 0) {
- ret.add(new ArrayList<>(list));
- return;
- }
- for (int i = start; i < candidates.length; i++) {
- if (i != 0 && candidates[i] == candidates[i - 1] && !visited[i - 1]) continue;
- if (candidates[i] <= target) {
- list.add(candidates[i]);
- visited[i] = true;
- doCombination(candidates, target - candidates[i], i + 1, list, visited);
- visited[i] = false;
- list.remove(list.size() - 1);
- }
- }
+private void doCombination(int[] candidates, int target, int start, List list, boolean[] visited) {
+ if (target == 0) {
+ ret.add(new ArrayList<>(list));
+ return;
+ }
+ for (int i = start; i < candidates.length; i++) {
+ if (i != 0 && candidates[i] == candidates[i - 1] && !visited[i - 1]) continue;
+ if (candidates[i] <= target) {
+ list.add(candidates[i]);
+ visited[i] = true;
+ doCombination(candidates, target - candidates[i], i + 1, list, visited);
+ visited[i] = false;
+ list.remove(list.size() - 1);
+ }
+ }
}
```
-**子集**
+**子集**
-[Leetcode : 78. Subsets (Medium)](https://leetcode.com/problems/subsets/description/)
+[Leetcode : 78. Subsets (Medium)](https://leetcode.com/problems/subsets/description/)
-题目描述：找出集合的所有子集，子集不能重复，[1, 2] 和 [2, 1] 这种子集算重复
+题目描述：找出集合的所有子集，子集不能重复，[1, 2] 和 [2, 1] 这种子集算重复
```java
-private List> ret;
-private List subsetList;
+private List> ret;
+private List subsetList;
-public List> subsets(int[] nums) {
- ret = new ArrayList<>();
- subsetList = new ArrayList<>();
- for (int i = 0; i <= nums.length; i++) {
- backtracking(0, i, nums);
- }
- return ret;
+public List> subsets(int[] nums) {
+ ret = new ArrayList<>();
+ subsetList = new ArrayList<>();
+ for (int i = 0; i <= nums.length; i++) {
+ backtracking(0, i, nums);
+ }
+ return ret;
}
-private void backtracking(int startIdx, int size, int[] nums) {
- if (subsetList.size() == size) {
- ret.add(new ArrayList(subsetList));
- return;
- }
+private void backtracking(int startIdx, int size, int[] nums) {
+ if (subsetList.size() == size) {
+ ret.add(new ArrayList(subsetList));
+ return;
+ }
- for (int i = startIdx; i < nums.length; i++) {
- subsetList.add(nums[i]);
- backtracking(i + 1, size, nums); // startIdx 设为下一个元素，使 subset 中的元素都递增排序
- subsetList.remove(subsetList.size() - 1);
- }
+ for (int i = startIdx; i < nums.length; i++) {
+ subsetList.add(nums[i]);
+ backtracking(i + 1, size, nums); // startIdx 设为下一个元素，使 subset 中的元素都递增排序
+ subsetList.remove(subsetList.size() - 1);
+ }
}
```
-**含有相同元素求子集**
+**含有相同元素求子集**
-[Leetcode : 90. Subsets II (Medium)](https://leetcode.com/problems/subsets-ii/description/)
+[Leetcode : 90. Subsets II (Medium)](https://leetcode.com/problems/subsets-ii/description/)
```html
-For example,
-If nums = [1,2,2], a solution is:
+For example,
+If nums = [1,2,2], a solution is:
[
- [2],
- [1],
- [1,2,2],
- [2,2],
- [1,2],
- []
+ [2],
+ [1],
+ [1,2,2],
+ [2,2],
+ [1,2],
+ []
]
```
```java
-private List> ret;
-private List subsetList;
-private boolean[] visited;
+private List> ret;
+private List subsetList;
+private boolean[] visited;
-public List> subsetsWithDup(int[] nums) {
- ret = new ArrayList<>();
- subsetList = new ArrayList<>();
- visited = new boolean[nums.length];
- Arrays.sort(nums);
- for (int i = 0; i <= nums.length; i++) {
- backtracking(0, i, nums);
- }
- return ret;
+public List> subsetsWithDup(int[] nums) {
+ ret = new ArrayList<>();
+ subsetList = new ArrayList<>();
+ visited = new boolean[nums.length];
+ Arrays.sort(nums);
+ for (int i = 0; i <= nums.length; i++) {
+ backtracking(0, i, nums);
+ }
+ return ret;
}
-private void backtracking(int startIdx, int size, int[] nums) {
- if (subsetList.size() == size) {
- ret.add(new ArrayList(subsetList));
- return;
- }
+private void backtracking(int startIdx, int size, int[] nums) {
+ if (subsetList.size() == size) {
+ ret.add(new ArrayList(subsetList));
+ return;
+ }
- for (int i = startIdx; i < nums.length; i++) {
- if (i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) continue;
- subsetList.add(nums[i]);
- visited[i] = true;
- backtracking(i + 1, size, nums);
- visited[i] = false;
- subsetList.remove(subsetList.size() - 1);
- }
+ for (int i = startIdx; i < nums.length; i++) {
+ if (i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) continue;
+ subsetList.add(nums[i]);
+ visited[i] = true;
+ backtracking(i + 1, size, nums);
+ visited[i] = false;
+ subsetList.remove(subsetList.size() - 1);
+ }
}
```
-**分割字符串使得每部分都是回文数**
+**分割字符串使得每部分都是回文数**
-[Leetcode : 131. Palindrome Partitioning (Medium)](https://leetcode.com/problems/palindrome-partitioning/description/)
+[Leetcode : 131. Palindrome Partitioning (Medium)](https://leetcode.com/problems/palindrome-partitioning/description/)
```java
-private List> ret;
+private List> ret;
-public List> partition(String s) {
- ret = new ArrayList<>();
- doPartion(new ArrayList<>(), s);
- return ret;
+public List> partition(String s) {
+ ret = new ArrayList<>();
+ doPartion(new ArrayList<>(), s);
+ return ret;
}
-private void doPartion(List list, String s) {
- if (s.length() == 0) {
- ret.add(new ArrayList<>(list));
- return;
- }
- for (int i = 0; i < s.length(); i++) {
- if (isPalindrome(s, 0, i)) {
- list.add(s.substring(0, i + 1));
- doPartion(list, s.substring(i + 1));
- list.remove(list.size() - 1);
- }
- }
+private void doPartion(List list, String s) {
+ if (s.length() == 0) {
+ ret.add(new ArrayList<>(list));
+ return;
+ }
+ for (int i = 0; i < s.length(); i++) {
+ if (isPalindrome(s, 0, i)) {
+ list.add(s.substring(0, i + 1));
+ doPartion(list, s.substring(i + 1));
+ list.remove(list.size() - 1);
+ }
+ }
}
-private boolean isPalindrome(String s, int begin, int end) {
- while (begin < end) {
- if (s.charAt(begin++) != s.charAt(end--)) return false;
- }
- return true;
+private boolean isPalindrome(String s, int begin, int end) {
+ while (begin < end) {
+ if (s.charAt(begin++) != s.charAt(end--)) return false;
+ }
+ return true;
}
```
-**数独**
+**数独**
-[Leetcode : 37. Sudoku Solver (Hard)](https://leetcode.com/problems/sudoku-solver/description/)
+[Leetcode : 37. Sudoku Solver (Hard)](https://leetcode.com/problems/sudoku-solver/description/)
-
+ 
```java
-private boolean[][] rowsUsed = new boolean[9][10];
-private boolean[][] colsUsed = new boolean[9][10];
-private boolean[][] cubesUsed = new boolean[9][10];
-private char[][] board;
+private boolean[][] rowsUsed = new boolean[9][10];
+private boolean[][] colsUsed = new boolean[9][10];
+private boolean[][] cubesUsed = new boolean[9][10];
+private char[][] board;
-public void solveSudoku(char[][] board) {
- this.board = board;
- for (int i = 0; i < 9; i++) {
- for (int j = 0; j < 9; j++) {
- if (board[i][j] == '.') continue;
- int num = board[i][j] - '0';
- rowsUsed[i][num] = true;
- colsUsed[j][num] = true;
- cubesUsed[cubeNum(i, j)][num] = true;
- }
- }
- for (int i = 0; i < 9; i++) {
- for (int j = 0; j < 9; j++) {
- backtracking(i, j);
- }
- }
+public void solveSudoku(char[][] board) {
+ this.board = board;
+ for (int i = 0; i < 9; i++) {
+ for (int j = 0; j < 9; j++) {
+ if (board[i][j] == '.') continue;
+ int num = board[i][j] - '0';
+ rowsUsed[i][num] = true;
+ colsUsed[j][num] = true;
+ cubesUsed[cubeNum(i, j)][num] = true;
+ }
+ }
+ for (int i = 0; i < 9; i++) {
+ for (int j = 0; j < 9; j++) {
+ backtracking(i, j);
+ }
+ }
}
-private boolean backtracking(int row, int col) {
- while (row < 9 && board[row][col] != '.') {
- row = col == 8 ? row + 1 : row;
- col = col == 8 ? 0 : col + 1;
- }
- if (row == 9) {
- return true;
- }
- for (int num = 1; num <= 9; num++) {
- if (rowsUsed[row][num] || colsUsed[col][num] || cubesUsed[cubeNum(row, col)][num]) continue;
- rowsUsed[row][num] = colsUsed[col][num] = cubesUsed[cubeNum(row, col)][num] = true;
- board[row][col] = (char) (num + '0');
- if (backtracking(row, col)) return true;
- board[row][col] = '.';
- rowsUsed[row][num] = colsUsed[col][num] = cubesUsed[cubeNum(row, col)][num] = false;
- }
- return false;
+private boolean backtracking(int row, int col) {
+ while (row < 9 && board[row][col] != '.') {
+ row = col == 8 ? row + 1 : row;
+ col = col == 8 ? 0 : col + 1;
+ }
+ if (row == 9) {
+ return true;
+ }
+ for (int num = 1; num <= 9; num++) {
+ if (rowsUsed[row][num] || colsUsed[col][num] || cubesUsed[cubeNum(row, col)][num]) continue;
+ rowsUsed[row][num] = colsUsed[col][num] = cubesUsed[cubeNum(row, col)][num] = true;
+ board[row][col] = (char) (num + '0');
+ if (backtracking(row, col)) return true;
+ board[row][col] = '.';
+ rowsUsed[row][num] = colsUsed[col][num] = cubesUsed[cubeNum(row, col)][num] = false;
+ }
+ return false;
}
-private int cubeNum(int i, int j) {
- int r = i / 3;
- int c = j / 3;
- return r * 3 + c;
+private int cubeNum(int i, int j) {
+ int r = i / 3;
+ int c = j / 3;
+ return r * 3 + c;
}
```
-## 分治
+## 分治
-**给表达式加括号**
+**给表达式加括号**
-[Leetcode : 241. Different Ways to Add Parentheses (Medium)](https://leetcode.com/problems/different-ways-to-add-parentheses/description/)
+[Leetcode : 241. Different Ways to Add Parentheses (Medium)](https://leetcode.com/problems/different-ways-to-add-parentheses/description/)
```html
-Input: "2-1-1".
+Input: "2-1-1".
-((2-1)-1) = 0
-(2-(1-1)) = 2
+((2-1)-1) = 0
+(2-(1-1)) = 2
-Output : [0, 2]
+Output : [0, 2]
```
```java
-public List diffWaysToCompute(String input) {
- int n = input.length();
- List ret = new ArrayList<>();
- for (int i = 0; i < n; i++) {
- char c = input.charAt(i);
- if (c == '+' || c == '-' || c == '*') {
- List left = diffWaysToCompute(input.substring(0, i));
- List right = diffWaysToCompute(input.substring(i + 1));
- for (int l : left) {
- for (int r : right) {
- switch (c) {
- case '+': ret.add(l + r); break;
- case '-': ret.add(l - r); break;
- case '*': ret.add(l * r); break;
- }
- }
- }
- }
- }
- if (ret.size() == 0) ret.add(Integer.valueOf(input));
- return ret;
+public List diffWaysToCompute(String input) {
+ int n = input.length();
+ List ret = new ArrayList<>();
+ for (int i = 0; i < n; i++) {
+ char c = input.charAt(i);
+ if (c == '+' || c == '-' || c == '*') {
+ List left = diffWaysToCompute(input.substring(0, i));
+ List right = diffWaysToCompute(input.substring(i + 1));
+ for (int l : left) {
+ for (int r : right) {
+ switch (c) {
+ case '+': ret.add(l + r); break;
+ case '-': ret.add(l - r); break;
+ case '*': ret.add(l * r); break;
+ }
+ }
+ }
+ }
+ }
+ if (ret.size() == 0) ret.add(Integer.valueOf(input));
+ return ret;
}
```
-## 动态规划
+## 动态规划
递归和动态规划都是将原问题拆成多个子问题然后求解，他们之间最本质的区别是，动态规划保存了子问题的解。
-### 分割整数
+### 分割整数
-**分割整数的最大乘积**
+**分割整数的最大乘积**
-[Leetcode : 343. Integer Break (Medim)](https://leetcode.com/problems/integer-break/description/)
+[Leetcode : 343. Integer Break (Medim)](https://leetcode.com/problems/integer-break/description/)
-题目描述：For example, given n = 2, return 1 (2 = 1 + 1); given n = 10, return 36 (10 = 3 + 3 + 4).
+题目描述：For example, given n = 2, return 1 (2 = 1 + 1); given n = 10, return 36 (10 = 3 + 3 + 4).
```java
-public int integerBreak(int n) {
- int[] dp = new int[n + 1];
- dp[1] = 1;
- for(int i = 2; i <= n; i++) {
- for(int j = 1; j <= i - 1; j++) {
- dp[i] = Math.max(dp[i], Math.max(j * dp[i - j], j * (i - j)));
- }
- }
- return dp[n];
+public int integerBreak(int n) {
+ int[] dp = new int[n + 1];
+ dp[1] = 1;
+ for(int i = 2; i <= n; i++) {
+ for(int j = 1; j <= i - 1; j++) {
+ dp[i] = Math.max(dp[i], Math.max(j * dp[i - j], j * (i - j)));
+ }
+ }
+ return dp[n];
}
```
-**按平方数来分割整数**
+**按平方数来分割整数**
-[Leetcode : 279. Perfect Squares(Medium)](https://leetcode.com/problems/perfect-squares/description/)
+[Leetcode : 279. Perfect Squares(Medium)](https://leetcode.com/problems/perfect-squares/description/)
-题目描述：For example, given n = 12, return 3 because 12 = 4 + 4 + 4; given n = 13, return 2 because 13 = 4 + 9.
+题目描述：For example, given n = 12, return 3 because 12 = 4 + 4 + 4; given n = 13, return 2 because 13 = 4 + 9.
```java
-public int numSquares(int n) {
- List squares = new ArrayList<>(); // 存储小于 n 的平方数
- int diff = 3;
- while(square <= n) {
- squares.add(square);
- square += diff;
- diff += 2;
- }
- int[] dp = new int[n + 1];
- for(int i = 1; i <= n; i++) {
- int max = Integer.MAX_VALUE;
- for(int s : squares) {
- if(s > i) break;
- max = Math.min(max, dp[i - s] + 1);
- }
- dp[i] = max;
- }
- return dp[n];
+public int numSquares(int n) {
+ List squares = new ArrayList<>(); // 存储小于 n 的平方数
+ int diff = 3;
+ while(square <= n) {
+ squares.add(square);
+ square += diff;
+ diff += 2;
+ }
+ int[] dp = new int[n + 1];
+ for(int i = 1; i <= n; i++) {
+ int max = Integer.MAX_VALUE;
+ for(int s : squares) {
+ if(s > i) break;
+ max = Math.min(max, dp[i - s] + 1);
+ }
+ dp[i] = max;
+ }
+ return dp[n];
}
```
-**分割整数构成字母字符串**
+**分割整数构成字母字符串**
-[Leetcode : 91. Decode Ways (Medium)](https://leetcode.com/problems/decode-ways/description/)
+[Leetcode : 91. Decode Ways (Medium)](https://leetcode.com/problems/decode-ways/description/)
-题目描述：Given encoded message "12", it could be decoded as "AB" (1 2) or "L" (12).
+题目描述：Given encoded message "12", it could be decoded as "AB" (1 2) or "L" (12).
```java
-public int numDecodings(String s) {
- if(s == null || s.length() == 0) return 0;
- int n = s.length();
- int[] dp = new int[n + 1];
- dp[0] = 1;
- dp[1] = s.charAt(0) == '0' ? 0 : 1;
- for(int i = 2; i <= n; i++) {
- int one = Integer.valueOf(s.substring(i - 1, i));
- if(one != 0) dp[i] += dp[i - 1];
- if(s.charAt(i - 2) == '0') continue;
- int two = Integer.valueOf(s.substring(i - 2, i));
- if(two <= 26) dp[i] += dp[i - 2];
- }
- return dp[n];
+public int numDecodings(String s) {
+ if(s == null || s.length() == 0) return 0;
+ int n = s.length();
+ int[] dp = new int[n + 1];
+ dp[0] = 1;
+ dp[1] = s.charAt(0) == '0' ? 0 : 1;
+ for(int i = 2; i <= n; i++) {
+ int one = Integer.valueOf(s.substring(i - 1, i));
+ if(one != 0) dp[i] += dp[i - 1];
+ if(s.charAt(i - 2) == '0') continue;
+ int two = Integer.valueOf(s.substring(i - 2, i));
+ if(two <= 26) dp[i] += dp[i - 2];
+ }
+ return dp[n];
}
```
-### 矩阵路径
+### 矩阵路径
-**矩阵的总路径数**
+**矩阵的总路径数**
-[Leetcode : 62. Unique Paths (Medium)](https://leetcode.com/problems/unique-paths/description/)
+[Leetcode : 62. Unique Paths (Medium)](https://leetcode.com/problems/unique-paths/description/)
题目描述：统计从矩阵左上角到右下角的路径总数，每次只能向左和向下移动。
```java
-public int uniquePaths(int m, int n) {
- int[] dp = new int[n];
- for (int i = 0; i < m; i++) {
- for (int j = 0; j < n; j++) {
- if(i == 0) dp[j] = 1;
- else if(j != 0) dp[j] = dp[j] + dp[j - 1];
- }
- }
- return dp[n - 1];
+public int uniquePaths(int m, int n) {
+ int[] dp = new int[n];
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ if(i == 0) dp[j] = 1;
+ else if(j != 0) dp[j] = dp[j] + dp[j - 1];
+ }
+ }
+ return dp[n - 1];
}
```
-**矩阵的最小路径和**
+**矩阵的最小路径和**
-[Leetcode : 64. Minimum Path Sum (Medium)](https://leetcode.com/problems/minimum-path-sum/description/)
+[Leetcode : 64. Minimum Path Sum (Medium)](https://leetcode.com/problems/minimum-path-sum/description/)
题目描述：求从矩阵的左上角到右下角的最小路径和，每次只能向左和向下移动。
```java
-public int minPathSum(int[][] grid) {
- if(grid.length == 0 || grid[0].length == 0) return 0;
- int m = grid.length, n = grid[0].length;
- int[] dp = new int[n];
- for(int i = 0; i < m; i++) {
- for(int j = 0; j < n; j++) {
- if(j == 0) dp[0] = dp[0] + grid[i][0];
- else if(i == 0) dp[j] = dp[j - 1] + grid[0][j];
- else dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];
- }
- }
- return dp[n - 1];
+public int minPathSum(int[][] grid) {
+ if(grid.length == 0 || grid[0].length == 0) return 0;
+ int m = grid.length, n = grid[0].length;
+ int[] dp = new int[n];
+ for(int i = 0; i < m; i++) {
+ for(int j = 0; j < n; j++) {
+ if(j == 0) dp[0] = dp[0] + grid[i][0];
+ else if(i == 0) dp[j] = dp[j - 1] + grid[0][j];
+ else dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];
+ }
+ }
+ return dp[n - 1];
}
```
-### 斐波那契数列
+### 斐波那契数列
-**爬楼梯**
+**爬楼梯**
-[Leetcode : 70. Climbing Stairs (Easy)](https://leetcode.com/problems/climbing-stairs/description/)
+[Leetcode : 70. Climbing Stairs (Easy)](https://leetcode.com/problems/climbing-stairs/description/)
-题目描述：有 N 阶楼梯，每次可以上一阶或者两阶，求有多少种上楼梯的方法。
+题目描述：有 N 阶楼梯，每次可以上一阶或者两阶，求有多少种上楼梯的方法。
-定义一个数组 dp 存储上楼梯的方法数（为了方便讨论，数组下标从 1 开始），dp[i] 表示走到第 i 个楼梯的方法数目。第 i 个楼梯可以从第 i-1 和 i-2 个楼梯再走一步到达，走到第 i 个楼梯的方法数为走到第 i-1 和第 i-2 个楼梯的方法数之和。
+定义一个数组 dp 存储上楼梯的方法数（为了方便讨论，数组下标从 1 开始），dp[i] 表示走到第 i 个楼梯的方法数目。第 i 个楼梯可以从第 i-1 和 i-2 个楼梯再走一步到达，走到第 i 个楼梯的方法数为走到第 i-1 和第 i-2 个楼梯的方法数之和。
-$$dp[i] = dp[i-1] + dp[i-2]$$
+
-dp[N] 即为所求。
+dp[N] 即为所求。
-考虑到 dp[i] 只与 dp[i - 1] 和 dp[i - 2] 有关，因此可以只用两个变量来存储 dp[i - 1] 和 dp[i - 2] 即可，使得原来的 O(n) 空间复杂度优化为 O(1) 复杂度。
+考虑到 dp[i] 只与 dp[i - 1] 和 dp[i - 2] 有关，因此可以只用两个变量来存储 dp[i - 1] 和 dp[i - 2] 即可，使得原来的 O(n) 空间复杂度优化为 O(1) 复杂度。
```java
-public int climbStairs(int n) {
- if(n == 1) return 1;
- if(n == 2) return 2;
- // 前一个楼梯、后一个楼梯
- int pre1 = 2, pre2 = 1;
- for(int i = 2; i < n; i++){
- int cur = pre1 + pre2;
- pre2 = pre1;
- pre1 = cur;
- }
- return pre1;
+public int climbStairs(int n) {
+ if(n == 1) return 1;
+ if(n == 2) return 2;
+ // 前一个楼梯、后一个楼梯
+ int pre1 = 2, pre2 = 1;
+ for(int i = 2; i < n; i++){
+ int cur = pre1 + pre2;
+ pre2 = pre1;
+ pre1 = cur;
+ }
+ return pre1;
}
```
-**母牛生产**
+**母牛生产**
[程序员代码面试指南-P181](#)
-题目描述：假设农场中成熟的母牛每年都会生 1 头小母牛，并且永远不会死。第一年有 1 只小母牛，从第二年开始，母牛开始生小母牛。每只小母牛 3 年之后成熟又可以生小母牛。给定整数 N，求 N 年后牛的数量。
+题目描述：假设农场中成熟的母牛每年都会生 1 头小母牛，并且永远不会死。第一年有 1 只小母牛，从第二年开始，母牛开始生小母牛。每只小母牛 3 年之后成熟又可以生小母牛。给定整数 N，求 N 年后牛的数量。
-第 i 年成熟的牛的数量为：
+第 i 年成熟的牛的数量为：
-$$dp[i] = dp[i-1] + dp[i-3]$$
+
-**强盗抢劫**
+**强盗抢劫**
-[Leetcode : 198. House Robber (Easy)](https://leetcode.com/problems/house-robber/description/)
+[Leetcode : 198. House Robber (Easy)](https://leetcode.com/problems/house-robber/description/)
题目描述：抢劫一排住户，但是不能抢邻近的住户，求最大抢劫量。
-定义 dp 数组用来存储最大的抢劫量，其中 dp[i] 表示抢到第 i 个住户时的最大抢劫量。由于不能抢劫邻近住户，因此如果抢劫了第 i 个住户那么只能抢劫 i - 2 和 i - 3 的住户，所以
+定义 dp 数组用来存储最大的抢劫量，其中 dp[i] 表示抢到第 i 个住户时的最大抢劫量。由于不能抢劫邻近住户，因此如果抢劫了第 i 个住户那么只能抢劫 i - 2 和 i - 3 的住户，所以
-$$dp[i] = max(dp[i - 2], dp[i - 3]) + nums[i]$$
+
-O(n) 空间复杂度实现方法：
+O(n) 空间复杂度实现方法：
```java
-public int rob(int[] nums) {
- int n = nums.length;
- if(n == 0) return 0;
- if(n == 1) return nums[0];
- if(n == 2) return Math.max(nums[0], nums[1]);
- int[] dp = new int[n];
- dp[0] = nums[0];
- dp[1] = nums[1];
- dp[2] = nums[0] + nums[2];
- for(int i = 3; i < n; i++){
- dp[i] = Math.max(dp[i -2], dp[i - 3]) + nums[i];
- }
- return Math.max(dp[n - 1], dp[n - 2]);
+public int rob(int[] nums) {
+ int n = nums.length;
+ if(n == 0) return 0;
+ if(n == 1) return nums[0];
+ if(n == 2) return Math.max(nums[0], nums[1]);
+ int[] dp = new int[n];
+ dp[0] = nums[0];
+ dp[1] = nums[1];
+ dp[2] = nums[0] + nums[2];
+ for(int i = 3; i < n; i++){
+ dp[i] = Math.max(dp[i -2], dp[i - 3]) + nums[i];
+ }
+ return Math.max(dp[n - 1], dp[n - 2]);
}
```
-O(1) 空间复杂度实现方法：
+O(1) 空间复杂度实现方法：
```java
-public int rob(int[] nums) {
- int n = nums.length;
- if(n == 0) return 0;
- if(n == 1) return nums[0];
- if(n == 2) return Math.max(nums[0], nums[1]);
- int pre3 = nums[0], pre2 = nums[1], pre1 = nums[2] + nums[0];
- for(int i = 3; i < n; i++){
- int cur = Math.max(pre2, pre3) + nums[i];
- pre3 = pre2;
- pre2 = pre1;
- pre1 = cur;
- }
- return Math.max(pre1, pre2);
+public int rob(int[] nums) {
+ int n = nums.length;
+ if(n == 0) return 0;
+ if(n == 1) return nums[0];
+ if(n == 2) return Math.max(nums[0], nums[1]);
+ int pre3 = nums[0], pre2 = nums[1], pre1 = nums[2] + nums[0];
+ for(int i = 3; i < n; i++){
+ int cur = Math.max(pre2, pre3) + nums[i];
+ pre3 = pre2;
+ pre2 = pre1;
+ pre1 = cur;
+ }
+ return Math.max(pre1, pre2);
}
```
-**强盗在环形街区抢劫**
+**强盗在环形街区抢劫**
-[Leetcode : 213. House Robber II (Medium)](https://leetcode.com/problems/house-robber-ii/description/)
+[Leetcode : 213. House Robber II (Medium)](https://leetcode.com/problems/house-robber-ii/description/)
```java
-public int rob(int[] nums) {
- if(nums == null || nums.length == 0) return 0;
- int n = nums.length;
- if(n == 1) return nums[0];
- return Math.max(rob(nums, 0, n - 2), rob(nums, 1, n - 1));
+public int rob(int[] nums) {
+ if(nums == null || nums.length == 0) return 0;
+ int n = nums.length;
+ if(n == 1) return nums[0];
+ return Math.max(rob(nums, 0, n - 2), rob(nums, 1, n - 1));
}
-private int rob(int[] nums, int s, int e) {
- int n = nums.length;
- if(e - s == 0) return nums[s];
- if(e - s == 1) return Math.max(nums[s], nums[s + 1]);
- int[] dp = new int[n];
- dp[s] = nums[s];
- dp[s + 1] = nums[s + 1];
- dp[s + 2] = nums[s] + nums[s + 2];
- for (int i = s + 3; i <= e; i++) {
- dp[i] = Math.max(dp[i - 2], dp[i - 3]) + nums[i];
- }
- return Math.max(dp[e], dp[e - 1]);
+private int rob(int[] nums, int s, int e) {
+ int n = nums.length;
+ if(e - s == 0) return nums[s];
+ if(e - s == 1) return Math.max(nums[s], nums[s + 1]);
+ int[] dp = new int[n];
+ dp[s] = nums[s];
+ dp[s + 1] = nums[s + 1];
+ dp[s + 2] = nums[s] + nums[s + 2];
+ for (int i = s + 3; i <= e; i++) {
+ dp[i] = Math.max(dp[i - 2], dp[i - 3]) + nums[i];
+ }
+ return Math.max(dp[e], dp[e - 1]);
}
```
-**信件错排**
+**信件错排**
-题目描述：有 N 个 信 和 信封，它们被打乱，求错误装信的方式数量。
+题目描述：有 N 个 信 和 信封，它们被打乱，求错误装信的方式数量。
-定义一个数组 dp 存储错误方式数量，dp[i] 表示前 i 个信和信封的错误方式数量。假设第 i 个信装到第 j 个信封里面，而第 j 个信装到第 k 个信封里面。根据 i 和 k 是否相等，有两种情况：
+定义一个数组 dp 存储错误方式数量，dp[i] 表示前 i 个信和信封的错误方式数量。假设第 i 个信装到第 j 个信封里面，而第 j 个信装到第 k 个信封里面。根据 i 和 k 是否相等，有两种情况：
-① i==k，交换 i 和 k 的信后，它们的信和信封在正确的位置，但是其余 i-2 封信有 dp[i-2] 种错误装信的方式。由于 j 有 i-1 种取值，因此共有 (i-1)\*dp[i-2] 种错误装信方式。
+① i==k，交换 i 和 k 的信后，它们的信和信封在正确的位置，但是其余 i-2 封信有 dp[i-2] 种错误装信的方式。由于 j 有 i-1 种取值，因此共有 (i-1)\*dp[i-2] 种错误装信方式。
-② i != k，交换 i 和 j 的信后，第 i 个信和信封在正确的位置，其余 i-1 封信有 dp[i-1] 种错误装信方式。由于 j 有 i-1 种取值，因此共有 (n-1)\*dp[i-1] 种错误装信方式。
+② i != k，交换 i 和 j 的信后，第 i 个信和信封在正确的位置，其余 i-1 封信有 dp[i-1] 种错误装信方式。由于 j 有 i-1 种取值，因此共有 (n-1)\*dp[i-1] 种错误装信方式。
综上所述，错误装信数量方式数量为：
-$$ dp[i] = (i-1) * dp[i-2] + (i-1) * dp[i-1]$$
+
-dp[N] 即为所求。
+dp[N] 即为所求。
-和上楼梯问题一样，dp[i] 只与 dp[i-1] 和 dp[i-2] 有关，因此也可以只用两个变量来存储 dp[i-1] 和 dp[i-2]。
+和上楼梯问题一样，dp[i] 只与 dp[i-1] 和 dp[i-2] 有关，因此也可以只用两个变量来存储 dp[i-1] 和 dp[i-2]。
-### 最长递增子序列
+### 最长递增子序列
-已知一个序列 {S1, S2,...,Sn} ，取出若干数组成新的序列 {Si1, Si2,..., Sim}，其中 i1、i2 ... im 保持递增，即新序列中各个数仍然保持原数列中的先后顺序，称新序列为原序列的一个**子序列**。
+已知一个序列 {S1, S2,...,Sn} ，取出若干数组成新的序列 {Si1, Si2,..., Sim}，其中 i1、i2 ... im 保持递增，即新序列中各个数仍然保持原数列中的先后顺序，称新序列为原序列的一个 **子序列** 。
-如果在子序列中，当下标 ix > iy 时，Six > Siy，称子序列为原序列的一个**递增子序列**。
+如果在子序列中，当下标 ix > iy 时，Six > Siy，称子序列为原序列的一个 **递增子序列** 。
-定义一个数组 dp 存储最长递增子序列的长度，dp[n] 表示以 Sn 结尾的序列的最长递增子序列长度。对于一个递增子序列 {Si1, Si2,...,Sim}，如果 im < n 并且 Sim < Sn ，此时 {Si1, Si2,..., Sim, Sn} 为一个递增子序列，递增子序列的长度增加 1。满足上述条件的递增子序列中，长度最长的那个递增子序列就是要找的，在长度最长的递增子序列上加上 Sn 就构成了以 Sn 为结尾的最长递增子序列。因此 dp[n] = max{ dp[i]+1 | Si < Sn && i < n} 。
+定义一个数组 dp 存储最长递增子序列的长度，dp[n] 表示以 Sn 结尾的序列的最长递增子序列长度。对于一个递增子序列 {Si1, Si2,...,Sim}，如果 im < n 并且 Sim < Sn ，此时 {Si1, Si2,..., Sim, Sn} 为一个递增子序列，递增子序列的长度增加 1。满足上述条件的递增子序列中，长度最长的那个递增子序列就是要找的，在长度最长的递增子序列上加上 Sn 就构成了以 Sn 为结尾的最长递增子序列。因此 dp[n] = max{ dp[i]+1 | Si < Sn && i < n} 。
-因为在求 dp[n] 时可能无法找到一个满足条件的递增子序列，此时 {Sn} 就构成了递增子序列，因此需要对前面的求解方程做修改，令 dp[n] 最小为 1，即：
+因为在求 dp[n] 时可能无法找到一个满足条件的递增子序列，此时 {Sn} 就构成了递增子序列，因此需要对前面的求解方程做修改，令 dp[n] 最小为 1，即：
-$$ dp[n] = max\{ 1, dp[i]+1 | S_i < S_n \&\& i < n \} $$
+
-对于一个长度为 N 的序列，最长子序列并不一定会以 SN 为结尾，因此 dp[N] 不是序列的最长递增子序列的长度，需要遍历 dp 数组找出最大值才是所要的结果，即 max{ dp[i] | 1 <= i <= N} 即为所求。
+对于一个长度为 N 的序列，最长子序列并不一定会以 SN 为结尾，因此 dp[N] 不是序列的最长递增子序列的长度，需要遍历 dp 数组找出最大值才是所要的结果，即 max{ dp[i] | 1 <= i <= N} 即为所求。
-**最长递增子序列**
+**最长递增子序列**
-[Leetcode : 300. Longest Increasing Subsequence (Medium)](https://leetcode.com/problems/longest-increasing-subsequence/description/)
+[Leetcode : 300. Longest Increasing Subsequence (Medium)](https://leetcode.com/problems/longest-increasing-subsequence/description/)
```java
-public int lengthOfLIS(int[] nums) {
- int n = nums.length;
- int[] dp = new int[n];
- for(int i = 0; i < n; i++){
- int max = 1;
- for(int j = 0; j < i; j++){
- if(nums[i] > nums[j]) max = Math.max(max, dp[j] + 1);
- }
- dp[i] = max;
- }
- int ret = 0;
- for(int i = 0; i < n; i++){
- ret = Math.max(ret, dp[i]);
- }
- return ret;
+public int lengthOfLIS(int[] nums) {
+ int n = nums.length;
+ int[] dp = new int[n];
+ for(int i = 0; i < n; i++){
+ int max = 1;
+ for(int j = 0; j < i; j++){
+ if(nums[i] > nums[j]) max = Math.max(max, dp[j] + 1);
+ }
+ dp[i] = max;
+ }
+ int ret = 0;
+ for(int i = 0; i < n; i++){
+ ret = Math.max(ret, dp[i]);
+ }
+ return ret;
}
```
-以上解法的时间复杂度为 O(n2) ，可以使用二分查找使得时间复杂度降低为 O(nlogn)。定义一个 tails 数组，其中 tails[i] 存储长度为 i + 1 的最长递增子序列的最后一个元素，例如对于数组 [4,5,6,3]，有
+以上解法的时间复杂度为 O(n2) ，可以使用二分查找使得时间复杂度降低为 O(nlogn)。定义一个 tails 数组，其中 tails[i] 存储长度为 i + 1 的最长递增子序列的最后一个元素，例如对于数组 [4,5,6,3]，有
```html
-len = 1 : [4], [5], [6], [3] => tails[0] = 3
-len = 2 : [4, 5], [5, 6] => tails[1] = 5
-len = 3 : [4, 5, 6] => tails[2] = 6
+len = 1 : [4], [5], [6], [3] => tails[0] = 3
+len = 2 : [4, 5], [5, 6] => tails[1] = 5
+len = 3 : [4, 5, 6] => tails[2] = 6
```
-对于一个元素 x，如果它大于 tails 数组所有的值，那么把它添加到 tails 后面；如果 tails[i-1] < x <= tails[i]，那么更新 tails[i] = x 。
+对于一个元素 x，如果它大于 tails 数组所有的值，那么把它添加到 tails 后面；如果 tails[i-1] < x <= tails[i]，那么更新 tails[i] = x 。
-可以看出 tails 数组保持有序，因此在查找 Si 位于 tails 数组的位置时就可以使用二分查找。
+可以看出 tails 数组保持有序，因此在查找 Si 位于 tails 数组的位置时就可以使用二分查找。
```java
-public int lengthOfLIS(int[] nums) {
- int n = nums.length;
- int[] tails = new int[n];
- int size = 0;
- for(int i = 0; i < n; i++){
- int idx = binarySearch(tails, 0, size, nums[i]);
- tails[idx] = nums[i];
- if(idx == size) size++;
- }
- return size;
+public int lengthOfLIS(int[] nums) {
+ int n = nums.length;
+ int[] tails = new int[n];
+ int size = 0;
+ for(int i = 0; i < n; i++){
+ int idx = binarySearch(tails, 0, size, nums[i]);
+ tails[idx] = nums[i];
+ if(idx == size) size++;
+ }
+ return size;
}
-private int binarySearch(int[] nums, int sIdx, int eIdx, int key){
- while(sIdx < eIdx){
- int mIdx = sIdx + (eIdx - sIdx) / 2;
- if(nums[mIdx] == key) return mIdx;
- else if(nums[mIdx] > key) eIdx = mIdx;
- else sIdx = mIdx + 1;
- }
- return sIdx;
+private int binarySearch(int[] nums, int sIdx, int eIdx, int key){
+ while(sIdx < eIdx){
+ int mIdx = sIdx + (eIdx - sIdx) / 2;
+ if(nums[mIdx] == key) return mIdx;
+ else if(nums[mIdx] > key) eIdx = mIdx;
+ else sIdx = mIdx + 1;
+ }
+ return sIdx;
}
```
-**最长摆动子序列**
+**最长摆动子序列**
-[Leetcode : 376. Wiggle Subsequence (Medium)](https://leetcode.com/problems/wiggle-subsequence/description/)
+[Leetcode : 376. Wiggle Subsequence (Medium)](https://leetcode.com/problems/wiggle-subsequence/description/)
-要求：使用 O(n) 时间复杂度求解。
+要求：使用 O(n) 时间复杂度求解。
-使用两个状态 up 和 down。
+使用两个状态 up 和 down。
```java
-public int wiggleMaxLength(int[] nums) {
- int len = nums.length;
- if (len == 0) return 0;
- int up = 1, down = 1;
- for (int i = 1; i < len; i++) {
- if (nums[i] > nums[i - 1]) up = down + 1;
- else if (nums[i] < nums[i - 1]) down = up + 1;
- }
- return Math.max(up, down);
+public int wiggleMaxLength(int[] nums) {
+ int len = nums.length;
+ if (len == 0) return 0;
+ int up = 1, down = 1;
+ for (int i = 1; i < len; i++) {
+ if (nums[i] > nums[i - 1]) up = down + 1;
+ else if (nums[i] < nums[i - 1]) down = up + 1;
+ }
+ return Math.max(up, down);
}
```
-### 最长公共子系列
+### 最长公共子系列
-对于两个子序列 S1 和 S2，找出它们最长的公共子序列。
+对于两个子序列 S1 和 S2，找出它们最长的公共子序列。
-定义一个二维数组 dp 用来存储最长公共子序列的长度，其中 dp[i][j] 表示 S1 的前 i 个字符与 S2 的前 j 个字符最长公共子序列的长度。考虑 S1i 与 S2j 值是否相等，分为两种情况：
+定义一个二维数组 dp 用来存储最长公共子序列的长度，其中 dp[i][j] 表示 S1 的前 i 个字符与 S2 的前 j 个字符最长公共子序列的长度。考虑 S1i 与 S2j 值是否相等，分为两种情况：
-① 当 S1i==S2j 时，那么就能在 S1 的前 i-1 个字符与 S2 的前 j-1 个字符最长公共子序列的基础上再加上 S1i 这个值，最长公共子序列长度加 1 ，即 dp[i][j] = dp[i-1][j-1] + 1。
+① 当 S1i==S2j 时，那么就能在 S1 的前 i-1 个字符与 S2 的前 j-1 个字符最长公共子序列的基础上再加上 S1i 这个值，最长公共子序列长度加 1 ，即 dp[i][j] = dp[i-1][j-1] + 1。
-② 当 S1i != S2j 时，此时最长公共子序列为 S1 的前 i-1 个字符和 S2 的前 j 个字符最长公共子序列，与 S1 的前 i 个字符和 S2 的前 j-1 个字符最长公共子序列，它们的最大者，即 dp[i][j] = max{ dp[i-1][j], dp[i][j-1] }。
+② 当 S1i != S2j 时，此时最长公共子序列为 S1 的前 i-1 个字符和 S2 的前 j 个字符最长公共子序列，与 S1 的前 i 个字符和 S2 的前 j-1 个字符最长公共子序列，它们的最大者，即 dp[i][j] = max{ dp[i-1][j], dp[i][j-1] }。
综上，最长公共子系列的状态转移方程为：
-$$ dp[i][j]=\left\{ \begin{array}{rcl} dp[i-1][j-1] && { S1_i==S2_j }\\ max(dp[i-1][j], dp[i][j-1]) &&{ S1_i <> S2_j } \end{array} \right. $$
+
-对于长度为 N 的序列 S1 和 长度为 M 的序列 S2，dp[N][M] 就是序列 S1 和序列 S2 的最长公共子序列长度。
+对于长度为 N 的序列 S1 和 长度为 M 的序列 S2，dp[N][M] 就是序列 S1 和序列 S2 的最长公共子序列长度。
与最长递增子序列相比，最长公共子序列有以下不同点：
-① 针对的是两个序列，求它们的最长公共子序列。
-② 在最长递增子序列中，dp[i] 表示以 Si 为结尾的最长递增子序列长度，子序列必须包含 Si ；在最长公共子序列中，dp[i][j] 表示 S1 中前 i 个字符与 S2 中前 j 个字符的最长公共子序列长度，不一定包含 S1i 和 S2j 。
-③ 由于 2 ，在求最终解时，最长公共子序列中 dp[N][M] 就是最终解，而最长递增子序列中 dp[N] 不是最终解，因为以 SN 为结尾的最长递增子序列不一定是整个序列最长递增子序列，需要遍历一遍 dp 数组找到最大者。
+① 针对的是两个序列，求它们的最长公共子序列。
+② 在最长递增子序列中，dp[i] 表示以 Si 为结尾的最长递增子序列长度，子序列必须包含 Si ；在最长公共子序列中，dp[i][j] 表示 S1 中前 i 个字符与 S2 中前 j 个字符的最长公共子序列长度，不一定包含 S1i 和 S2j 。
+③ 由于 2 ，在求最终解时，最长公共子序列中 dp[N][M] 就是最终解，而最长递增子序列中 dp[N] 不是最终解，因为以 SN 为结尾的最长递增子序列不一定是整个序列最长递增子序列，需要遍历一遍 dp 数组找到最大者。
```java
-public int lengthOfLCS(int[] nums1, int[] nums2) {
- int n1 = nums1.length, n2 = nums2.length;
- int[][] dp = new int[n1 + 1][n2 + 1];
- for (int i = 1; i <= n1; i++) {
- for (int j = 1; j <= n2; j++) {
- if (nums1[i - 1] == nums2[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
- else dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
- }
- }
- return dp[n1][n2];
+public int lengthOfLCS(int[] nums1, int[] nums2) {
+ int n1 = nums1.length, n2 = nums2.length;
+ int[][] dp = new int[n1 + 1][n2 + 1];
+ for (int i = 1; i <= n1; i++) {
+ for (int j = 1; j <= n2; j++) {
+ if (nums1[i - 1] == nums2[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
+ else dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+ }
+ }
+ return dp[n1][n2];
}
```
-### 0-1 背包
+### 0-1 背包
-有一个容量为 N 的背包，要用这个背包装下物品的价值最大，这些物品有两个属性：体积 w 和价值 v。
+有一个容量为 N 的背包，要用这个背包装下物品的价值最大，这些物品有两个属性：体积 w 和价值 v。
-定义一个二维数组 dp 存储最大价值，其中 dp[i][j] 表示体积不超过 j 的情况下，前 i 件物品能达到的最大价值。设第 i 件物品体积为 w，价值为 v，根据第 i 件物品是否添加到背包中，可以分两种情况讨论：
+定义一个二维数组 dp 存储最大价值，其中 dp[i][j] 表示体积不超过 j 的情况下，前 i 件物品能达到的最大价值。设第 i 件物品体积为 w，价值为 v，根据第 i 件物品是否添加到背包中，可以分两种情况讨论：
-① 第 i 件物品没添加到背包，总体积不超过 j 的前 i 件物品的最大价值就是总体积不超过 j 的前 i-1 件物品的最大价值，dp[i][j] = dp[i-1][j]。
-② 第 i 件物品添加到背包中，dp[i][j] = dp[i-1][j-w] + v。
+① 第 i 件物品没添加到背包，总体积不超过 j 的前 i 件物品的最大价值就是总体积不超过 j 的前 i-1 件物品的最大价值，dp[i][j] = dp[i-1][j]。
+② 第 i 件物品添加到背包中，dp[i][j] = dp[i-1][j-w] + v。
-第 i 件物品可添加也可以不添加，取决于哪种情况下最大价值更大。
+第 i 件物品可添加也可以不添加，取决于哪种情况下最大价值更大。
-综上，0-1 背包的状态转移方程为：
+综上，0-1 背包的状态转移方程为：
-$$ dp[i][j] = max ( dp[i-1][j], dp[i-1][j-w] + v ) $$
+)
```java
-public int knapsack(int W, int N, int[] weights, int[] values) {
- int[][] dp = new int[N][W];
- for (int i = W - 1; i >= 0; i--) {
- dp[0][i] = i > weights[0] ? values[0] : 0;
- }
- for (int i = 1; i < N; i++) {
- for (int j = W - 1; j >= weights[i]; j--) {
- dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weights[i]] + values[i]);
- }
- for (int j = weights[i - 1] - 1; j >= 0; j--) {
- dp[i][j] = dp[i - 1][j];
- }
- }
- return dp[N - 1][W - 1];
+public int knapsack(int W, int N, int[] weights, int[] values) {
+ int[][] dp = new int[N][W];
+ for (int i = W - 1; i >= 0; i--) {
+ dp[0][i] = i > weights[0] ? values[0] : 0;
+ }
+ for (int i = 1; i < N; i++) {
+ for (int j = W - 1; j >= weights[i]; j--) {
+ dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weights[i]] + values[i]);
+ }
+ for (int j = weights[i - 1] - 1; j >= 0; j--) {
+ dp[i][j] = dp[i - 1][j];
+ }
+ }
+ return dp[N - 1][W - 1];
}
```
-**空间优化**
+**空间优化**
-在程序实现时可以对 0-1 背包做优化。观察状态转移方程可以知道，前 i 件物品的状态仅由前 i-1 件物品的状态有关，因此可以将 dp 定义为一维数组，其中 dp[j] 既可以表示 dp[i-1][j] 也可以表示 dp[i][j]。此时，
+在程序实现时可以对 0-1 背包做优化。观察状态转移方程可以知道，前 i 件物品的状态仅由前 i-1 件物品的状态有关，因此可以将 dp 定义为一维数组，其中 dp[j] 既可以表示 dp[i-1][j] 也可以表示 dp[i][j]。此时，
-$$ dp[j] = max ( dp[j], dp[j-w] + v ) $$
+)
-因为 dp[j-w] 表示 dp[i-1][j-w]，因此不能先求 dp[i][j-w] 防止将 dp[i-1][j-w] 覆盖。也就是说要先计算 dp[i][j] 再计算 dp[i][j-w]，在程序实现时需要按倒序来循环求解。
+因为 dp[j-w] 表示 dp[i-1][j-w]，因此不能先求 dp[i][j-w] 防止将 dp[i-1][j-w] 覆盖。也就是说要先计算 dp[i][j] 再计算 dp[i][j-w]，在程序实现时需要按倒序来循环求解。
-**无法使用贪心算法的解释**
+**无法使用贪心算法的解释**
-0-1 背包问题无法使用贪心算法来求解，也就是说不能按照先添加性价比最高的物品来达到最优，这是因为这种方式可能造成背包空间的浪费，从而无法达到最优。考虑下面的物品和一个容量为 5 的背包，如果先添加物品 0 再添加物品 1，那么只能存放的价值为 16，浪费了大小为 2 的空间。最优的方式是存放物品 1 和物品 2，价值为 22.
+0-1 背包问题无法使用贪心算法来求解，也就是说不能按照先添加性价比最高的物品来达到最优，这是因为这种方式可能造成背包空间的浪费，从而无法达到最优。考虑下面的物品和一个容量为 5 的背包，如果先添加物品 0 再添加物品 1，那么只能存放的价值为 16，浪费了大小为 2 的空间。最优的方式是存放物品 1 和物品 2，价值为 22.
-| id | w | v | v/w |
-| --- | --- | --- | --- |
-| 0 | 1 | 6 | 6 |
-| 1 | 2 | 10 | 5 |
-| 2 | 3 | 12 | 4 |
+| id | w | v | v/w |
+| --- | --- | --- | --- |
+| 0 | 1 | 6 | 6 |
+| 1 | 2 | 10 | 5 |
+| 2 | 3 | 12 | 4 |
-**变种**
+**变种**
-完全背包：物品可以无限个，可以转换为 0-1 背包，令每种物品的体积和价值变为 1/2/4... 倍数，把它们都当成一个新物品，然后一种物品只能添加一次。
+完全背包：物品可以无限个，可以转换为 0-1 背包，令每种物品的体积和价值变为 1/2/4... 倍数，把它们都当成一个新物品，然后一种物品只能添加一次。
-多重背包：物品数量有限制，同样可以转换为 0-1 背包。
+多重背包：物品数量有限制，同样可以转换为 0-1 背包。
多维费用背包：物品不仅有重量，还有体积，同时考虑这两种限制。
其它：物品之间相互约束或者依赖。
-**划分数组为和相等的两部分**
+**划分数组为和相等的两部分**
-[Leetcode : 416. Partition Equal Subset Sum (Medium)](https://leetcode.com/problems/partition-equal-subset-sum/description/)
+[Leetcode : 416. Partition Equal Subset Sum (Medium)](https://leetcode.com/problems/partition-equal-subset-sum/description/)
-可以看成一个背包大小为 sum/2 的 0-1 背包问题，但是也有不同的地方，这里没有价值属性，并且背包必须被填满。
+可以看成一个背包大小为 sum/2 的 0-1 背包问题，但是也有不同的地方，这里没有价值属性，并且背包必须被填满。
以下实现使用了空间优化。
```java
-public boolean canPartition(int[] nums) {
- int sum = 0;
- for (int num : nums) {
- sum += num;
- }
- if (sum % 2 != 0) {
- return false;
- }
- int W = sum / 2;
- boolean[] dp = new boolean[W + 1];
- int n = nums.length;
- for(int i = 0; i <= W; i++) {
- if(nums[0] == i) dp[i] = true;
- }
- for(int i = 1; i < n; i++) {
- for(int j = W; j >= nums[i]; j--) {
- dp[j] = dp[j] || dp[j - nums[i]];
- }
- }
+public boolean canPartition(int[] nums) {
+ int sum = 0;
+ for (int num : nums) {
+ sum += num;
+ }
+ if (sum % 2 != 0) {
+ return false;
+ }
+ int W = sum / 2;
+ boolean[] dp = new boolean[W + 1];
+ int n = nums.length;
+ for(int i = 0; i <= W; i++) {
+ if(nums[0] == i) dp[i] = true;
+ }
+ for(int i = 1; i < n; i++) {
+ for(int j = W; j >= nums[i]; j--) {
+ dp[j] = dp[j] || dp[j - nums[i]];
+ }
+ }
- return dp[W];
+ return dp[W];
}
```
-**字符串按单词列表分割**
+**字符串按单词列表分割**
-[Leetcode : 139. Word Break (Medium)](https://leetcode.com/problems/word-break/description/)
+[Leetcode : 139. Word Break (Medium)](https://leetcode.com/problems/word-break/description/)
```html
-s = "leetcode",
-dict = ["leet", "code"].
-Return true because "leetcode" can be segmented as "leet code".
+s = "leetcode",
+dict = ["leet", "code"].
+Return true because "leetcode" can be segmented as "leet code".
```
```java
-public boolean wordBreak(String s, List wordDict) {
- int n = s.length();
- boolean[] dp = new boolean[n + 1];
- dp[0] = true;
- for (int i = 1; i <= n; i++) {
- for (String word : wordDict) {
- if (word.length() <= i
- && word.equals(s.substring(i - word.length(), i))) {
- dp[i] = dp[i] || dp[i - word.length()];
- }
- }
- }
- return dp[n];
+public boolean wordBreak(String s, List wordDict) {
+ int n = s.length();
+ boolean[] dp = new boolean[n + 1];
+ dp[0] = true;
+ for (int i = 1; i <= n; i++) {
+ for (String word : wordDict) {
+ if (word.length() <= i
+ && word.equals(s.substring(i - word.length(), i))) {
+ dp[i] = dp[i] || dp[i - word.length()];
+ }
+ }
+ }
+ return dp[n];
}
```
-**改变一组数的正负号使得它们的和为一给定数**
+**改变一组数的正负号使得它们的和为一给定数**
-[Leetcode : 494. Target Sum (Medium)](https://leetcode.com/problems/target-sum/description/)
+[Leetcode : 494. Target Sum (Medium)](https://leetcode.com/problems/target-sum/description/)
```html
-Input: nums is [1, 1, 1, 1, 1], S is 3.
-Output: 5
+Input: nums is [1, 1, 1, 1, 1], S is 3.
+Output: 5
Explanation:
--1+1+1+1+1 = 3
-+1-1+1+1+1 = 3
-+1+1-1+1+1 = 3
-+1+1+1-1+1 = 3
-+1+1+1+1-1 = 3
+-1+1+1+1+1 = 3
++1-1+1+1+1 = 3
++1+1-1+1+1 = 3
++1+1+1-1+1 = 3
++1+1+1+1-1 = 3
-There are 5 ways to assign symbols to make the sum of nums be target 3.
+There are 5 ways to assign symbols to make the sum of nums be target 3.
```
-该问题可以转换为 subset sum 问题，从而使用 0-1 背包的方法来求解。可以将这组数看成两部分，P 和 N，其中 P 使用正号，N 使用负号，有以下推导：
+该问题可以转换为 subset sum 问题，从而使用 0-1 背包的方法来求解。可以将这组数看成两部分，P 和 N，其中 P 使用正号，N 使用负号，有以下推导：
```html
- sum(P) - sum(N) = target
-sum(P) + sum(N) + sum(P) - sum(N) = target + sum(P) + sum(N)
- 2 * sum(P) = target + sum(nums)
+ sum(P) - sum(N) = target
+sum(P) + sum(N) + sum(P) - sum(N) = target + sum(P) + sum(N)
+ 2 * sum(P) = target + sum(nums)
```
-因此只要找到一个子集，令它们都取正号，并且和等于 (target + sum(nums))/2，就证明存在解。
+因此只要找到一个子集，令它们都取正号，并且和等于 (target + sum(nums))/2，就证明存在解。
```java
-public int findTargetSumWays(int[] nums, int S) {
- int sum = 0;
- for (int num : nums) {
- sum += num;
- }
- if (sum < S || (sum + S) % 2 == 1) {
- return 0;
- }
- return subsetSum(nums, (sum + S) >>> 1);
+public int findTargetSumWays(int[] nums, int S) {
+ int sum = 0;
+ for (int num : nums) {
+ sum += num;
+ }
+ if (sum < S || (sum + S) % 2 == 1) {
+ return 0;
+ }
+ return subsetSum(nums, (sum + S) >>> 1);
}
-private int subsetSum(int[] nums, int targetSum) {
- Arrays.sort(nums);
- int[] dp = new int[targetSum + 1];
- dp[0] = 1;
- for (int i = 0; i < nums.length; i++) {
- int num = nums[i];
- for (int j = targetSum; j >= num; j--) {
- dp[j] = dp[j] + dp[j - num];
- }
- }
- return dp[targetSum];
+private int subsetSum(int[] nums, int targetSum) {
+ Arrays.sort(nums);
+ int[] dp = new int[targetSum + 1];
+ dp[0] = 1;
+ for (int i = 0; i < nums.length; i++) {
+ int num = nums[i];
+ for (int j = targetSum; j >= num; j--) {
+ dp[j] = dp[j] + dp[j - num];
+ }
+ }
+ return dp[targetSum];
}
```
-**01 字符构成最多的字符串**
+**01 字符构成最多的字符串**
-[Leetcode : 474. Ones and Zeroes (Medium)](https://leetcode.com/problems/ones-and-zeroes/description/)
+[Leetcode : 474. Ones and Zeroes (Medium)](https://leetcode.com/problems/ones-and-zeroes/description/)
```html
-Input: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
-Output: 4
+Input: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
+Output: 4
-Explanation: This are totally 4 strings can be formed by the using of 5 0s and 3 1s, which are “10,”0001”,”1”,”0”
+Explanation: This are totally 4 strings can be formed by the using of 5 0s and 3 1s, which are “10,”0001”,”1”,”0”
```
-这是一个多维费用的 0-1 背包问题，有两个背包大小，0 的数量和 1 的数量。
+这是一个多维费用的 0-1 背包问题，有两个背包大小，0 的数量和 1 的数量。
```java
-public int findMaxForm(String[] strs, int m, int n) {
- if (strs == null || strs.length == 0) return 0;
- int l = strs.length;
- int[][] dp = new int[m + 1][n + 1];
- for (int i = 0; i < l; i++) {
- String s = strs[i];
- int ones = 0, zeros = 0;
- for (char c : s.toCharArray()) {
- if (c == '0') zeros++;
- else if (c == '1') ones++;
- }
- for (int j = m; j >= zeros; j--) {
- for (int k = n; k >= ones; k--) {
- if (zeros <= j && ones <= k) {
- dp[j][k] = Math.max(dp[j][k], dp[j - zeros][k - ones] + 1);
- }
- }
- }
- }
- return dp[m][n];
+public int findMaxForm(String[] strs, int m, int n) {
+ if (strs == null || strs.length == 0) return 0;
+ int l = strs.length;
+ int[][] dp = new int[m + 1][n + 1];
+ for (int i = 0; i < l; i++) {
+ String s = strs[i];
+ int ones = 0, zeros = 0;
+ for (char c : s.toCharArray()) {
+ if (c == '0') zeros++;
+ else if (c == '1') ones++;
+ }
+ for (int j = m; j >= zeros; j--) {
+ for (int k = n; k >= ones; k--) {
+ if (zeros <= j && ones <= k) {
+ dp[j][k] = Math.max(dp[j][k], dp[j - zeros][k - ones] + 1);
+ }
+ }
+ }
+ }
+ return dp[m][n];
}
```
-**找零钱**
+**找零钱**
-[Leetcode : 322. Coin Change (Medium)](https://leetcode.com/problems/coin-change/description/)
+[Leetcode : 322. Coin Change (Medium)](https://leetcode.com/problems/coin-change/description/)
题目描述：给一些面额的硬币，要求用这些硬币来组成给定面额的钱数，并且使得硬币数量最少。硬币可以重复使用。
-这是一个完全背包问题，完全背包问题和 0-1 背包问题在实现上唯一的不同是，第二层循环是从 0 开始的，而不是从尾部开始。
+这是一个完全背包问题，完全背包问题和 0-1 背包问题在实现上唯一的不同是，第二层循环是从 0 开始的，而不是从尾部开始。
```java
-public int coinChange(int[] coins, int amount) {
- int[] dp = new int[amount + 1];
- Arrays.fill(dp, amount + 1);
- dp[0] = 0;
- for (int i = 1; i <= amount; i++) {
- for (int j = 0; j < coins.length; j++) {
- if (coins[j] <= i) {
- dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
- }
- }
- }
- return dp[amount] > amount ? -1 : dp[amount];
+public int coinChange(int[] coins, int amount) {
+ int[] dp = new int[amount + 1];
+ Arrays.fill(dp, amount + 1);
+ dp[0] = 0;
+ for (int i = 1; i <= amount; i++) {
+ for (int j = 0; j < coins.length; j++) {
+ if (coins[j] <= i) {
+ dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
+ }
+ }
+ }
+ return dp[amount] > amount ? -1 : dp[amount];
}
```
-**组合总和**
+**组合总和**
-[Leetcode : 377. Combination Sum IV (Medium)](https://leetcode.com/problems/combination-sum-iv/description/)
+[Leetcode : 377. Combination Sum IV (Medium)](https://leetcode.com/problems/combination-sum-iv/description/)
```html
-nums = [1, 2, 3]
-target = 4
+nums = [1, 2, 3]
+target = 4
-The possible combination ways are:
-(1, 1, 1, 1)
-(1, 1, 2)
-(1, 2, 1)
-(1, 3)
-(2, 1, 1)
-(2, 2)
-(3, 1)
+The possible combination ways are:
+(1, 1, 1, 1)
+(1, 1, 2)
+(1, 2, 1)
+(1, 3)
+(2, 1, 1)
+(2, 2)
+(3, 1)
-Note that different sequences are counted as different combinations.
+Note that different sequences are counted as different combinations.
-Therefore the output is 7.
+Therefore the output is 7.
```
```java
-public int combinationSum4(int[] nums, int target) {
- int[] dp = new int[target + 1];
- dp[0] = 1;
- for (int i = 1; i <= target; i++) {
- for (int j = 0; j < nums.length; j++) {
- if(nums[j] <= i) {
- dp[i] += dp[i - nums[j]];
- }
- }
- }
- return dp[target];
+public int combinationSum4(int[] nums, int target) {
+ int[] dp = new int[target + 1];
+ dp[0] = 1;
+ for (int i = 1; i <= target; i++) {
+ for (int j = 0; j < nums.length; j++) {
+ if(nums[j] <= i) {
+ dp[i] += dp[i - nums[j]];
+ }
+ }
+ }
+ return dp[target];
}
```
-**只能进行两次的股票交易**
+**只能进行两次的股票交易**
-[Leetcode : 123. Best Time to Buy and Sell Stock III (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/description/)
+[Leetcode : 123. Best Time to Buy and Sell Stock III (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/description/)
```java
-public int maxProfit(int[] prices) {
- int firstBuy = Integer.MIN_VALUE, firstSell = 0;
- int secondBuy = Integer.MIN_VALUE, secondSell = 0;
- for (int curPrice : prices) {
- if (firstBuy < -curPrice) firstBuy = -curPrice;
- if (firstSell < firstBuy + curPrice) firstSell = firstBuy + curPrice;
- if (secondBuy < firstSell - curPrice) secondBuy = firstSell - curPrice;
- if (secondSell < secondBuy + curPrice) secondSell = secondBuy + curPrice;
- }
- return secondSell;
+public int maxProfit(int[] prices) {
+ int firstBuy = Integer.MIN_VALUE, firstSell = 0;
+ int secondBuy = Integer.MIN_VALUE, secondSell = 0;
+ for (int curPrice : prices) {
+ if (firstBuy < -curPrice) firstBuy = -curPrice;
+ if (firstSell < firstBuy + curPrice) firstSell = firstBuy + curPrice;
+ if (secondBuy < firstSell - curPrice) secondBuy = firstSell - curPrice;
+ if (secondSell < secondBuy + curPrice) secondSell = secondBuy + curPrice;
+ }
+ return secondSell;
}
```
-**只能进行 k 次的股票交易**
+**只能进行 k 次的股票交易**
-[Leetcode : 188. Best Time to Buy and Sell Stock IV (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/description/)
+[Leetcode : 188. Best Time to Buy and Sell Stock IV (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/description/)
```html
-dp[i, j] = max(dp[i, j-1], prices[j] - prices[jj] + dp[i-1, jj]) { jj in range of [0, j-1] } = max(dp[i, j-1], prices[j] + max(dp[i-1, jj] - prices[jj]))
+dp[i, j] = max(dp[i, j-1], prices[j] - prices[jj] + dp[i-1, jj]) { jj in range of [0, j-1] } = max(dp[i, j-1], prices[j] + max(dp[i-1, jj] - prices[jj]))
```
```java
-public int maxProfit(int k, int[] prices) {
- int n = prices.length;
- if (k >= n/2) {
- int maxPro = 0;
- for (int i = 1; i < n; i++) {
- if (prices[i] > prices[i-1])
- maxPro += prices[i] - prices[i-1];
- }
- return maxPro;
- }
- int[][] dp = new int[k + 1][n];
- for (int i = 1; i <= k; i++) {
- int localMax = dp[i - 1][0] - prices[0];
- for (int j = 1; j < n; j++) {
- dp[i][j] = Math.max(dp[i][j - 1], prices[j] + localMax);
- localMax = Math.max(localMax, dp[i - 1][j] - prices[j]);
- }
- }
- return dp[k][n - 1];
+public int maxProfit(int k, int[] prices) {
+ int n = prices.length;
+ if (k >= n/2) {
+ int maxPro = 0;
+ for (int i = 1; i < n; i++) {
+ if (prices[i] > prices[i-1])
+ maxPro += prices[i] - prices[i-1];
+ }
+ return maxPro;
+ }
+ int[][] dp = new int[k + 1][n];
+ for (int i = 1; i <= k; i++) {
+ int localMax = dp[i - 1][0] - prices[0];
+ for (int j = 1; j < n; j++) {
+ dp[i][j] = Math.max(dp[i][j - 1], prices[j] + localMax);
+ localMax = Math.max(localMax, dp[i - 1][j] - prices[j]);
+ }
+ }
+ return dp[k][n - 1];
}
```
-### 数组区间
+### 数组区间
-**数组区间和**
+**数组区间和**
-[Leetcode : 303. Range Sum Query - Immutable (Easy)](https://leetcode.com/problems/range-sum-query-immutable/description/)
+[Leetcode : 303. Range Sum Query - Immutable (Easy)](https://leetcode.com/problems/range-sum-query-immutable/description/)
-求区间 i ~ j 的和，可以转换为 sum[j] - sum[i-1]，其中 sum[i] 为 0 ~ j 的和。
+求区间 i \~ j 的和，可以转换为 sum[j] - sum[i-1]，其中 sum[i] 为 0 \~ j 的和。
```java
-class NumArray {
+class NumArray {
- int[] nums;
+ int[] nums;
- public NumArray(int[] nums) {
- for(int i = 1; i < nums.length; i++)
- nums[i] += nums[i - 1];
- this.nums = nums;
- }
+ public NumArray(int[] nums) {
+ for(int i = 1; i < nums.length; i++)
+ nums[i] += nums[i - 1];
+ this.nums = nums;
+ }
- public int sumRange(int i, int j) {
- return i == 0 ? nums[j] : nums[j] - nums[i - 1];
- }
+ public int sumRange(int i, int j) {
+ return i == 0 ? nums[j] : nums[j] - nums[i - 1];
+ }
}
```
-**子数组最大的和**
+**子数组最大的和**
-[Leetcode : 53. Maximum Subarray (Easy)](https://leetcode.com/problems/maximum-subarray/description/)
+[Leetcode : 53. Maximum Subarray (Easy)](https://leetcode.com/problems/maximum-subarray/description/)
-令 sum[i] 为以 num[i] 为结尾的子数组最大的和，可以由 sum[i-1] 得到 sum[i] 的值，如果 sum[i-1] 小于 0，那么以 num[i] 为结尾的子数组不能包含前面的内容，因为加上前面的部分，那么和一定会比 num[i] 还小。
+令 sum[i] 为以 num[i] 为结尾的子数组最大的和，可以由 sum[i-1] 得到 sum[i] 的值，如果 sum[i-1] 小于 0，那么以 num[i] 为结尾的子数组不能包含前面的内容，因为加上前面的部分，那么和一定会比 num[i] 还小。
```java
-public int maxSubArray(int[] nums) {
- int n = nums.length;
- int[] sum = new int[n];
- sum[0] = nums[0];
- int max = sum[0];
- for(int i = 1; i < n; i++){
- sum[i] = (sum[i-1] > 0 ? sum[i-1] : 0) + nums[i];
- max = Math.max(max, sum[i]);
- }
- return max;
+public int maxSubArray(int[] nums) {
+ int n = nums.length;
+ int[] sum = new int[n];
+ sum[0] = nums[0];
+ int max = sum[0];
+ for(int i = 1; i < n; i++){
+ sum[i] = (sum[i-1] > 0 ? sum[i-1] : 0) + nums[i];
+ max = Math.max(max, sum[i]);
+ }
+ return max;
}
```
-空间复杂度可以优化成 O(1) 空间复杂度
+空间复杂度可以优化成 O(1) 空间复杂度
```java
-public int maxSubArray(int[] nums) {
- int max = nums[0];
- int oldsum = nums[0];
- for (int i = 1; i < nums.length; i++) {
- oldsum = (oldsum > 0 ? oldsum: 0) + nums[i];
- max = Math.max(max, oldsum);
- }
- return max;
+public int maxSubArray(int[] nums) {
+ int max = nums[0];
+ int oldsum = nums[0];
+ for (int i = 1; i < nums.length; i++) {
+ oldsum = (oldsum > 0 ? oldsum: 0) + nums[i];
+ max = Math.max(max, oldsum);
+ }
+ return max;
}
```
-**数组中等差递增子区间的个数**
+**数组中等差递增子区间的个数**
-[Leetcode : 413. Arithmetic Slices (Medium)](https://leetcode.com/problems/arithmetic-slices/description/)
+[Leetcode : 413. Arithmetic Slices (Medium)](https://leetcode.com/problems/arithmetic-slices/description/)
```html
-A = [1, 2, 3, 4]
+A = [1, 2, 3, 4]
-return: 3, for 3 arithmetic slices in A: [1, 2, 3], [2, 3, 4] and [1, 2, 3, 4] itself.
+return: 3, for 3 arithmetic slices in A: [1, 2, 3], [2, 3, 4] and [1, 2, 3, 4] itself.
```
-对于 (1,2,3,4)，它有三种组成递增子区间的方式，而对于 (1,2,3,4,5)，它组成递增子区间的方式除了 (1,2,3,4) 的三种外还多了一种，即 (1,2,3,4,5)，因此 dp[i] = dp[i - 1] + 1。
+对于 (1,2,3,4)，它有三种组成递增子区间的方式，而对于 (1,2,3,4,5)，它组成递增子区间的方式除了 (1,2,3,4) 的三种外还多了一种，即 (1,2,3,4,5)，因此 dp[i] = dp[i - 1] + 1。
```java
-public int numberOfArithmeticSlices(int[] A) {
- int n = A.length;
- int[] dp = new int[n];
- for(int i = 2; i < n; i++) {
- if(A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {
- dp[i] = dp[i - 1] + 1;
- }
- }
- int ret = 0;
- for(int cnt : dp) {
- ret += cnt;
- }
- return ret;
+public int numberOfArithmeticSlices(int[] A) {
+ int n = A.length;
+ int[] dp = new int[n];
+ for(int i = 2; i < n; i++) {
+ if(A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {
+ dp[i] = dp[i - 1] + 1;
+ }
+ }
+ int ret = 0;
+ for(int cnt : dp) {
+ ret += cnt;
+ }
+ return ret;
}
```
-### 字符串编辑
+### 字符串编辑
-**删除两个字符串的字符使它们相等**
+**删除两个字符串的字符使它们相等**
-[Leetcode : 583. Delete Operation for Two Strings (Medium)](https://leetcode.com/problems/delete-operation-for-two-strings/description/)
+[Leetcode : 583. Delete Operation for Two Strings (Medium)](https://leetcode.com/problems/delete-operation-for-two-strings/description/)
可以转换为求两个字符串的最长公共子序列问题。
```java
-public int minDistance(String word1, String word2) {
- int m = word1.length(), n = word2.length();
- int[][] dp = new int[m + 1][n + 1];
- for (int i = 0; i <= m; i++) {
- for (int j = 0; j <= n; j++) {
- if (i == 0 || j == 0) continue;
- dp[i][j] = word1.charAt(i - 1) == word2.charAt(j - 1) ? dp[i - 1][j - 1] + 1
- : Math.max(dp[i][j - 1], dp[i - 1][j]);
- }
- }
- return m + n - 2 * dp[m][n];
+public int minDistance(String word1, String word2) {
+ int m = word1.length(), n = word2.length();
+ int[][] dp = new int[m + 1][n + 1];
+ for (int i = 0; i <= m; i++) {
+ for (int j = 0; j <= n; j++) {
+ if (i == 0 || j == 0) continue;
+ dp[i][j] = word1.charAt(i - 1) == word2.charAt(j - 1) ? dp[i - 1][j - 1] + 1
+ : Math.max(dp[i][j - 1], dp[i - 1][j]);
+ }
+ }
+ return m + n - 2 * dp[m][n];
}
```
-**修改一个字符串称为另一个字符串** // TODO
+**修改一个字符串称为另一个字符串** // TODO
-[Leetcode : 72. Edit Distance (Hard)](https://leetcode.com/problems/edit-distance/description/)
+[Leetcode : 72. Edit Distance (Hard)](https://leetcode.com/problems/edit-distance/description/)
-### 其它问题
+### 其它问题
-**需要冷却期的股票交易**
+**需要冷却期的股票交易**
-[Leetcode : 309. Best Time to Buy and Sell Stock with Cooldown(Medium)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/description/)
+[Leetcode : 309. Best Time to Buy and Sell Stock with Cooldown(Medium)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/description/)
题目描述：交易之后需要有一天的冷却时间。
-
+
```html
-s0[i] = max(s0[i - 1], s2[i - 1]); // Stay at s0, or rest from s2
-s1[i] = max(s1[i - 1], s0[i - 1] - prices[i]); // Stay at s1, or buy from s0
-s2[i] = s1[i - 1] + prices[i]; // Only one way from s1
+s0[i] = max(s0[i - 1], s2[i - 1]); // Stay at s0, or rest from s2
+s1[i] = max(s1[i - 1], s0[i - 1] - prices[i]); // Stay at s1, or buy from s0
+s2[i] = s1[i - 1] + prices[i]; // Only one way from s1
```
```java
-public int maxProfit(int[] prices) {
- if (prices == null || prices.length == 0) return 0;
- int n = prices.length;
- int[] s0 = new int[n];
- int[] s1 = new int[n];
- int[] s2 = new int[n];
- s0[0] = 0;
- s1[0] = -prices[0];
- s2[0] = Integer.MIN_VALUE;
- for (int i = 1; i < n; i++) {
- s0[i] = Math.max(s0[i - 1], s2[i - 1]);
- s1[i] = Math.max(s1[i - 1], s0[i - 1] - prices[i]);
- s2[i] = Math.max(s2[i - 1], s1[i - 1] + prices[i]);
- }
- return Math.max(s0[n - 1], s2[n - 1]);
+public int maxProfit(int[] prices) {
+ if (prices == null || prices.length == 0) return 0;
+ int n = prices.length;
+ int[] s0 = new int[n];
+ int[] s1 = new int[n];
+ int[] s2 = new int[n];
+ s0[0] = 0;
+ s1[0] = -prices[0];
+ s2[0] = Integer.MIN_VALUE;
+ for (int i = 1; i < n; i++) {
+ s0[i] = Math.max(s0[i - 1], s2[i - 1]);
+ s1[i] = Math.max(s1[i - 1], s0[i - 1] - prices[i]);
+ s2[i] = Math.max(s2[i - 1], s1[i - 1] + prices[i]);
+ }
+ return Math.max(s0[n - 1], s2[n - 1]);
}
```
-**统计从 0 ~ n 每个数的二进制表示中 1 的个数**
+**统计从 0 \~ n 每个数的二进制表示中 1 的个数**
-[Leetcode : 338. Counting Bits (Medium)](https://leetcode.com/problems/counting-bits/description/)
+[Leetcode : 338. Counting Bits (Medium)](https://leetcode.com/problems/counting-bits/description/)
-对于数字 6(110)，它可以看成是数字 2(10) 前面加上一个 1 ，因此 dp[i] = dp[i&(i-1)] + 1;
+对于数字 6(110)，它可以看成是数字 2(10) 前面加上一个 1 ，因此 dp[i] = dp[i&(i-1)] + 1;
```java
- public int[] countBits(int num) {
- int[] ret = new int[num + 1];
- for(int i = 1; i <= num; i++){
- ret[i] = ret[i&(i-1)] + 1;
- }
- return ret;
- }
+ public int[] countBits(int num) {
+ int[] ret = new int[num + 1];
+ for(int i = 1; i <= num; i++){
+ ret[i] = ret[i&(i-1)] + 1;
+ }
+ return ret;
+ }
```
-**一组整数对能够构成的最长链**
+**一组整数对能够构成的最长链**
-[Leetcode : 646. Maximum Length of Pair Chain (Medium)](https://leetcode.com/problems/maximum-length-of-pair-chain/description/)
+[Leetcode : 646. Maximum Length of Pair Chain (Medium)](https://leetcode.com/problems/maximum-length-of-pair-chain/description/)
-对于 (a, b) 和 (c, d) ，如果 b < c，则它们可以构成一条链。
+对于 (a, b) 和 (c, d) ，如果 b < c，则它们可以构成一条链。
```java
-public int findLongestChain(int[][] pairs) {
- if(pairs == null || pairs.length == 0) {
- return 0;
- }
- Arrays.sort(pairs, (a, b) -> (a[0] - b[0]));
- int n = pairs.length;
- int[] dp = new int[n];
- Arrays.fill(dp, 1);
- for(int i = 0; i < n; i++) {
- for(int j = 0; j < i; j++) {
- if(pairs[i][0] > pairs[j][1]){
- dp[i] = Math.max(dp[i], dp[j] + 1);
- }
- }
- }
+public int findLongestChain(int[][] pairs) {
+ if(pairs == null || pairs.length == 0) {
+ return 0;
+ }
+ Arrays.sort(pairs, (a, b) -> (a[0] - b[0]));
+ int n = pairs.length;
+ int[] dp = new int[n];
+ Arrays.fill(dp, 1);
+ for(int i = 0; i < n; i++) {
+ for(int j = 0; j < i; j++) {
+ if(pairs[i][0] > pairs[j][1]){
+ dp[i] = Math.max(dp[i], dp[j] + 1);
+ }
+ }
+ }
- int ret = 0;
- for(int num : dp) {
- ret = Math.max(ret, num);
- }
- return ret;
+ int ret = 0;
+ for(int num : dp) {
+ ret = Math.max(ret, num);
+ }
+ return ret;
}
```
-**买入和售出股票最大的收益**
+**买入和售出股票最大的收益**
-[Leetcode : 121. Best Time to Buy and Sell Stock (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
+[Leetcode : 121. Best Time to Buy and Sell Stock (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
只进行一次交易。
只要记录前面的最小价格，将这个最小价格作为买入价格，然后将当前的价格作为售出价格，查看这个价格是否是当前的最大价格。
```java
-public int maxProfit(int[] prices) {
- int n = prices.length;
- if(n == 0) return 0;
- int soFarMin = prices[0];
- int max = 0;
- for(int i = 1; i < n; i++){
- if(soFarMin > prices[i]) soFarMin = prices[i];
- else max = Math.max(max, prices[i] - soFarMin);
- }
- return max;
+public int maxProfit(int[] prices) {
+ int n = prices.length;
+ if(n == 0) return 0;
+ int soFarMin = prices[0];
+ int max = 0;
+ for(int i = 1; i < n; i++){
+ if(soFarMin > prices[i]) soFarMin = prices[i];
+ else max = Math.max(max, prices[i] - soFarMin);
+ }
+ return max;
}
```
-**复制粘贴字符**
+**复制粘贴字符**
-[Leetcode : 650. 2 Keys Keyboard (Medium)](https://leetcode.com/problems/2-keys-keyboard/description/)
+[Leetcode : 650. 2 Keys Keyboard (Medium)](https://leetcode.com/problems/2-keys-keyboard/description/)
```java
-public int minSteps(int n) {
- int[] dp = new int[n + 1];
- for (int i = 2; i <= n; i++) {
- dp[i] = i;
- for (int j = i - 1; j >= 0; j--) {
- if (i % j == 0) {
- dp[i] = dp[j] + dp[i / j];
- break;
- }
- }
- }
- return dp[n];
+public int minSteps(int n) {
+ int[] dp = new int[n + 1];
+ for (int i = 2; i <= n; i++) {
+ dp[i] = i;
+ for (int j = i - 1; j >= 0; j--) {
+ if (i % j == 0) {
+ dp[i] = dp[j] + dp[i / j];
+ break;
+ }
+ }
+ }
+ return dp[n];
}
```
```java
-public int minSteps(int n) {
- if (n == 1) return 0;
- for (int i = 2; i <= Math.sqrt(n); i++) {
- if (n % i == 0) return i + minSteps(n / i);
- }
- return n;
+public int minSteps(int n) {
+ if (n == 1) return 0;
+ for (int i = 2; i <= Math.sqrt(n); i++) {
+ if (n % i == 0) return i + minSteps(n / i);
+ }
+ return n;
}
```
-## 数学
+## 数学
-### 素数
+### 素数
-**素数分解**
+**素数分解**
-每一个数都可以分解成素数的乘积，例如 84 = 22 \* 31 \* 50 \* 71 \* 110 \* 130 \* 170 \* …
+每一个数都可以分解成素数的乘积，例如 84 = 22 \* 31 \* 50 \* 71 \* 110 \* 130 \* 170 \* …
-**整除**
+**整除**
-令 x = 2m0 \* 3m1 \* 5m2 \* 7m3 \* 11m4 \* …
-令 y = 2n0 \* 3n1 \* 5n2 \* 7n3 \* 11n4 \* …
+令 x = 2m0 \* 3m1 \* 5m2 \* 7m3 \* 11m4 \* …
+令 y = 2n0 \* 3n1 \* 5n2 \* 7n3 \* 11n4 \* …
-如果 x 整除 y（y mod x == 0），则对于所有 i，mi <= ni。
+如果 x 整除 y（y mod x == 0），则对于所有 i，mi <= ni。
-x 和 y 的 **最大公约数** 为：gcd(x,y) = 2min(m0,n0) \* 3min(m1,n1) \* 5min(m2,n2) \* ...
+x 和 y 的 **最大公约数** 为：gcd(x,y) = 2min(m0,n0) \* 3min(m1,n1) \* 5min(m2,n2) \* ...
-x 和 y 的 **最小公倍数** 为：lcm(x,y) = 2max(m0,n0) \* 3max(m1,n1) \* 5max(m2,n2) \* ...
+x 和 y 的 **最小公倍数** 为：lcm(x,y) = 2max(m0,n0) \* 3max(m1,n1) \* 5max(m2,n2) \* ...
-**生成素数序列**
+**生成素数序列**
-[Leetcode : 204. Count Primes (Easy)](https://leetcode.com/problems/count-primes/description/)
+[Leetcode : 204. Count Primes (Easy)](https://leetcode.com/problems/count-primes/description/)
埃拉托斯特尼筛法在每次找到一个素数时，将能被素数整除的数排除掉。
```java
-public int countPrimes(int n) {
- boolean[] notPrimes = new boolean[n + 1];
- int cnt = 0;
- for(int i = 2; i < n; i++){
- if(notPrimes[i]) continue;
- cnt++;
- // 从 i * i 开始，因为如果 k < i，那么 k * i 在之前就已经被去除过了
- for(long j = (long) i * i; j < n; j += i){
- notPrimes[(int) j] = true;
- }
- }
- return cnt;
+public int countPrimes(int n) {
+ boolean[] notPrimes = new boolean[n + 1];
+ int cnt = 0;
+ for(int i = 2; i < n; i++){
+ if(notPrimes[i]) continue;
+ cnt++;
+ // 从 i * i 开始，因为如果 k < i，那么 k * i 在之前就已经被去除过了
+ for(long j = (long) i * i; j < n; j += i){
+ notPrimes[(int) j] = true;
+ }
+ }
+ return cnt;
}
```
-### 最大公约数
+### 最大公约数
```java
-int gcd(int a, int b) {
- if (b == 0) return a;
- return gcd(b, a % b);
+int gcd(int a, int b) {
+ if (b == 0) return a;
+ return gcd(b, a % b);
}
```
最大公倍数为两数的乘积除以最大公约数。
```java
-int lcm(int a, int b){
- return a * b / gcd(a, b);
+int lcm(int a, int b){
+ return a * b / gcd(a, b);
}
```
-对于最大公约数问题，因为需要计算 a % b ，而这个操作是比较耗时的，可以使用 [编程之美：2.7]() 的方法，利用减法和移位操作来替换它。
+对于最大公约数问题，因为需要计算 a % b ，而这个操作是比较耗时的，可以使用 [编程之美：2.7]() 的方法，利用减法和移位操作来替换它。
-对于 a 和 b 的最大公约数 f(a, b)，有：
+对于 a 和 b 的最大公约数 f(a, b)，有：
-1\. 如果 a 和 b 均为偶数，f(a, b) = 2\*f(a/2, b/2);
-2\. 如果 a 是偶数 b 是奇数，f(a, b) = f(a/2, b);
-3\. 如果 b 是偶数 a 是奇数，f(a, b) = f(a, b/2);
-4\. 如果 a 和 b 均为奇数，f(a, b) = f(a, a-b);
+1\. 如果 a 和 b 均为偶数，f(a, b) = 2\*f(a/2, b/2);
+2\. 如果 a 是偶数 b 是奇数，f(a, b) = f(a/2, b);
+3\. 如果 b 是偶数 a 是奇数，f(a, b) = f(a, b/2);
+4\. 如果 a 和 b 均为奇数，f(a, b) = f(a, a-b);
-乘 2 和除 2 都可以转换为移位操作。
+乘 2 和除 2 都可以转换为移位操作。
-### 进制转换
+### 进制转换
-Java 中 static String toString(int num, int radix) 可以将一个整数装换为 redix 进制表示的字符串。
+Java 中 static String toString(int num, int radix) 可以将一个整数装换为 redix 进制表示的字符串。
-**7 进制**
+**7 进制**
-[Leetcode : 504. Base 7 (Easy)](https://leetcode.com/problems/base-7/description/)
+[Leetcode : 504. Base 7 (Easy)](https://leetcode.com/problems/base-7/description/)
```java
-public String convertToBase7(int num) {
- if (num < 0) {
- return '-' + convertToBase7(-num);
- }
- if (num < 7) {
- return num + "";
- }
- return convertToBase7(num / 7) + num % 7;
+public String convertToBase7(int num) {
+ if (num < 0) {
+ return '-' + convertToBase7(-num);
+ }
+ if (num < 7) {
+ return num + "";
+ }
+ return convertToBase7(num / 7) + num % 7;
}
```
-**16 进制**
+**16 进制**
-[Leetcode : 405. Convert a Number to Hexadecimal (Easy)](https://leetcode.com/problems/convert-a-number-to-hexadecimal/description/)
+[Leetcode : 405. Convert a Number to Hexadecimal (Easy)](https://leetcode.com/problems/convert-a-number-to-hexadecimal/description/)
```java
-public String toHex(int num) {
- char[] map = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
- if(num == 0) return "0";
- String ret = "";
- while(num != 0){
- ret = map[(num & 0b1111)] + ret;
- num >>>= 4;
- }
- return ret;
+public String toHex(int num) {
+ char[] map = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
+ if(num == 0) return "0";
+ String ret = "";
+ while(num != 0){
+ ret = map[(num & 0b1111)] + ret;
+ num >>>= 4;
+ }
+ return ret;
}
```
-### 阶乘
+### 阶乘
-**统计阶乘尾部有多少个 0**
+**统计阶乘尾部有多少个 0**
-[Leetcode : 172. Factorial Trailing Zeroes (Easy)](https://leetcode.com/problems/factorial-trailing-zeroes/description/)
+[Leetcode : 172. Factorial Trailing Zeroes (Easy)](https://leetcode.com/problems/factorial-trailing-zeroes/description/)
-尾部的 0 由 2 * 5 得来，2 的数量明显多于 5 的数量，因此只要统计有多少个 5 即可。
+尾部的 0 由 2 * 5 得来，2 的数量明显多于 5 的数量，因此只要统计有多少个 5 即可。
-对于一个数 N，它所包含 5 的个数为：N/5 + N/52 + N/53 + ...，其中 N/5 表示不大于 N 的数中 5 的倍数贡献一个 5，N/52 表示不大于 N 的数中 52 的倍数再贡献一个 5 ...。
+对于一个数 N，它所包含 5 的个数为：N/5 + N/52 + N/53 + ...，其中 N/5 表示不大于 N 的数中 5 的倍数贡献一个 5，N/52 表示不大于 N 的数中 52 的倍数再贡献一个 5 ...。
```java
-public int trailingZeroes(int n) {
- return n == 0 ? 0 : n / 5 + trailingZeroes(n / 5);
+public int trailingZeroes(int n) {
+ return n == 0 ? 0 : n / 5 + trailingZeroes(n / 5);
}
```
-如果统计的是 N! 的二进制表示中最低位 1 的位置，只要统计有多少个 2 即可，该题目出自 [编程之美：2.2](#) 。和求解有多少个 5 一样，2 的个数为 N/2 + N/22 + N/23 + ...
+如果统计的是 N! 的二进制表示中最低位 1 的位置，只要统计有多少个 2 即可，该题目出自 [编程之美：2.2](#) 。和求解有多少个 5 一样，2 的个数为 N/2 + N/22 + N/23 + ...
-### 字符串加法减法
+### 字符串加法减法
-**二进制加法**
+**二进制加法**
-[Leetcode : 67. Add Binary (Easy)](https://leetcode.com/problems/add-binary/description/)
+[Leetcode : 67. Add Binary (Easy)](https://leetcode.com/problems/add-binary/description/)
```html
-a = "11"
-b = "1"
-Return "100".
+a = "11"
+b = "1"
+Return "100".
```
```java
-public String addBinary(String a, String b) {
- int i = a.length() - 1, j = b.length() - 1, carry = 0;
- String str = "";
- while(i >= 0 || j >= 0){
- if(i >= 0 && a.charAt(i--) == '1') carry++;
- if(j >= 0 && b.charAt(j--) == '1') carry++;
- str = (carry % 2) + str;
- carry /= 2;
- }
- if(carry == 1) str = "1" + str;
- return str;
+public String addBinary(String a, String b) {
+ int i = a.length() - 1, j = b.length() - 1, carry = 0;
+ String str = "";
+ while(i >= 0 || j >= 0){
+ if(i >= 0 && a.charAt(i--) == '1') carry++;
+ if(j >= 0 && b.charAt(j--) == '1') carry++;
+ str = (carry % 2) + str;
+ carry /= 2;
+ }
+ if(carry == 1) str = "1" + str;
+ return str;
}
```
-**字符串加法**
+**字符串加法**
-[Leetcode : 415. Add Strings (Easy)](https://leetcode.com/problems/add-strings/description/)
+[Leetcode : 415. Add Strings (Easy)](https://leetcode.com/problems/add-strings/description/)
字符串的值为非负整数
```java
-public String addStrings(String num1, String num2) {
- StringBuilder sb = new StringBuilder();
- int carry = 0;
- for(int i = num1.length() - 1, j = num2.length() - 1; i >= 0 || j >= 0 || carry == 1; i--, j--){
- int x = i < 0 ? 0 : num1.charAt(i) - '0';
- int y = j < 0 ? 0 : num2.charAt(j) - '0';
- sb.append((x + y + carry) % 10);
- carry = (x + y + carry) / 10;
- }
- return sb.reverse().toString();
+public String addStrings(String num1, String num2) {
+ StringBuilder sb = new StringBuilder();
+ int carry = 0;
+ for(int i = num1.length() - 1, j = num2.length() - 1; i >= 0 || j >= 0 || carry == 1; i--, j--){
+ int x = i < 0 ? 0 : num1.charAt(i) - '0';
+ int y = j < 0 ? 0 : num2.charAt(j) - '0';
+ sb.append((x + y + carry) % 10);
+ carry = (x + y + carry) / 10;
+ }
+ return sb.reverse().toString();
}
```
-### 相遇问题
+### 相遇问题
-**改变数组元素使所有的数组元素都相等**
+**改变数组元素使所有的数组元素都相等**
-[Leetcode : 462. Minimum Moves to Equal Array Elements II (Medium)](https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/description/)
+[Leetcode : 462. Minimum Moves to Equal Array Elements II (Medium)](https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/description/)
```html
Input:
@@ -2779,1774 +2830,1774 @@ Output:
2
Explanation:
-Only two moves are needed (remember each move increments or decrements one element):
+Only two moves are needed (remember each move increments or decrements one element):
-[1,2,3] => [2,2,3] => [2,2,2]
+[1,2,3] => [2,2,3] => [2,2,2]
```
每次可以对一个数组元素加一或者减一，求最小的改变次数。
这是个典型的相遇问题，移动距离最小的方式是所有元素都移动到中位数。理由如下：
-设 m 为中位数。a 和 b 是 m 两边的两个元素，且 b > a。要使 a 和 b 相等，它们总共移动的次数为 b - a，这个值等于 (b - m) + (m - a)，也就是把这两个数移动到中位数的移动次数。
+设 m 为中位数。a 和 b 是 m 两边的两个元素，且 b > a。要使 a 和 b 相等，它们总共移动的次数为 b - a，这个值等于 (b - m) + (m - a)，也就是把这两个数移动到中位数的移动次数。
-设数组长度为 N，则可以找到 N/2 对 a 和 b 的组合，使它们都移动到 m 的位置。
+设数组长度为 N，则可以找到 N/2 对 a 和 b 的组合，使它们都移动到 m 的位置。
-**解法 1**
+**解法 1**
先排序，时间复杂度：O(NlgN)
```java
-public int minMoves2(int[] nums) {
- Arrays.sort(nums);
- int ret = 0;
- int l = 0, h = nums.length - 1;
- while(l <= h) {
- ret += nums[h] - nums[l];
- l++;
- h--;
- }
- return ret;
+public int minMoves2(int[] nums) {
+ Arrays.sort(nums);
+ int ret = 0;
+ int l = 0, h = nums.length - 1;
+ while(l <= h) {
+ ret += nums[h] - nums[l];
+ l++;
+ h--;
+ }
+ return ret;
}
```
-**解法 2**
+**解法 2**
-使用快速排序找到中位数，时间复杂度 O(N)
+使用快速排序找到中位数，时间复杂度 O(N)
```java
-public int minMoves2(int[] nums) {
- int ret = 0;
- int n = nums.length;
- int median = quickSelect(nums, 0, n - 1, n / 2 + 1);
- for(int num : nums) ret += Math.abs(num - median);
- return ret;
+public int minMoves2(int[] nums) {
+ int ret = 0;
+ int n = nums.length;
+ int median = quickSelect(nums, 0, n - 1, n / 2 + 1);
+ for(int num : nums) ret += Math.abs(num - median);
+ return ret;
}
-private int quickSelect(int[] nums, int start, int end, int k) {
- int l = start, r = end, privot = nums[(l + r) / 2];
- while(l <= r) {
- while(nums[l] < privot) l++;
- while(nums[r] > privot) r--;
- if(l >= r) break;
- swap(nums, l, r);
- l++; r--;
- }
- int left = l - start + 1;
- if(left > k) return quickSelect(nums, start, l - 1, k);
- if(left == k && l == r) return nums[l];
- int right = r - start + 1;
- return quickSelect(nums, r + 1, end, k - right);
+private int quickSelect(int[] nums, int start, int end, int k) {
+ int l = start, r = end, privot = nums[(l + r) / 2];
+ while(l <= r) {
+ while(nums[l] < privot) l++;
+ while(nums[r] > privot) r--;
+ if(l >= r) break;
+ swap(nums, l, r);
+ l++; r--;
+ }
+ int left = l - start + 1;
+ if(left > k) return quickSelect(nums, start, l - 1, k);
+ if(left == k && l == r) return nums[l];
+ int right = r - start + 1;
+ return quickSelect(nums, r + 1, end, k - right);
}
-private void swap(int[] nums, int i, int j) {
- int tmp = nums[i]; nums[i] = nums[j]; nums[j] = tmp;
+private void swap(int[] nums, int i, int j) {
+ int tmp = nums[i]; nums[i] = nums[j]; nums[j] = tmp;
}
```
-### 多数投票问题
+### 多数投票问题
-**数组中出现次数多于 n / 2 的元素**
+**数组中出现次数多于 n / 2 的元素**
-[Leetcode : 169. Majority Element (Easy)](https://leetcode.com/problems/majority-element/description/)
+[Leetcode : 169. Majority Element (Easy)](https://leetcode.com/problems/majority-element/description/)
-先对数组排序，最中间那个数出现次数一定多于 n / 2
+先对数组排序，最中间那个数出现次数一定多于 n / 2
```java
-public int majorityElement(int[] nums) {
- Arrays.sort(nums);
- return nums[nums.length / 2];
+public int majorityElement(int[] nums) {
+ Arrays.sort(nums);
+ return nums[nums.length / 2];
}
```
-可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(n)。可以这么理解该算法：使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素不想等时，令 cnt--。如果前面查找了 i 个元素，且 cnt == 0 ，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2 ，因为如果多于 i / 2 的话 cnt 就一定不会为 0 。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
+可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(n)。可以这么理解该算法：使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素不想等时，令 cnt--。如果前面查找了 i 个元素，且 cnt == 0 ，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2 ，因为如果多于 i / 2 的话 cnt 就一定不会为 0 。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
```java
-public int majorityElement(int[] nums) {
- int cnt = 0, majority = 0;
- for(int i = 0; i < nums.length; i++){
- if(cnt == 0) {
- majority = nums[i];
- cnt++;
- }
- else if(majority == nums[i]) cnt++;
- else cnt--;
- }
- return majority;
+public int majorityElement(int[] nums) {
+ int cnt = 0, majority = 0;
+ for(int i = 0; i < nums.length; i++){
+ if(cnt == 0) {
+ majority = nums[i];
+ cnt++;
+ }
+ else if(majority == nums[i]) cnt++;
+ else cnt--;
+ }
+ return majority;
}
```
-### 其它
+### 其它
-**平方数**
+**平方数**
-[Leetcode : 367. Valid Perfect Square (Easy)](https://leetcode.com/problems/valid-perfect-square/description/)
+[Leetcode : 367. Valid Perfect Square (Easy)](https://leetcode.com/problems/valid-perfect-square/description/)
```html
-Input: 16
-Returns: True
+Input: 16
+Returns: True
```
平方序列：1,4,9,16,..
间隔：3,5,7,...
-间隔为等差数列，使用这个特性可以得到从 1 开始的平方序列。
+间隔为等差数列，使用这个特性可以得到从 1 开始的平方序列。
```java
-public boolean isPerfectSquare(int num) {
- int subNum = 1;
- while (num > 0) {
- num -= subNum;
- subNum += 2;
- }
- return num == 0;
+public boolean isPerfectSquare(int num) {
+ int subNum = 1;
+ while (num > 0) {
+ num -= subNum;
+ subNum += 2;
+ }
+ return num == 0;
}
```
-**3 的 n 次方**
+**3 的 n 次方**
-[Leetcode : 326. Power of Three (Easy)](https://leetcode.com/problems/power-of-three/description/)
+[Leetcode : 326. Power of Three (Easy)](https://leetcode.com/problems/power-of-three/description/)
```java
-public boolean isPowerOfThree(int n) {
- return n > 0 && (1162261467 % n == 0);
+public boolean isPowerOfThree(int n) {
+ return n > 0 && (1162261467 % n == 0);
}
```
-**找出数组中的乘积最大的三个数**
+**找出数组中的乘积最大的三个数**
-[Leetcode : 628. Maximum Product of Three Numbers (Easy)](https://leetcode.com/problems/maximum-product-of-three-numbers/description/)
+[Leetcode : 628. Maximum Product of Three Numbers (Easy)](https://leetcode.com/problems/maximum-product-of-three-numbers/description/)
```html
-Input: [1,2,3,4]
-Output: 24
+Input: [1,2,3,4]
+Output: 24
```
```java
-public int maximumProduct(int[] nums) {
- int max1 = Integer.MIN_VALUE, max2 = Integer.MIN_VALUE, max3 = Integer.MIN_VALUE, min1 = Integer.MAX_VALUE, min2 = Integer.MAX_VALUE;
- for (int n : nums) {
- if (n > max1) {
- max3 = max2;
- max2 = max1;
- max1 = n;
- } else if (n > max2) {
- max3 = max2;
- max2 = n;
- } else if (n > max3) {
- max3 = n;
- }
+public int maximumProduct(int[] nums) {
+ int max1 = Integer.MIN_VALUE, max2 = Integer.MIN_VALUE, max3 = Integer.MIN_VALUE, min1 = Integer.MAX_VALUE, min2 = Integer.MAX_VALUE;
+ for (int n : nums) {
+ if (n > max1) {
+ max3 = max2;
+ max2 = max1;
+ max1 = n;
+ } else if (n > max2) {
+ max3 = max2;
+ max2 = n;
+ } else if (n > max3) {
+ max3 = n;
+ }
- if (n < min1) {
- min2 = min1;
- min1 = n;
- } else if (n < min2) {
- min2 = n;
- }
- }
- return Math.max(max1*max2*max3, max1*min1*min2);
+ if (n < min1) {
+ min2 = min1;
+ min1 = n;
+ } else if (n < min2) {
+ min2 = n;
+ }
+ }
+ return Math.max(max1*max2*max3, max1*min1*min2);
}
```
-**乘积数组**
+**乘积数组**
-[Leetcode : 238. Product of Array Except Self (Medium)](https://leetcode.com/problems/product-of-array-except-self/description/)
+[Leetcode : 238. Product of Array Except Self (Medium)](https://leetcode.com/problems/product-of-array-except-self/description/)
```html
-For example, given [1,2,3,4], return [24,12,8,6].
+For example, given [1,2,3,4], return [24,12,8,6].
```
题目描述：给定一个数组，创建一个新数组，新数组的每个元素为原始数组中除了该位置上的元素之外所有元素的乘积。
-题目要求：时间复杂度为 O(n)，并且不能使用除法。
+题目要求：时间复杂度为 O(n)，并且不能使用除法。
```java
-public int[] productExceptSelf(int[] nums) {
- int n = nums.length;
- int[] ret = new int[n];
- ret[0] = 1;
- for(int i = 1; i < n; i++) {
- ret[i] = ret[i - 1] * nums[i - 1];
- }
- int right = 1;
- for(int i = n - 1; i >= 0; i--) {
- ret[i] *= right;
- right *= nums[i];
- }
- return ret;
+public int[] productExceptSelf(int[] nums) {
+ int n = nums.length;
+ int[] ret = new int[n];
+ ret[0] = 1;
+ for(int i = 1; i < n; i++) {
+ ret[i] = ret[i - 1] * nums[i - 1];
+ }
+ int right = 1;
+ for(int i = n - 1; i >= 0; i--) {
+ ret[i] *= right;
+ right *= nums[i];
+ }
+ return ret;
}
```
-# 数据结构相关
+# 数据结构相关
-## 栈和队列
+## 栈和队列
-**用栈实现队列**
+**用栈实现队列**
-[Leetcode : 232. Implement Queue using Stacks (Easy)](https://leetcode.com/problems/implement-queue-using-stacks/description/)
+[Leetcode : 232. Implement Queue using Stacks (Easy)](https://leetcode.com/problems/implement-queue-using-stacks/description/)
一个栈实现：
```java
-class MyQueue {
- private Stack st = new Stack();
+class MyQueue {
+ private Stack st = new Stack();
- public void push(int x) {
- Stack temp = new Stack();
- while(!st.isEmpty()){
- temp.push(st.pop());
- }
- st.push(x);
- while(!temp.isEmpty()){
- st.push(temp.pop());
- }
- }
+ public void push(int x) {
+ Stack temp = new Stack();
+ while(!st.isEmpty()){
+ temp.push(st.pop());
+ }
+ st.push(x);
+ while(!temp.isEmpty()){
+ st.push(temp.pop());
+ }
+ }
- public int pop() {
- return st.pop();
- }
+ public int pop() {
+ return st.pop();
+ }
- public int peek() {
- return st.peek();
- }
+ public int peek() {
+ return st.peek();
+ }
- public boolean empty() {
- return st.isEmpty();
- }
+ public boolean empty() {
+ return st.isEmpty();
+ }
}
```
两个栈实现：
```java
-class MyQueue {
- private Stack in = new Stack();
- private Stack out = new Stack();
+class MyQueue {
+ private Stack in = new Stack();
+ private Stack out = new Stack();
- public void push(int x) {
- in.push(x);
- }
+ public void push(int x) {
+ in.push(x);
+ }
- public int pop() {
- in2out();
- return out.pop();
- }
+ public int pop() {
+ in2out();
+ return out.pop();
+ }
- public int peek() {
- in2out();
- return out.peek();
- }
+ public int peek() {
+ in2out();
+ return out.peek();
+ }
- private void in2out(){
- if(out.isEmpty()){
- while(!in.isEmpty()){
- out.push(in.pop());
- }
- }
- }
+ private void in2out(){
+ if(out.isEmpty()){
+ while(!in.isEmpty()){
+ out.push(in.pop());
+ }
+ }
+ }
- public boolean empty() {
- return in.isEmpty() && out.isEmpty();
- }
+ public boolean empty() {
+ return in.isEmpty() && out.isEmpty();
+ }
}
```
-**用队列实现栈**
+**用队列实现栈**
-[Leetcode : 225. Implement Stack using Queues (Easy)](https://leetcode.com/problems/implement-stack-using-queues/description/)
+[Leetcode : 225. Implement Stack using Queues (Easy)](https://leetcode.com/problems/implement-stack-using-queues/description/)
```java
-class MyStack {
+class MyStack {
- private Queue queue;
+ private Queue queue;
- public MyStack() {
- queue = new LinkedList<>();
- }
+ public MyStack() {
+ queue = new LinkedList<>();
+ }
- public void push(int x) {
- queue.add(x);
- for(int i = 1; i < queue.size(); i++){ // 翻转
- queue.add(queue.remove());
- }
- }
+ public void push(int x) {
+ queue.add(x);
+ for(int i = 1; i < queue.size(); i++){ // 翻转
+ queue.add(queue.remove());
+ }
+ }
- public int pop() {
- return queue.remove();
- }
+ public int pop() {
+ return queue.remove();
+ }
- public int top() {
- return queue.peek();
- }
+ public int top() {
+ return queue.peek();
+ }
- public boolean empty() {
- return queue.isEmpty();
- }
+ public boolean empty() {
+ return queue.isEmpty();
+ }
}
```
-**最小值栈**
+**最小值栈**
-[Leetcode : 155. Min Stack (Easy)](https://leetcode.com/problems/min-stack/description/)
+[Leetcode : 155. Min Stack (Easy)](https://leetcode.com/problems/min-stack/description/)
用两个栈实现，一个存储数据，一个存储最小值。
```java
-class MinStack {
+class MinStack {
- private Stack dataStack;
- private Stack minStack;
- private int min;
+ private Stack dataStack;
+ private Stack minStack;
+ private int min;
- public MinStack() {
- dataStack = new Stack<>();
- minStack = new Stack<>();
- min = Integer.MAX_VALUE;
- }
+ public MinStack() {
+ dataStack = new Stack<>();
+ minStack = new Stack<>();
+ min = Integer.MAX_VALUE;
+ }
- public void push(int x) {
- dataStack.add(x);
- if(x < min) {
- min = x;
- }
- minStack.add(min);
- }
+ public void push(int x) {
+ dataStack.add(x);
+ if(x < min) {
+ min = x;
+ }
+ minStack.add(min);
+ }
- public void pop() {
- dataStack.pop();
- minStack.pop();
- if(!minStack.isEmpty()) {
- min = minStack.peek();
- } else{
- min = Integer.MAX_VALUE;
- }
- }
+ public void pop() {
+ dataStack.pop();
+ minStack.pop();
+ if(!minStack.isEmpty()) {
+ min = minStack.peek();
+ } else{
+ min = Integer.MAX_VALUE;
+ }
+ }
- public int top() {
- return dataStack.peek();
- }
+ public int top() {
+ return dataStack.peek();
+ }
- public int getMin() {
- return min;
- }
+ public int getMin() {
+ return min;
+ }
}
```
-对于实现最小值队列问题，可以先将队列使用栈来实现，然后就将问题转换为最小值栈，这个问题出现在 编程之美：3.7。
+对于实现最小值队列问题，可以先将队列使用栈来实现，然后就将问题转换为最小值栈，这个问题出现在 编程之美：3.7。
-**用栈实现括号匹配**
+**用栈实现括号匹配**
-[Leetcode : 20. Valid Parentheses (Easy)](https://leetcode.com/problems/valid-parentheses/description/)
+[Leetcode : 20. Valid Parentheses (Easy)](https://leetcode.com/problems/valid-parentheses/description/)
```html
"()[]{}"
-Output : true
+Output : true
```
```java
-public boolean isValid(String s) {
- Stack stack = new Stack<>();
- for(int i = 0; i < s.length(); i++){
- char c = s.charAt(i);
- if(c == '(' || c == '{' || c == '[') stack.push(c);
- else{
- if(stack.isEmpty()) return false;
- char cStack = stack.pop();
- if(c == ')' && cStack != '(' ||
- c == ']' && cStack != '[' ||
- c == '}' && cStack != '{' ) {
- return false;
- }
- }
- }
- return stack.isEmpty();
+public boolean isValid(String s) {
+ Stack stack = new Stack<>();
+ for(int i = 0; i < s.length(); i++){
+ char c = s.charAt(i);
+ if(c == '(' || c == '{' || c == '[') stack.push(c);
+ else{
+ if(stack.isEmpty()) return false;
+ char cStack = stack.pop();
+ if(c == ')' && cStack != '(' ||
+ c == ']' && cStack != '[' ||
+ c == '}' && cStack != '{' ) {
+ return false;
+ }
+ }
+ }
+ return stack.isEmpty();
}
```
-**数组中元素与下一个比它大的元素之间的距离**
+**数组中元素与下一个比它大的元素之间的距离**
```html
-Input: [73, 74, 75, 71, 69, 72, 76, 73]
-Output: [1, 1, 4, 2, 1, 1, 0, 0]
+Input: [73, 74, 75, 71, 69, 72, 76, 73]
+Output: [1, 1, 4, 2, 1, 1, 0, 0]
```
-[Leetcode : 739. Daily Temperatures (Medium)](https://leetcode.com/problems/daily-temperatures/description/)
+[Leetcode : 739. Daily Temperatures (Medium)](https://leetcode.com/problems/daily-temperatures/description/)
-在遍历数组时用 Stack 把数组中的数存起来，如果当前遍历的数比栈顶元素来的大，说明栈顶元素的下一个比它大的数就是当前元素。
+在遍历数组时用 Stack 把数组中的数存起来，如果当前遍历的数比栈顶元素来的大，说明栈顶元素的下一个比它大的数就是当前元素。
```java
-public int[] dailyTemperatures(int[] temperatures) {
- int n = temperatures.length;
- int[] ret = new int[n];
- Stack stack = new Stack<>();
- for(int i = 0; i < n; i++) {
- while(!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {
- int idx = stack.pop();
- ret[idx] = i - idx;
- }
- stack.add(i);
- }
- return ret;
+public int[] dailyTemperatures(int[] temperatures) {
+ int n = temperatures.length;
+ int[] ret = new int[n];
+ Stack stack = new Stack<>();
+ for(int i = 0; i < n; i++) {
+ while(!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {
+ int idx = stack.pop();
+ ret[idx] = i - idx;
+ }
+ stack.add(i);
+ }
+ return ret;
}
```
-**在另一个数组中比当前元素大的下一个元素**
+**在另一个数组中比当前元素大的下一个元素**
-[Leetcode : 496. Next Greater Element I (Easy)](https://leetcode.com/problems/next-greater-element-i/description/)
+[Leetcode : 496. Next Greater Element I (Easy)](https://leetcode.com/problems/next-greater-element-i/description/)
```html
-Input: nums1 = [4,1,2], nums2 = [1,3,4,2].
-Output: [-1,3,-1]
+Input: nums1 = [4,1,2], nums2 = [1,3,4,2].
+Output: [-1,3,-1]
```
```java
-public int[] nextGreaterElement(int[] nums1, int[] nums2) {
- Map map = new HashMap<>();
- Stack stack = new Stack<>();
- for(int num : nums2){
- while(!stack.isEmpty() && num > stack.peek()){
- map.put(stack.pop(), num);
- }
- stack.add(num);
- }
- int[] ret = new int[nums1.length];
- for(int i = 0; i < nums1.length; i++){
- if(map.containsKey(nums1[i])) ret[i] = map.get(nums1[i]);
- else ret[i] = -1;
- }
- return ret;
+public int[] nextGreaterElement(int[] nums1, int[] nums2) {
+ Map map = new HashMap<>();
+ Stack stack = new Stack<>();
+ for(int num : nums2){
+ while(!stack.isEmpty() && num > stack.peek()){
+ map.put(stack.pop(), num);
+ }
+ stack.add(num);
+ }
+ int[] ret = new int[nums1.length];
+ for(int i = 0; i < nums1.length; i++){
+ if(map.containsKey(nums1[i])) ret[i] = map.get(nums1[i]);
+ else ret[i] = -1;
+ }
+ return ret;
}
```
-**循环数组中比当前元素大的下一个元素**
+**循环数组中比当前元素大的下一个元素**
-[Leetcode : 503. Next Greater Element II (Medium)](https://leetcode.com/problems/next-greater-element-ii/description/)
+[Leetcode : 503. Next Greater Element II (Medium)](https://leetcode.com/problems/next-greater-element-ii/description/)
```java
-public int[] nextGreaterElements(int[] nums) {
- int n = nums.length, next[] = new int[n];
- Arrays.fill(next, -1);
- Stack stack = new Stack<>();
- for (int i = 0; i < n * 2; i++) {
- int num = nums[i % n];
- while (!stack.isEmpty() && nums[stack.peek()] < num)
- next[stack.pop()] = num;
- if (i < n) stack.push(i);
- }
- return next;
+public int[] nextGreaterElements(int[] nums) {
+ int n = nums.length, next[] = new int[n];
+ Arrays.fill(next, -1);
+ Stack stack = new Stack<>();
+ for (int i = 0; i < n * 2; i++) {
+ int num = nums[i % n];
+ while (!stack.isEmpty() && nums[stack.peek()] < num)
+ next[stack.pop()] = num;
+ if (i < n) stack.push(i);
+ }
+ return next;
}
```
-## 哈希表
+## 哈希表
-利用 Hash Table 可以快速查找一个元素是否存在等问题，但是需要一定的空间来存储。在优先考虑时间复杂度的情况下，可以利用 Hash Table 这种空间换取时间的做法。
+利用 Hash Table 可以快速查找一个元素是否存在等问题，但是需要一定的空间来存储。在优先考虑时间复杂度的情况下，可以利用 Hash Table 这种空间换取时间的做法。
-Java 中的 **HashSet** 用于存储一个集合，并以 O(1) 的时间复杂度查找元素是否在集合中。
+Java 中的 **HashSet** 用于存储一个集合，并以 O(1) 的时间复杂度查找元素是否在集合中。
-如果元素有穷，并且范围不大，那么可以用一个布尔数组来存储一个元素是否存在，例如对于只有小写字符的元素，就可以用一个长度为 26 的布尔数组来存储一个字符集合，使得空间复杂度降低为 O(1)。
+如果元素有穷，并且范围不大，那么可以用一个布尔数组来存储一个元素是否存在，例如对于只有小写字符的元素，就可以用一个长度为 26 的布尔数组来存储一个字符集合，使得空间复杂度降低为 O(1)。
-Java 中的 **HashMap** 主要用于映射关系，从而把两个元素联系起来。
+Java 中的 **HashMap** 主要用于映射关系，从而把两个元素联系起来。
-在对一个内容进行压缩或者其它转换时，利用 HashMap 可以把原始内容和转换后的内容联系起来。例如在一个简化 url 的系统中（[Leetcdoe : 535. Encode and Decode TinyURL (Medium)](https://leetcode.com/problems/encode-and-decode-tinyurl/description/)），利用 HashMap 就可以存储精简后的 url 到原始 url 的映射，使得不仅可以显示简化的 url，也可以根据简化的 url 得到原始 url 从而定位到正确的资源。
+在对一个内容进行压缩或者其它转换时，利用 HashMap 可以把原始内容和转换后的内容联系起来。例如在一个简化 url 的系统中（[Leetcdoe : 535. Encode and Decode TinyURL (Medium)](https://leetcode.com/problems/encode-and-decode-tinyurl/description/)），利用 HashMap 就可以存储精简后的 url 到原始 url 的映射，使得不仅可以显示简化的 url，也可以根据简化的 url 得到原始 url 从而定位到正确的资源。
-HashMap 也可以用来对元素进行计数统计，此时键为元素，值为计数。和 HashSet 类似，如果元素有穷并且范围不大，可以用整型数组来进行统计。
+HashMap 也可以用来对元素进行计数统计，此时键为元素，值为计数。和 HashSet 类似，如果元素有穷并且范围不大，可以用整型数组来进行统计。
-**数组中的两个数和为给定值**
+**数组中的两个数和为给定值**
-[Leetcode : 1. Two Sum (Easy)](https://leetcode.com/problems/two-sum/description/)
+[Leetcode : 1. Two Sum (Easy)](https://leetcode.com/problems/two-sum/description/)
-可以先对数组进行排序，然后使用双指针方法或者二分查找方法。这样做的时间复杂度为 O(nlgn)，空间复杂度为 O(1)。
+可以先对数组进行排序，然后使用双指针方法或者二分查找方法。这样做的时间复杂度为 O(nlgn)，空间复杂度为 O(1)。
-用 HashMap 存储数组元素和索引的映射，在访问到 nums[i] 时，判断 HashMap 中是否存在 target - nums[i] ，如果存在说明 target - nums[i] 所在的索引和 i 就是要找的两个数。该方法的时间复杂度为 O(n)，空间复杂度为 O(n)，使用空间来换取时间。
+用 HashMap 存储数组元素和索引的映射，在访问到 nums[i] 时，判断 HashMap 中是否存在 target - nums[i] ，如果存在说明 target - nums[i] 所在的索引和 i 就是要找的两个数。该方法的时间复杂度为 O(n)，空间复杂度为 O(n)，使用空间来换取时间。
```java
-public int[] twoSum(int[] nums, int target) {
- HashMap map = new HashMap<>();
- for(int i = 0; i < nums.length; i++){
- if(map.containsKey(target - nums[i])) return new int[]{map.get(target - nums[i]), i};
- else map.put(nums[i], i);
- }
- return null;
+public int[] twoSum(int[] nums, int target) {
+ HashMap map = new HashMap<>();
+ for(int i = 0; i < nums.length; i++){
+ if(map.containsKey(target - nums[i])) return new int[]{map.get(target - nums[i]), i};
+ else map.put(nums[i], i);
+ }
+ return null;
}
```
-**最长和谐序列**
+**最长和谐序列**
-[Leetcode : 594. Longest Harmonious Subsequence (Easy)](https://leetcode.com/problems/longest-harmonious-subsequence/description/)
+[Leetcode : 594. Longest Harmonious Subsequence (Easy)](https://leetcode.com/problems/longest-harmonious-subsequence/description/)
```html
-Input: [1,3,2,2,5,2,3,7]
-Output: 5
-Explanation: The longest harmonious subsequence is [3,2,2,2,3].
+Input: [1,3,2,2,5,2,3,7]
+Output: 5
+Explanation: The longest harmonious subsequence is [3,2,2,2,3].
```
-和谐序列中最大数和最小数只差正好为 1。
+和谐序列中最大数和最小数只差正好为 1。
```java
-public int findLHS(int[] nums) {
- Map map = new HashMap<>();
- for (long num : nums) {
- map.put(num, map.getOrDefault(num, 0) + 1);
- }
- int result = 0;
- for (long key : map.keySet()) {
- if (map.containsKey(key + 1)) {
- result = Math.max(result, map.get(key + 1) + map.get(key));
- }
- }
- return result;
+public int findLHS(int[] nums) {
+ Map map = new HashMap<>();
+ for (long num : nums) {
+ map.put(num, map.getOrDefault(num, 0) + 1);
+ }
+ int result = 0;
+ for (long key : map.keySet()) {
+ if (map.containsKey(key + 1)) {
+ result = Math.max(result, map.get(key + 1) + map.get(key));
+ }
+ }
+ return result;
}
```
-## 字符串
+## 字符串
-**两个字符串包含的字符是否完全相同**
+**两个字符串包含的字符是否完全相同**
-[Leetcode : 242. Valid Anagram (Easy)](https://leetcode.com/problems/valid-anagram/description/)
+[Leetcode : 242. Valid Anagram (Easy)](https://leetcode.com/problems/valid-anagram/description/)
```html
-s = "anagram", t = "nagaram", return true.
-s = "rat", t = "car", return false.
+s = "anagram", t = "nagaram", return true.
+s = "rat", t = "car", return false.
```
-字符串只包含小写字符，总共有 26 个小写字符。可以用 Hash Table 来映射字符与出现次数，因为键值范围很小，因此可以使用长度为 26 的整型数组对字符串出现的字符进行统计，比较两个字符串出现的字符数量是否相同。
+字符串只包含小写字符，总共有 26 个小写字符。可以用 Hash Table 来映射字符与出现次数，因为键值范围很小，因此可以使用长度为 26 的整型数组对字符串出现的字符进行统计，比较两个字符串出现的字符数量是否相同。
```java
-public boolean isAnagram(String s, String t) {
- int[] cnts = new int[26];
- for(int i = 0; i < s.length(); i++) cnts[s.charAt(i) - 'a'] ++;
- for(int i = 0; i < t.length(); i++) cnts[t.charAt(i) - 'a'] --;
- for(int i = 0; i < 26; i++) if(cnts[i] != 0) return false;
- return true;
+public boolean isAnagram(String s, String t) {
+ int[] cnts = new int[26];
+ for(int i = 0; i < s.length(); i++) cnts[s.charAt(i) - 'a'] ++;
+ for(int i = 0; i < t.length(); i++) cnts[t.charAt(i) - 'a'] --;
+ for(int i = 0; i < 26; i++) if(cnts[i] != 0) return false;
+ return true;
}
```
-**字符串同构**
+**字符串同构**
-[Leetcode : 205. Isomorphic Strings (Easy)](https://leetcode.com/problems/isomorphic-strings/description/)
+[Leetcode : 205. Isomorphic Strings (Easy)](https://leetcode.com/problems/isomorphic-strings/description/)
```html
-Given "egg", "add", return true.
-Given "foo", "bar", return false.
-Given "paper", "title", return true.
+Given "egg", "add", return true.
+Given "foo", "bar", return false.
+Given "paper", "title", return true.
```
记录一个字符上次出现的位置，如果两个字符串中某个字符上次出现的位置一样，那么就属于同构。
```java
-public boolean isIsomorphic(String s, String t) {
- int[] m1 = new int[256];
- int[] m2 = new int[256];
- for(int i = 0; i < s.length(); i++){
- if(m1[s.charAt(i)] != m2[t.charAt(i)]) {
- return false;
- }
- m1[s.charAt(i)] = i + 1;
- m2[t.charAt(i)] = i + 1;
- }
- return true;
+public boolean isIsomorphic(String s, String t) {
+ int[] m1 = new int[256];
+ int[] m2 = new int[256];
+ for(int i = 0; i < s.length(); i++){
+ if(m1[s.charAt(i)] != m2[t.charAt(i)]) {
+ return false;
+ }
+ m1[s.charAt(i)] = i + 1;
+ m2[t.charAt(i)] = i + 1;
+ }
+ return true;
}
```
-**计算一组字符集合可以组成的回文字符串的最大长度**
+**计算一组字符集合可以组成的回文字符串的最大长度**
-[Leetcode : 409. Longest Palindrome (Easy)](https://leetcode.com/problems/longest-palindrome/description/)
+[Leetcode : 409. Longest Palindrome (Easy)](https://leetcode.com/problems/longest-palindrome/description/)
```html
-Input : "abccccdd"
-Output : 7
-Explanation : One longest palindrome that can be built is "dccaccd", whose length is 7.
+Input : "abccccdd"
+Output : 7
+Explanation : One longest palindrome that can be built is "dccaccd", whose length is 7.
```
-使用长度为 128 的整型数组来统计每个字符出现的个数，每个字符有偶数个可以用来构成回文字符串。因为回文字符串最中间的那个字符可以单独出现，所以如果有单独的字符就把它放到最中间。
+使用长度为 128 的整型数组来统计每个字符出现的个数，每个字符有偶数个可以用来构成回文字符串。因为回文字符串最中间的那个字符可以单独出现，所以如果有单独的字符就把它放到最中间。
```java
-public int longestPalindrome(String s) {
- int[] cnts = new int[128]; // ascii 码总共 128 个
- for(char c : s.toCharArray()) cnts[c]++;
- int ret = 0;
- for(int cnt : cnts) ret += (cnt / 2) * 2;
- if(ret < s.length()) ret++; // 这个条件下 s 中一定有单个未使用的字符存在，可以把这个字符放到回文的最中间
- return ret;
+public int longestPalindrome(String s) {
+ int[] cnts = new int[128]; // ascii 码总共 128 个
+ for(char c : s.toCharArray()) cnts[c]++;
+ int ret = 0;
+ for(int cnt : cnts) ret += (cnt / 2) * 2;
+ if(ret < s.length()) ret++; // 这个条件下 s 中一定有单个未使用的字符存在，可以把这个字符放到回文的最中间
+ return ret;
}
```
-**判断一个整数是否是回文数**
+**判断一个整数是否是回文数**
-[Leetcode : 9. Palindrome Number (Easy)](https://leetcode.com/problems/palindrome-number/description/)
+[Leetcode : 9. Palindrome Number (Easy)](https://leetcode.com/problems/palindrome-number/description/)
要求不能使用额外空间，也就不能将整数转换为字符串进行判断。
将整数分成左右两部分，右边那部分需要转置，然后判断这两部分是否相等。
```java
-public boolean isPalindrome(int x) {
- if(x == 0) return true;
- if(x < 0) return false;
- if(x % 10 == 0) return false;
- int right = 0;
- while(x > right){
- right = right * 10 + x % 10;
- x /= 10;
- }
- return x == right || x == right / 10;
+public boolean isPalindrome(int x) {
+ if(x == 0) return true;
+ if(x < 0) return false;
+ if(x % 10 == 0) return false;
+ int right = 0;
+ while(x > right){
+ right = right * 10 + x % 10;
+ x /= 10;
+ }
+ return x == right || x == right / 10;
}
```
-**回文子字符串**
+**回文子字符串**
-[Leetcode : 647. Palindromic Substrings (Medium)](https://leetcode.com/problems/palindromic-substrings/description/)
+[Leetcode : 647. Palindromic Substrings (Medium)](https://leetcode.com/problems/palindromic-substrings/description/)
```html
-Input: "aaa"
-Output: 6
-Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".
+Input: "aaa"
+Output: 6
+Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".
```
解决方案是从字符串的某一位开始，尝试着去扩展子字符串。
```java
-private int cnt = 0;
-public int countSubstrings(String s) {
- for(int i = 0; i < s.length(); i++) {
- extendSubstrings(s, i, i); // 奇数长度
- extendSubstrings(s, i, i + 1); // 偶数长度
- }
- return cnt;
+private int cnt = 0;
+public int countSubstrings(String s) {
+ for(int i = 0; i < s.length(); i++) {
+ extendSubstrings(s, i, i); // 奇数长度
+ extendSubstrings(s, i, i + 1); // 偶数长度
+ }
+ return cnt;
}
-private void extendSubstrings(String s, int start, int end) {
- while(start >= 0 && end < s.length() && s.charAt(start) == s.charAt(end)) {
- start--;
- end++;
- cnt++;
- }
+private void extendSubstrings(String s, int start, int end) {
+ while(start >= 0 && end < s.length() && s.charAt(start) == s.charAt(end)) {
+ start--;
+ end++;
+ cnt++;
+ }
}
```
-**统计二进制字符串中连续 1 和连续 0 数量相同的子字符串个数**
+**统计二进制字符串中连续 1 和连续 0 数量相同的子字符串个数**
-[Leetcode : 696. Count Binary Substrings (Easy)](https://leetcode.com/problems/count-binary-substrings/description/)
+[Leetcode : 696. Count Binary Substrings (Easy)](https://leetcode.com/problems/count-binary-substrings/description/)
```html
-Input: "00110011"
-Output: 6
-Explanation: There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".
+Input: "00110011"
+Output: 6
+Explanation: There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".
```
```java
-public int countBinarySubstrings(String s) {
- int preLen = 0, curLen = 1, ret = 0;
- for(int i = 1; i < s.length(); i++){
- if(s.charAt(i) == s.charAt(i-1)) curLen++;
- else{
- preLen = curLen;
- curLen = 1;
- }
+public int countBinarySubstrings(String s) {
+ int preLen = 0, curLen = 1, ret = 0;
+ for(int i = 1; i < s.length(); i++){
+ if(s.charAt(i) == s.charAt(i-1)) curLen++;
+ else{
+ preLen = curLen;
+ curLen = 1;
+ }
- if(preLen >= curLen) ret++;
- }
- return ret;
+ if(preLen >= curLen) ret++;
+ }
+ return ret;
}
```
-**字符串循环移位包含**
+**字符串循环移位包含**
-[ 编程之美：3.1](#)
+[ 编程之美：3.1](#)
```html
-s1 = AABCD, s2 = CDAA
-Return : true
+s1 = AABCD, s2 = CDAA
+Return : true
```
-给定两个字符串 s1 和 s2 ，要求判定 s2 是否能够被 s1 做循环移位得到的字符串包含。
+给定两个字符串 s1 和 s2 ，要求判定 s2 是否能够被 s1 做循环移位得到的字符串包含。
-s1 进行循环移位的结果是 s1s1 的子字符串，因此只要判断 s2 是否是 s1s1 的子字符串即可。
+s1 进行循环移位的结果是 s1s1 的子字符串，因此只要判断 s2 是否是 s1s1 的子字符串即可。
-**字符串循环移位**
+**字符串循环移位**
-[ 编程之美：2.17](#)
+[ 编程之美：2.17](#)
-将字符串向右循环移动 k 位。
+将字符串向右循环移动 k 位。
-例如 abcd123 向右移动 3 位 得到 123abcd
+例如 abcd123 向右移动 3 位 得到 123abcd
-将 abcd123 中的 abcd 和 123 单独逆序，得到 dcba321，然后对整个字符串进行逆序，得到 123abcd。
+将 abcd123 中的 abcd 和 123 单独逆序，得到 dcba321，然后对整个字符串进行逆序，得到 123abcd。
-**字符串中单词的翻转**
+**字符串中单词的翻转**
[程序员代码面试指南](#)
-例如将 "I am a student" 翻转成 "student a am I"
+例如将 "I am a student" 翻转成 "student a am I"
将每个单词逆序，然后将整个字符串逆序。
-## 数组与矩阵
+## 数组与矩阵
-**把数组中的 0 移到末尾**
+**把数组中的 0 移到末尾**
-[Leetcode : 283. Move Zeroes (Easy)](https://leetcode.com/problems/move-zeroes/description/)
+[Leetcode : 283. Move Zeroes (Easy)](https://leetcode.com/problems/move-zeroes/description/)
```html
-For example, given nums = [0, 1, 0, 3, 12], after calling your function, nums should be [1, 3, 12, 0, 0].
+For example, given nums = [0, 1, 0, 3, 12], after calling your function, nums should be [1, 3, 12, 0, 0].
```
```java
-public void moveZeroes(int[] nums) {
- int n = nums.length;
- int idx = 0;
- for(int i = 0; i < n; i++){
- if(nums[i] != 0) nums[idx++] = nums[i];
- }
- while(idx < n){
- nums[idx++] = 0;
- }
+public void moveZeroes(int[] nums) {
+ int n = nums.length;
+ int idx = 0;
+ for(int i = 0; i < n; i++){
+ if(nums[i] != 0) nums[idx++] = nums[i];
+ }
+ while(idx < n){
+ nums[idx++] = 0;
+ }
}
```
-### 1-n 分布
+### 1-n 分布
-**一个数组元素在 [1, n] 之间，其中一个数被替换为另一个数，找出丢失的数和重复的数**
+**一个数组元素在 [1, n] 之间，其中一个数被替换为另一个数，找出丢失的数和重复的数**
-[Leetcode : 645. Set Mismatch (Easy)](https://leetcode.com/problems/set-mismatch/description/)
+[Leetcode : 645. Set Mismatch (Easy)](https://leetcode.com/problems/set-mismatch/description/)
```html
-Input: nums = [1,2,2,4]
-Output: [2,3]
+Input: nums = [1,2,2,4]
+Output: [2,3]
```
-最直接的方法是先对数组进行排序，这种方法时间复杂度为 O(nlogn).本题可以以 O(n) 的时间复杂度、O(1) 空间复杂度来求解。
+最直接的方法是先对数组进行排序，这种方法时间复杂度为 O(nlogn).本题可以以 O(n) 的时间复杂度、O(1) 空间复杂度来求解。
主要思想是让通过交换数组元素，使得数组上的元素在正确的位置上
-遍历数组，如果第 i 位上的元素不是 i + 1 ，那么就交换第 i 位 和 nums[i] - 1 位上的元素，使得 num[i] - 1 的元素为 nums[i] ，也就是该位的元素是正确的。交换操作需要循环进行，因为一次交换没办法使得第 i 位上的元素是正确的。但是要交换的两个元素可能就是重复元素，那么循环就可能永远进行下去，终止循环的方法是加上 nums[i] != nums[nums[i] - 1 条件。
+遍历数组，如果第 i 位上的元素不是 i + 1 ，那么就交换第 i 位 和 nums[i] - 1 位上的元素，使得 num[i] - 1 的元素为 nums[i] ，也就是该位的元素是正确的。交换操作需要循环进行，因为一次交换没办法使得第 i 位上的元素是正确的。但是要交换的两个元素可能就是重复元素，那么循环就可能永远进行下去，终止循环的方法是加上 nums[i] != nums[nums[i] - 1 条件。
类似题目：
-- [Leetcode :448. Find All Numbers Disappeared in an Array (Easy)](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/description/)，寻找所有丢失的元素
-- [Leetcode : 442. Find All Duplicates in an Array (Medium)](https://leetcode.com/problems/find-all-duplicates-in-an-array/description/)，寻找所有重复的元素。
+- [Leetcode :448. Find All Numbers Disappeared in an Array (Easy)](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/description/)，寻找所有丢失的元素
+- [Leetcode : 442. Find All Duplicates in an Array (Medium)](https://leetcode.com/problems/find-all-duplicates-in-an-array/description/)，寻找所有重复的元素。
```java
-public int[] findErrorNums(int[] nums) {
- for(int i = 0; i < nums.length; i++){
- while(nums[i] != i + 1 && nums[i] != nums[nums[i] - 1]) {
- swap(nums, i, nums[i] - 1);
- }
- }
+public int[] findErrorNums(int[] nums) {
+ for(int i = 0; i < nums.length; i++){
+ while(nums[i] != i + 1 && nums[i] != nums[nums[i] - 1]) {
+ swap(nums, i, nums[i] - 1);
+ }
+ }
- for(int i = 0; i < nums.length; i++){
- if(i + 1 != nums[i]) {
- return new int[]{nums[i], i + 1};
- }
- }
+ for(int i = 0; i < nums.length; i++){
+ if(i + 1 != nums[i]) {
+ return new int[]{nums[i], i + 1};
+ }
+ }
- return null;
+ return null;
}
-private void swap(int[] nums, int i, int j){
- int tmp = nums[i];
- nums[i] = nums[j];
- nums[j] = tmp;
+private void swap(int[] nums, int i, int j){
+ int tmp = nums[i];
+ nums[i] = nums[j];
+ nums[j] = tmp;
}
```
-**找出数组中重复的数，数组值在 [0, n-1] 之间**
+**找出数组中重复的数，数组值在 [0, n-1] 之间**
-[Leetcode : 287. Find the Duplicate Number (Medium)](https://leetcode.com/problems/find-the-duplicate-number/description/)
+[Leetcode : 287. Find the Duplicate Number (Medium)](https://leetcode.com/problems/find-the-duplicate-number/description/)
二分查找解法：
```java
-public int findDuplicate(int[] nums) {
- int l = 1, h = nums.length - 1;
- while (l <= h) {
- int mid = l + (h - l) / 2;
- int cnt = 0;
- for (int i = 0; i < nums.length; i++) {
- if (nums[i] <= mid) cnt++;
- }
- if (cnt > mid) h = mid - 1;
- else l = mid + 1;
- }
- return l;
+public int findDuplicate(int[] nums) {
+ int l = 1, h = nums.length - 1;
+ while (l <= h) {
+ int mid = l + (h - l) / 2;
+ int cnt = 0;
+ for (int i = 0; i < nums.length; i++) {
+ if (nums[i] <= mid) cnt++;
+ }
+ if (cnt > mid) h = mid - 1;
+ else l = mid + 1;
+ }
+ return l;
}
```
双指针解法，类似于有环链表中找出环的入口：
```java
-public int findDuplicate(int[] nums) {
- int slow = nums[0], fast = nums[nums[0]];
- while (slow != fast) {
- slow = nums[slow];
- fast = nums[nums[fast]];
- }
+public int findDuplicate(int[] nums) {
+ int slow = nums[0], fast = nums[nums[0]];
+ while (slow != fast) {
+ slow = nums[slow];
+ fast = nums[nums[fast]];
+ }
- fast = 0;
- while (slow != fast) {
- slow = nums[slow];
- fast = nums[fast];
- }
- return slow;
+ fast = 0;
+ while (slow != fast) {
+ slow = nums[slow];
+ fast = nums[fast];
+ }
+ return slow;
}
```
-### 有序矩阵
+### 有序矩阵
有序矩阵指的是行和列分别有序的矩阵。一般可以利用有序性使用二分查找方法。
```html
[
- [ 1, 5, 9],
- [10, 11, 13],
- [12, 13, 15]
+ [ 1, 5, 9],
+ [10, 11, 13],
+ [12, 13, 15]
]
```
-**有序矩阵查找**
+**有序矩阵查找**
-[Leetocde : 240. Search a 2D Matrix II (Medium)](https://leetcode.com/problems/search-a-2d-matrix-ii/description/)
+[Leetocde : 240. Search a 2D Matrix II (Medium)](https://leetcode.com/problems/search-a-2d-matrix-ii/description/)
```java
-public boolean searchMatrix(int[][] matrix, int target) {
- if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return false;
- int m = matrix.length, n = matrix[0].length;
- int row = 0, col = n - 1;
- while (row < m && col >= 0) {
- if (target == matrix[row][col]) return true;
- else if (target < matrix[row][col]) col--;
- else row++;
- }
- return false;
+public boolean searchMatrix(int[][] matrix, int target) {
+ if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return false;
+ int m = matrix.length, n = matrix[0].length;
+ int row = 0, col = n - 1;
+ while (row < m && col >= 0) {
+ if (target == matrix[row][col]) return true;
+ else if (target < matrix[row][col]) col--;
+ else row++;
+ }
+ return false;
}
```
-**有序矩阵的 Kth Element**
+**有序矩阵的 Kth Element**
-[Leetcode : 378. Kth Smallest Element in a Sorted Matrix ((Medium))](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/description/)
+[Leetcode : 378. Kth Smallest Element in a Sorted Matrix ((Medium))](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/description/)
```html
-matrix = [
- [ 1, 5, 9],
- [10, 11, 13],
- [12, 13, 15]
+matrix = [
+ [ 1, 5, 9],
+ [10, 11, 13],
+ [12, 13, 15]
],
-k = 8,
+k = 8,
-return 13.
+return 13.
```
-解题参考：[Share my thoughts and Clean Java Code](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/discuss/85173)
+解题参考：[Share my thoughts and Clean Java Code](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/discuss/85173)
二分查找解法：
```java
-public int kthSmallest(int[][] matrix, int k) {
- int m = matrix.length, n = matrix[0].length;
- int lo = matrix[0][0], hi = matrix[m - 1][n - 1];
- while(lo <= hi) {
- int mid = lo + (hi - lo) / 2;
- int cnt = 0;
- for(int i = 0; i < m; i++) {
- for(int j = 0; j < n && matrix[i][j] <= mid; j++) {
- cnt++;
- }
- }
- if(cnt < k) lo = mid + 1;
- else hi = mid - 1;
- }
- return lo;
+public int kthSmallest(int[][] matrix, int k) {
+ int m = matrix.length, n = matrix[0].length;
+ int lo = matrix[0][0], hi = matrix[m - 1][n - 1];
+ while(lo <= hi) {
+ int mid = lo + (hi - lo) / 2;
+ int cnt = 0;
+ for(int i = 0; i < m; i++) {
+ for(int j = 0; j < n && matrix[i][j] <= mid; j++) {
+ cnt++;
+ }
+ }
+ if(cnt < k) lo = mid + 1;
+ else hi = mid - 1;
+ }
+ return lo;
}
```
堆解法：
```java
-public int kthSmallest(int[][] matrix, int k) {
- int m = matrix.length, n = matrix[0].length;
- PriorityQueue pq = new PriorityQueue();
- for(int j = 0; j < n; j++) pq.offer(new Tuple(0, j, matrix[0][j]));
- for(int i = 0; i < k - 1; i++) { // 小根堆，去掉 k - 1 个堆顶元素，此时堆顶元素就是第 k 的数
- Tuple t = pq.poll();
- if(t.x == m - 1) continue;
- pq.offer(new Tuple(t.x + 1, t.y, matrix[t.x + 1][t.y]));
- }
- return pq.poll().val;
+public int kthSmallest(int[][] matrix, int k) {
+ int m = matrix.length, n = matrix[0].length;
+ PriorityQueue pq = new PriorityQueue();
+ for(int j = 0; j < n; j++) pq.offer(new Tuple(0, j, matrix[0][j]));
+ for(int i = 0; i < k - 1; i++) { // 小根堆，去掉 k - 1 个堆顶元素，此时堆顶元素就是第 k 的数
+ Tuple t = pq.poll();
+ if(t.x == m - 1) continue;
+ pq.offer(new Tuple(t.x + 1, t.y, matrix[t.x + 1][t.y]));
+ }
+ return pq.poll().val;
}
-class Tuple implements Comparable {
- int x, y, val;
- public Tuple(int x, int y, int val) {
- this.x = x; this.y = y; this.val = val;
- }
+class Tuple implements Comparable {
+ int x, y, val;
+ public Tuple(int x, int y, int val) {
+ this.x = x; this.y = y; this.val = val;
+ }
- @Override
- public int compareTo(Tuple that) {
- return this.val - that.val;
- }
+ @Override
+ public int compareTo(Tuple that) {
+ return this.val - that.val;
+ }
}
```
-## 链表
+## 链表
-**判断两个链表的交点**
+**判断两个链表的交点**
-[Leetcode : 160. Intersection of Two Linked Lists (Easy)](https://leetcode.com/problems/intersection-of-two-linked-lists/description/)
+[Leetcode : 160. Intersection of Two Linked Lists (Easy)](https://leetcode.com/problems/intersection-of-two-linked-lists/description/)
```html
-A: a1 → a2
- ↘
- c1 → c2 → c3
- ↗
-B: b1 → b2 → b3
+A: a1 → a2
+ ↘
+ c1 → c2 → c3
+ ↗
+B: b1 → b2 → b3
```
-要求：时间复杂度为 O(n) 空间复杂度为 O(1)
+要求：时间复杂度为 O(n) 空间复杂度为 O(1)
-设 A 的长度为 a + c，B 的长度为 b + c，其中 c 为尾部公共部分长度，可知 a + c + b = b + c + a。
+设 A 的长度为 a + c，B 的长度为 b + c，其中 c 为尾部公共部分长度，可知 a + c + b = b + c + a。
-当访问 A 链表的指针访问到链表尾部时，令它从链表 B 的头部开始访问链表 B；同样地，当访问 B 链表的指针访问到链表尾部时，令它从链表 A 的头部开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。
+当访问 A 链表的指针访问到链表尾部时，令它从链表 B 的头部开始访问链表 B；同样地，当访问 B 链表的指针访问到链表尾部时，令它从链表 A 的头部开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。
```java
-public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
- if(headA == null || headB == null) return null;
- ListNode l1 = headA, l2 = headB;
- while(l1 != l2){
- l1 = (l1 == null) ? headB : l1.next;
- l2 = (l2 == null) ? headA : l2.next;
- }
- return l1;
+public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
+ if(headA == null || headB == null) return null;
+ ListNode l1 = headA, l2 = headB;
+ while(l1 != l2){
+ l1 = (l1 == null) ? headB : l1.next;
+ l2 = (l2 == null) ? headA : l2.next;
+ }
+ return l1;
}
```
-如果只是判断是否存在交点，那么就是另一个问题，即 [编程之美：3.6]() 的问题。有两种解法：把第一个链表的结尾连接到第二个链表的开头，看第二个链表是否存在环；或者直接比较第一个链表最后一个节点和第二个链表最后一个节点是否相同。
+如果只是判断是否存在交点，那么就是另一个问题，即 [编程之美：3.6]() 的问题。有两种解法：把第一个链表的结尾连接到第二个链表的开头，看第二个链表是否存在环；或者直接比较第一个链表最后一个节点和第二个链表最后一个节点是否相同。
-**链表反转**
+**链表反转**
-[Leetcode : 206. Reverse Linked List (Easy)](https://leetcode.com/problems/reverse-linked-list/description/)
+[Leetcode : 206. Reverse Linked List (Easy)](https://leetcode.com/problems/reverse-linked-list/description/)
头插法能够按逆序构建链表。
```java
-public ListNode reverseList(ListNode head) {
- ListNode newHead = null; // 设为 null，作为新链表的结尾
- while(head != null){
- ListNode nextNode = head.next;
- head.next = newHead;
- newHead = head;
- head = nextNode;
- }
- return newHead;
+public ListNode reverseList(ListNode head) {
+ ListNode newHead = null; // 设为 null，作为新链表的结尾
+ while(head != null){
+ ListNode nextNode = head.next;
+ head.next = newHead;
+ newHead = head;
+ head = nextNode;
+ }
+ return newHead;
}
```
-**归并两个有序的链表**
+**归并两个有序的链表**
-[Leetcode : 21. Merge Two Sorted Lists (Easy)](https://leetcode.com/problems/merge-two-sorted-lists/description/)
+[Leetcode : 21. Merge Two Sorted Lists (Easy)](https://leetcode.com/problems/merge-two-sorted-lists/description/)
链表和树一样，可以用递归方式来定义：链表是空节点，或者有一个值和一个指向下一个链表的指针。因此很多链表问题可以用递归来处理。
```java
-public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
- if(l1 == null) return l2;
- if(l2 == null) return l1;
- ListNode newHead = null;
- if(l1.val < l2.val){
- newHead = l1;
- newHead.next = mergeTwoLists(l1.next, l2);
- } else{
- newHead = l2;
- newHead.next = mergeTwoLists(l1, l2.next);
- }
- return newHead;
+public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+ if(l1 == null) return l2;
+ if(l2 == null) return l1;
+ ListNode newHead = null;
+ if(l1.val < l2.val){
+ newHead = l1;
+ newHead.next = mergeTwoLists(l1.next, l2);
+ } else{
+ newHead = l2;
+ newHead.next = mergeTwoLists(l1, l2.next);
+ }
+ return newHead;
}
```
-**从有序链表中删除重复节点**
+**从有序链表中删除重复节点**
-[Leetcode : 83. Remove Duplicates from Sorted List (Easy)](https://leetcode.com/problems/remove-duplicates-from-sorted-list/description/)
+[Leetcode : 83. Remove Duplicates from Sorted List (Easy)](https://leetcode.com/problems/remove-duplicates-from-sorted-list/description/)
```java
-public ListNode deleteDuplicates(ListNode head) {
- if(head == null || head.next == null) return head;
- head.next = deleteDuplicates(head.next);
- return head.next != null && head.val == head.next.val ? head.next : head;
+public ListNode deleteDuplicates(ListNode head) {
+ if(head == null || head.next == null) return head;
+ head.next = deleteDuplicates(head.next);
+ return head.next != null && head.val == head.next.val ? head.next : head;
}
```
-**回文链表**
+**回文链表**
-[Leetcode : 234. Palindrome Linked List (Easy)](https://leetcode.com/problems/palindrome-linked-list/description/)
+[Leetcode : 234. Palindrome Linked List (Easy)](https://leetcode.com/problems/palindrome-linked-list/description/)
切成两半，把后半段反转，然后比较两半是否相等。
```java
-public boolean isPalindrome(ListNode head) {
- if(head == null || head.next == null) return true;
- ListNode slow = head, fast = head.next;
- while(fast != null && fast.next != null){
- slow = slow.next;
- fast = fast.next.next;
- }
+public boolean isPalindrome(ListNode head) {
+ if(head == null || head.next == null) return true;
+ ListNode slow = head, fast = head.next;
+ while(fast != null && fast.next != null){
+ slow = slow.next;
+ fast = fast.next.next;
+ }
- if(fast != null){ // 偶数节点，让 slow 指向下一个节点
- slow = slow.next;
- }
+ if(fast != null){ // 偶数节点，让 slow 指向下一个节点
+ slow = slow.next;
+ }
- cut(head, slow); // 切成两个链表
- ListNode l1 = head, l2 = slow;
- l2 = reverse(l2);
- return isEqual(l1, l2);
+ cut(head, slow); // 切成两个链表
+ ListNode l1 = head, l2 = slow;
+ l2 = reverse(l2);
+ return isEqual(l1, l2);
}
-private void cut(ListNode head, ListNode cutNode){
- while( head.next != cutNode ) head = head.next;
- head.next = null;
+private void cut(ListNode head, ListNode cutNode){
+ while( head.next != cutNode ) head = head.next;
+ head.next = null;
}
-private ListNode reverse(ListNode head){
- ListNode newHead = null;
- while(head != null){
- ListNode nextNode = head.next;
- head.next = newHead;
- newHead = head;
- head = nextNode;
- }
- return newHead;
+private ListNode reverse(ListNode head){
+ ListNode newHead = null;
+ while(head != null){
+ ListNode nextNode = head.next;
+ head.next = newHead;
+ newHead = head;
+ head = nextNode;
+ }
+ return newHead;
}
-private boolean isEqual(ListNode l1, ListNode l2){
- while(l1 != null && l2 != null){
- if(l1.val != l2.val) return false;
- l1 = l1.next;
- l2 = l2.next;
- }
- return true;
+private boolean isEqual(ListNode l1, ListNode l2){
+ while(l1 != null && l2 != null){
+ if(l1.val != l2.val) return false;
+ l1 = l1.next;
+ l2 = l2.next;
+ }
+ return true;
}
```
-**链表元素按奇偶聚集**
+**链表元素按奇偶聚集**
-[Leetcode : 328. Odd Even Linked List (Medium)](https://leetcode.com/problems/odd-even-linked-list/description/)
+[Leetcode : 328. Odd Even Linked List (Medium)](https://leetcode.com/problems/odd-even-linked-list/description/)
```html
Example:
-Given 1->2->3->4->5->NULL,
-return 1->3->5->2->4->NULL.
+Given 1->2->3->4->5->NULL,
+return 1->3->5->2->4->NULL.
```
```java
-public ListNode oddEvenList(ListNode head) {
- if (head == null) {
- return head;
- }
- ListNode odd = head, even = head.next, evenHead = even;
- while (even != null && even.next != null) {
- odd.next = odd.next.next;
- odd = odd.next;
- even.next = even.next.next;
- even = even.next;
- }
- odd.next = evenHead;
- return head;
+public ListNode oddEvenList(ListNode head) {
+ if (head == null) {
+ return head;
+ }
+ ListNode odd = head, even = head.next, evenHead = even;
+ while (even != null && even.next != null) {
+ odd.next = odd.next.next;
+ odd = odd.next;
+ even.next = even.next.next;
+ even = even.next;
+ }
+ odd.next = evenHead;
+ return head;
}
```
-## 树
+## 树
-### 递归
+### 递归
一棵树要么是空树，要么有两个指针，每个指针指向一棵树。树是一种递归结构，很多树的问题可以使用递归来处理。
-**树的高度**
+**树的高度**
-[Leetcode : 104. Maximum Depth of Binary Tree (Easy)](https://leetcode.com/problems/maximum-depth-of-binary-tree/description/)
+[Leetcode : 104. Maximum Depth of Binary Tree (Easy)](https://leetcode.com/problems/maximum-depth-of-binary-tree/description/)
```java
-public int maxDepth(TreeNode root) {
- if(root == null) return 0;
- return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
+public int maxDepth(TreeNode root) {
+ if(root == null) return 0;
+ return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
}
```
-**翻转树**
+**翻转树**
-[Leetcode : 226. Invert Binary Tree (Easy)](https://leetcode.com/problems/invert-binary-tree/description/)
+[Leetcode : 226. Invert Binary Tree (Easy)](https://leetcode.com/problems/invert-binary-tree/description/)
```java
-public TreeNode invertTree(TreeNode root) {
- if(root == null) return null;
- TreeNode left = root.left; // 后面的操作会改变 left 指针，因此先保存下来
- root.left = invertTree(root.right);
- root.right = invertTree(left);
- return root;
+public TreeNode invertTree(TreeNode root) {
+ if(root == null) return null;
+ TreeNode left = root.left; // 后面的操作会改变 left 指针，因此先保存下来
+ root.left = invertTree(root.right);
+ root.right = invertTree(left);
+ return root;
}
```
-**归并两棵树**
+**归并两棵树**
-[Leetcode : 617. Merge Two Binary Trees (Easy)](https://leetcode.com/problems/merge-two-binary-trees/description/)
+[Leetcode : 617. Merge Two Binary Trees (Easy)](https://leetcode.com/problems/merge-two-binary-trees/description/)
```html
Input:
- Tree 1 Tree 2
- 1 2
- / \ / \
- 3 2 1 3
- / \ \
- 5 4 7
+ Tree 1 Tree 2
+ 1 2
+ / \ / \
+ 3 2 1 3
+ / \ \
+ 5 4 7
Output:
-Merged tree:
- 3
- / \
- 4 5
- / \ \
- 5 4 7
+Merged tree:
+ 3
+ / \
+ 4 5
+ / \ \
+ 5 4 7
```
```java
-public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
- if(t1 == null && t2 == null) return null;
- if(t1 == null) return t2;
- if(t2 == null) return t1;
- TreeNode root = new TreeNode(t1.val + t2.val);
- root.left = mergeTrees(t1.left, t2.left);
- root.right = mergeTrees(t1.right, t2.right);
- return root;
+public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
+ if(t1 == null && t2 == null) return null;
+ if(t1 == null) return t2;
+ if(t2 == null) return t1;
+ TreeNode root = new TreeNode(t1.val + t2.val);
+ root.left = mergeTrees(t1.left, t2.left);
+ root.right = mergeTrees(t1.right, t2.right);
+ return root;
}
```
-**判断路径和是否等于一个数**
+**判断路径和是否等于一个数**
-[Leetcdoe : 112. Path Sum (Easy)](https://leetcode.com/problems/path-sum/description/)
+[Leetcdoe : 112. Path Sum (Easy)](https://leetcode.com/problems/path-sum/description/)
```html
-Given the below binary tree and sum = 22,
- 5
- / \
- 4 8
- / / \
- 11 13 4
- / \ \
- 7 2 1
-return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.
+Given the below binary tree and sum = 22,
+ 5
+ / \
+ 4 8
+ / / \
+ 11 13 4
+ / \ \
+ 7 2 1
+return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.
```
-路径和定义为从 root 到 leaf 的所有节点的和
+路径和定义为从 root 到 leaf 的所有节点的和
```java
-public boolean hasPathSum(TreeNode root, int sum) {
- if(root == null) return false;
- if(root.left == null && root.right == null && root.val == sum) return true;
- return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
+public boolean hasPathSum(TreeNode root, int sum) {
+ if(root == null) return false;
+ if(root.left == null && root.right == null && root.val == sum) return true;
+ return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
}
```
-**统计路径和等于一个数的路径数量**
+**统计路径和等于一个数的路径数量**
-[Leetcode : 437. Path Sum III (Easy)](https://leetcode.com/problems/path-sum-iii/description/)
+[Leetcode : 437. Path Sum III (Easy)](https://leetcode.com/problems/path-sum-iii/description/)
```html
-root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
+root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
- 10
- / \
- 5 -3
- / \ \
- 3 2 11
- / \ \
-3 -2 1
+ 10
+ / \
+ 5 -3
+ / \ \
+ 3 2 11
+ / \ \
+3 -2 1
-Return 3. The paths that sum to 8 are:
+Return 3. The paths that sum to 8 are:
-1. 5 -> 3
-2. 5 -> 2 -> 1
-3. -3 -> 11
+1. 5 -> 3
+2. 5 -> 2 -> 1
+3. -3 -> 11
```
-路径不一定以 root 开头并以 leaf 结尾，但是必须连续
+路径不一定以 root 开头并以 leaf 结尾，但是必须连续
```java
-public int pathSum(TreeNode root, int sum) {
- if(root == null) return 0;
- int ret = pathSumStartWithRoot(root, sum) + pathSum(root.left, sum) + pathSum(root.right, sum);
- return ret;
+public int pathSum(TreeNode root, int sum) {
+ if(root == null) return 0;
+ int ret = pathSumStartWithRoot(root, sum) + pathSum(root.left, sum) + pathSum(root.right, sum);
+ return ret;
}
-private int pathSumStartWithRoot(TreeNode root, int sum){
- if(root == null) return 0;
- int ret = 0;
- if(root.val == sum) ret++;
- ret += pathSumStartWithRoot(root.left, sum - root.val) + pathSumStartWithRoot(root.right, sum - root.val);
- return ret;
+private int pathSumStartWithRoot(TreeNode root, int sum){
+ if(root == null) return 0;
+ int ret = 0;
+ if(root.val == sum) ret++;
+ ret += pathSumStartWithRoot(root.left, sum - root.val) + pathSumStartWithRoot(root.right, sum - root.val);
+ return ret;
}
```
-**树的对称**
+**树的对称**
-[Leetcode : 101. Symmetric Tree (Easy)](https://leetcode.com/problems/symmetric-tree/description/)
+[Leetcode : 101. Symmetric Tree (Easy)](https://leetcode.com/problems/symmetric-tree/description/)
```html
- 1
- / \
- 2 2
- / \ / \
-3 4 4 3
+ 1
+ / \
+ 2 2
+ / \ / \
+3 4 4 3
```
```java
-public boolean isSymmetric(TreeNode root) {
- if(root == null) return true;
- return isSymmetric(root.left, root.right);
+public boolean isSymmetric(TreeNode root) {
+ if(root == null) return true;
+ return isSymmetric(root.left, root.right);
}
-private boolean isSymmetric(TreeNode t1, TreeNode t2){
- if(t1 == null && t2 == null) return true;
- if(t1 == null || t2 == null) return false;
- if(t1.val != t2.val) return false;
- return isSymmetric(t1.left, t2.right) && isSymmetric(t1.right, t2.left);
+private boolean isSymmetric(TreeNode t1, TreeNode t2){
+ if(t1 == null && t2 == null) return true;
+ if(t1 == null || t2 == null) return false;
+ if(t1.val != t2.val) return false;
+ return isSymmetric(t1.left, t2.right) && isSymmetric(t1.right, t2.left);
}
```
-**平衡树**
+**平衡树**
-[Leetcode : 110. Balanced Binary Tree (Easy)](https://leetcode.com/problems/balanced-binary-tree/description/)
+[Leetcode : 110. Balanced Binary Tree (Easy)](https://leetcode.com/problems/balanced-binary-tree/description/)
```html
- 3
- / \
- 9 20
- / \
- 15 7
+ 3
+ / \
+ 9 20
+ / \
+ 15 7
```
-平衡树左右子树高度差都小于等于 1
+平衡树左右子树高度差都小于等于 1
```java
-private boolean result = true;
+private boolean result = true;
-public boolean isBalanced(TreeNode root) {
- maxDepth(root);
- return result;
+public boolean isBalanced(TreeNode root) {
+ maxDepth(root);
+ return result;
}
-public int maxDepth(TreeNode root) {
- if (root == null) return 0;
- int l = maxDepth(root.left);
- int r = maxDepth(root.right);
- if (Math.abs(l - r) > 1) result = false;
- return 1 + Math.max(l, r);
+public int maxDepth(TreeNode root) {
+ if (root == null) return 0;
+ int l = maxDepth(root.left);
+ int r = maxDepth(root.right);
+ if (Math.abs(l - r) > 1) result = false;
+ return 1 + Math.max(l, r);
}
```
-**最小路径**
+**最小路径**
-[Leetcode : 111. Minimum Depth of Binary Tree (Easy)](https://leetcode.com/problems/minimum-depth-of-binary-tree/description/)
+[Leetcode : 111. Minimum Depth of Binary Tree (Easy)](https://leetcode.com/problems/minimum-depth-of-binary-tree/description/)
树的根节点到叶子节点的最小路径长度
```java
-public int minDepth(TreeNode root) {
- if(root == null) return 0;
- int left = minDepth(root.left);
- int right = minDepth(root.right);
- if(left == 0 || right == 0) return left + right + 1;
- return Math.min(left, right) + 1;
+public int minDepth(TreeNode root) {
+ if(root == null) return 0;
+ int left = minDepth(root.left);
+ int right = minDepth(root.right);
+ if(left == 0 || right == 0) return left + right + 1;
+ return Math.min(left, right) + 1;
}
```
-**统计左叶子节点的和**
+**统计左叶子节点的和**
-[Leetcode : 404. Sum of Left Leaves (Easy)](https://leetcode.com/problems/sum-of-left-leaves/description/)
+[Leetcode : 404. Sum of Left Leaves (Easy)](https://leetcode.com/problems/sum-of-left-leaves/description/)
```html
- 3
- / \
- 9 20
- / \
- 15 7
+ 3
+ / \
+ 9 20
+ / \
+ 15 7
-There are two left leaves in the binary tree, with values 9 and 15 respectively. Return 24.
+There are two left leaves in the binary tree, with values 9 and 15 respectively. Return 24.
```
```java
-public int sumOfLeftLeaves(TreeNode root) {
- if(root == null) {
- return 0;
- }
- if(isLeaf(root.left)) {
- return root.left.val + sumOfLeftLeaves(root.right);
- }
- return sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right);
+public int sumOfLeftLeaves(TreeNode root) {
+ if(root == null) {
+ return 0;
+ }
+ if(isLeaf(root.left)) {
+ return root.left.val + sumOfLeftLeaves(root.right);
+ }
+ return sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right);
}
-private boolean isLeaf(TreeNode node){
- if(node == null) {
- return false;
- }
- return node.left == null && node.right == null;
+private boolean isLeaf(TreeNode node){
+ if(node == null) {
+ return false;
+ }
+ return node.left == null && node.right == null;
}
```
-**修剪二叉查找树**
+**修剪二叉查找树**
-[Leetcode : 669. Trim a Binary Search Tree (Easy)](https://leetcode.com/problems/trim-a-binary-search-tree/description/)
+[Leetcode : 669. Trim a Binary Search Tree (Easy)](https://leetcode.com/problems/trim-a-binary-search-tree/description/)
```html
-Input:
- 3
- / \
- 0 4
- \
- 2
- /
- 1
+Input:
+ 3
+ / \
+ 0 4
+ \
+ 2
+ /
+ 1
- L = 1
- R = 3
+ L = 1
+ R = 3
-Output:
- 3
- /
- 2
- /
- 1
+Output:
+ 3
+ /
+ 2
+ /
+ 1
```
二叉查找树（BST）：根节点大于等于左子树所有节点，小于等于右子树所有节点。
-只保留值在 L ~ R 之间的节点
+只保留值在 L \~ R 之间的节点
```java
-public TreeNode trimBST(TreeNode root, int L, int R) {
- if(root == null) return null;
- if(root.val > R) return trimBST(root.left, L, R);
- if(root.val < L) return trimBST(root.right, L, R);
- root.left = trimBST(root.left, L, R);
- root.right = trimBST(root.right, L, R);
- return root;
+public TreeNode trimBST(TreeNode root, int L, int R) {
+ if(root == null) return null;
+ if(root.val > R) return trimBST(root.left, L, R);
+ if(root.val < L) return trimBST(root.right, L, R);
+ root.left = trimBST(root.left, L, R);
+ root.right = trimBST(root.right, L, R);
+ return root;
}
```
-**子树**
+**子树**
-[Leetcode : 572. Subtree of Another Tree (Easy)](https://leetcode.com/problems/subtree-of-another-tree/description/)
+[Leetcode : 572. Subtree of Another Tree (Easy)](https://leetcode.com/problems/subtree-of-another-tree/description/)
```html
-Given tree s:
- 3
- / \
- 4 5
- / \
- 1 2
-Given tree t:
- 4
- / \
- 1 2
-Return true, because t has the same structure and node values with a subtree of s.
+Given tree s:
+ 3
+ / \
+ 4 5
+ / \
+ 1 2
+Given tree t:
+ 4
+ / \
+ 1 2
+Return true, because t has the same structure and node values with a subtree of s.
```
```java
-public boolean isSubtree(TreeNode s, TreeNode t) {
- if(s == null && t == null) return true;
- if(s == null || t == null) return false;
- if(s.val == t.val && isSame(s, t)) return true;
- return isSubtree(s.left, t) || isSubtree(s.right, t);
+public boolean isSubtree(TreeNode s, TreeNode t) {
+ if(s == null && t == null) return true;
+ if(s == null || t == null) return false;
+ if(s.val == t.val && isSame(s, t)) return true;
+ return isSubtree(s.left, t) || isSubtree(s.right, t);
}
-private boolean isSame(TreeNode s, TreeNode t){
- if(s == null && t == null) return true;
- if(s == null || t == null) return false;
- if(s.val != t.val) return false;
- return isSame(s.left, t.left) && isSame(s.right, t.right);
+private boolean isSame(TreeNode s, TreeNode t){
+ if(s == null && t == null) return true;
+ if(s == null || t == null) return false;
+ if(s.val != t.val) return false;
+ return isSame(s.left, t.left) && isSame(s.right, t.right);
}
```
-**从有序数组中构造二叉查找树**
+**从有序数组中构造二叉查找树**
-[Leetcode : 108. Convert Sorted Array to Binary Search Tree (Easy)](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/description/)
+[Leetcode : 108. Convert Sorted Array to Binary Search Tree (Easy)](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/description/)
```java
-public TreeNode sortedArrayToBST(int[] nums) {
- return toBST(nums, 0, nums.length - 1);
+public TreeNode sortedArrayToBST(int[] nums) {
+ return toBST(nums, 0, nums.length - 1);
}
-private TreeNode toBST(int[] nums, int sIdx, int eIdx){
- if(sIdx > eIdx) return null;
- int mIdx = (sIdx + eIdx) / 2;
- TreeNode root = new TreeNode(nums[mIdx]);
- root.left = toBST(nums, sIdx, mIdx - 1);
- root.right = toBST(nums, mIdx + 1, eIdx);
- return root;
+private TreeNode toBST(int[] nums, int sIdx, int eIdx){
+ if(sIdx > eIdx) return null;
+ int mIdx = (sIdx + eIdx) / 2;
+ TreeNode root = new TreeNode(nums[mIdx]);
+ root.left = toBST(nums, sIdx, mIdx - 1);
+ root.right = toBST(nums, mIdx + 1, eIdx);
+ return root;
}
```
-**两节点的最长路径**
+**两节点的最长路径**
```html
Input:
- 1
- / \
- 2 3
- / \
- 4 5
+ 1
+ / \
+ 2 3
+ / \
+ 4 5
-Return 3, which is the length of the path [4,2,1,3] or [5,2,1,3].
+Return 3, which is the length of the path [4,2,1,3] or [5,2,1,3].
```
-[Leetcode : 543. Diameter of Binary Tree (Easy)](https://leetcode.com/problems/diameter-of-binary-tree/description/)
+[Leetcode : 543. Diameter of Binary Tree (Easy)](https://leetcode.com/problems/diameter-of-binary-tree/description/)
```java
-private int max = 0;
+private int max = 0;
-public int diameterOfBinaryTree(TreeNode root) {
- depth(root);
- return max;
+public int diameterOfBinaryTree(TreeNode root) {
+ depth(root);
+ return max;
}
-private int depth(TreeNode root) {
- if (root == null) return 0;
- int leftDepth = depth(root.left);
- int rightDepth = depth(root.right);
- max = Math.max(max, leftDepth + rightDepth);
- return Math.max(leftDepth, rightDepth) + 1;
+private int depth(TreeNode root) {
+ if (root == null) return 0;
+ int leftDepth = depth(root.left);
+ int rightDepth = depth(root.right);
+ max = Math.max(max, leftDepth + rightDepth);
+ return Math.max(leftDepth, rightDepth) + 1;
}
```
-**找出二叉树中第二小的节点**
+**找出二叉树中第二小的节点**
-[Leetcode : 671. Second Minimum Node In a Binary Tree (Easy)](https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/description/)
+[Leetcode : 671. Second Minimum Node In a Binary Tree (Easy)](https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/description/)
```html
Input:
- 2
- / \
- 2 5
- / \
- 5 7
+ 2
+ / \
+ 2 5
+ / \
+ 5 7
-Output: 5
+Output: 5
```
-一个节点要么具有 0 个或 2 个子节点，如果有子节点，那么根节点是最小的节点。
+一个节点要么具有 0 个或 2 个子节点，如果有子节点，那么根节点是最小的节点。
```java
-public int findSecondMinimumValue(TreeNode root) {
- if(root == null) return -1;
- if(root.left == null && root.right == null) return -1;
- int leftVal = root.left.val;
- int rightVal = root.right.val;
- if(leftVal == root.val) leftVal = findSecondMinimumValue(root.left);
- if(rightVal == root.val) rightVal = findSecondMinimumValue(root.right);
- if(leftVal != -1 && rightVal != -1) return Math.min(leftVal, rightVal);
- if(leftVal != -1) return leftVal;
- return rightVal;
+public int findSecondMinimumValue(TreeNode root) {
+ if(root == null) return -1;
+ if(root.left == null && root.right == null) return -1;
+ int leftVal = root.left.val;
+ int rightVal = root.right.val;
+ if(leftVal == root.val) leftVal = findSecondMinimumValue(root.left);
+ if(rightVal == root.val) rightVal = findSecondMinimumValue(root.right);
+ if(leftVal != -1 && rightVal != -1) return Math.min(leftVal, rightVal);
+ if(leftVal != -1) return leftVal;
+ return rightVal;
}
```
-**二叉查找树的最近公共祖先**
+**二叉查找树的最近公共祖先**
-[Leetcode : 235. Lowest Common Ancestor of a Binary Search Tree (Easy)](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/)
+[Leetcode : 235. Lowest Common Ancestor of a Binary Search Tree (Easy)](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/)
```html
- _______6______
- / \
- ___2__ ___8__
- / \ / \
- 0 _4 7 9
- / \
- 3 5
-For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6. Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.
+ _______6______
+ / \
+ ___2__ ___8__
+ / \ / \
+ 0 _4 7 9
+ / \
+ 3 5
+For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6. Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.
```
```java
-public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
- if(root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q);
- if(root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q);
- return root;
+public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+ if(root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q);
+ if(root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q);
+ return root;
}
```
-**二叉树的最近公共祖先**
+**二叉树的最近公共祖先**
-[Leetcode : 236. Lowest Common Ancestor of a Binary Tree (Medium) ](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
+[Leetcode : 236. Lowest Common Ancestor of a Binary Tree (Medium) ](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
```html
- _______3______
- / \
- ___5__ ___1__
- / \ / \
- 6 _2 0 8
- / \
- 7 4
-For example, the lowest common ancestor (LCA) of nodes 5 and 1 is 3. Another example is LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.
+ _______3______
+ / \
+ ___5__ ___1__
+ / \ / \
+ 6 _2 0 8
+ / \
+ 7 4
+For example, the lowest common ancestor (LCA) of nodes 5 and 1 is 3. Another example is LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.
```
```java
-public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
- if (root == null || root == p || root == q) return root;
- TreeNode left = lowestCommonAncestor(root.left, p, q);
- TreeNode right = lowestCommonAncestor(root.right, p, q);
- return left == null ? right : right == null ? left : root;
+public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+ if (root == null || root == p || root == q) return root;
+ TreeNode left = lowestCommonAncestor(root.left, p, q);
+ TreeNode right = lowestCommonAncestor(root.right, p, q);
+ return left == null ? right : right == null ? left : root;
}
```
-**相同节点值的最大路径长度**
+**相同节点值的最大路径长度**
-[Leetcode : 687. Longest Univalue Path (Easy)](https://leetcode.com/problems/longest-univalue-path/)
+[Leetcode : 687. Longest Univalue Path (Easy)](https://leetcode.com/problems/longest-univalue-path/)
```html
- 1
- / \
- 4 5
- / \ \
- 4 4 5
+ 1
+ / \
+ 4 5
+ / \ \
+ 4 4 5
-Output : 2
+Output : 2
```
```java
-private int path = 0;
-public int longestUnivaluePath(TreeNode root) {
- dfs(root);
- return path;
+private int path = 0;
+public int longestUnivaluePath(TreeNode root) {
+ dfs(root);
+ return path;
}
-private int dfs(TreeNode root){
- if(root == null) return 0;
- int left = dfs(root.left);
- int right = dfs(root.right);
- int leftPath = root.left != null && root.left.val == root.val ? left + 1 : 0;
- int rightPath = root.right != null && root.right.val == root.val ? right + 1 : 0;
- path = Math.max(path, leftPath + rightPath);
- return Math.max(leftPath, rightPath);
+private int dfs(TreeNode root){
+ if(root == null) return 0;
+ int left = dfs(root.left);
+ int right = dfs(root.right);
+ int leftPath = root.left != null && root.left.val == root.val ? left + 1 : 0;
+ int rightPath = root.right != null && root.right.val == root.val ? right + 1 : 0;
+ path = Math.max(path, leftPath + rightPath);
+ return Math.max(leftPath, rightPath);
}
```
-**间隔遍历**
+**间隔遍历**
-[Leetcode : 337. House Robber III (Medium)](https://leetcode.com/problems/house-robber-iii/description/)
+[Leetcode : 337. House Robber III (Medium)](https://leetcode.com/problems/house-robber-iii/description/)
```html
- 3
- / \
- 2 3
- \ \
- 3 1
-Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.
+ 3
+ / \
+ 2 3
+ \ \
+ 3 1
+Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.
```
```java
-public int rob(TreeNode root) {
- if (root == null) return 0;
- int val1 = root.val;
- if (root.left != null) {
- val1 += rob(root.left.left) + rob(root.left.right);
- }
- if (root.right != null) {
- val1 += rob(root.right.left) + rob(root.right.right);
- }
- int val2 = rob(root.left) + rob(root.right);
- return Math.max(val1, val2);
+public int rob(TreeNode root) {
+ if (root == null) return 0;
+ int val1 = root.val;
+ if (root.left != null) {
+ val1 += rob(root.left.left) + rob(root.left.right);
+ }
+ if (root.right != null) {
+ val1 += rob(root.right.left) + rob(root.right.right);
+ }
+ int val2 = rob(root.left) + rob(root.right);
+ return Math.max(val1, val2);
}
```
-### 层次遍历
+### 层次遍历
-使用 BFS 进行层次遍历。不需要使用两个队列来分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。
+使用 BFS 进行层次遍历。不需要使用两个队列来分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。
-**一棵树每层节点的平均数**
+**一棵树每层节点的平均数**
-[637. Average of Levels in Binary Tree (Easy)](https://leetcode.com/problems/average-of-levels-in-binary-tree/description/)
+[637. Average of Levels in Binary Tree (Easy)](https://leetcode.com/problems/average-of-levels-in-binary-tree/description/)
```java
-public List averageOfLevels(TreeNode root) {
- List ret = new ArrayList<>();
- if(root == null) return ret;
- Queue queue = new LinkedList<>();
- queue.add(root);
- while(!queue.isEmpty()){
- int cnt = queue.size();
- double sum = 0;
- for(int i = 0; i < cnt; i++){
- TreeNode node = queue.poll();
- sum += node.val;
- if(node.left != null) queue.add(node.left);
- if(node.right != null) queue.add(node.right);
- }
- ret.add(sum / cnt);
- }
- return ret;
+public List averageOfLevels(TreeNode root) {
+ List ret = new ArrayList<>();
+ if(root == null) return ret;
+ Queue queue = new LinkedList<>();
+ queue.add(root);
+ while(!queue.isEmpty()){
+ int cnt = queue.size();
+ double sum = 0;
+ for(int i = 0; i < cnt; i++){
+ TreeNode node = queue.poll();
+ sum += node.val;
+ if(node.left != null) queue.add(node.left);
+ if(node.right != null) queue.add(node.right);
+ }
+ ret.add(sum / cnt);
+ }
+ return ret;
}
```
-**得到左下角的节点**
+**得到左下角的节点**
-[Leetcode : 513. Find Bottom Left Tree Value (Easy)](https://leetcode.com/problems/find-bottom-left-tree-value/description/)
+[Leetcode : 513. Find Bottom Left Tree Value (Easy)](https://leetcode.com/problems/find-bottom-left-tree-value/description/)
```html
Input:
- 1
- / \
- 2 3
- / / \
- 4 5 6
- /
- 7
+ 1
+ / \
+ 2 3
+ / / \
+ 4 5 6
+ /
+ 7
Output:
7
```
```java
-public int findBottomLeftValue(TreeNode root) {
- Queue queue = new LinkedList<>();
- queue.add(root);
- while(!queue.isEmpty()){
- root = queue.poll();
- if(root.right != null) queue.add(root.right);
- if(root.left != null) queue.add(root.left);
- }
- return root.val;
+public int findBottomLeftValue(TreeNode root) {
+ Queue queue = new LinkedList<>();
+ queue.add(root);
+ while(!queue.isEmpty()){
+ root = queue.poll();
+ if(root.right != null) queue.add(root.right);
+ if(root.left != null) queue.add(root.left);
+ }
+ return root.val;
}
```
-### 前中后序遍历
+### 前中后序遍历
```html
- 1
- / \
- 2 3
- / \ \
-4 5 6
+ 1
+ / \
+ 2 3
+ / \ \
+4 5 6
```
-层次遍历顺序：[1 2 3 4 5 6]
-前序遍历顺序：[1 2 4 5 3 6]
-中序遍历顺序：[4 2 5 1 3 6]
-后序遍历顺序：[4 5 2 6 3 1]
+层次遍历顺序：[1 2 3 4 5 6]
+前序遍历顺序：[1 2 4 5 3 6]
+中序遍历顺序：[4 2 5 1 3 6]
+后序遍历顺序：[4 5 2 6 3 1]
-层次遍历使用 BFS 实现，利用的就是 BFS 一层一层遍历的特性；而前序、中序、后序遍历利用了 DFS 实现。
+层次遍历使用 BFS 实现，利用的就是 BFS 一层一层遍历的特性；而前序、中序、后序遍历利用了 DFS 实现。
前序、中序、后序遍只是在对节点访问的顺序有一点不同，其它都相同。
-① 前序
+① 前序
```java
-void dfs(TreeNode root){
- visit(root);
- dfs(root.left);
- dfs(root.right);
+void dfs(TreeNode root){
+ visit(root);
+ dfs(root.left);
+ dfs(root.right);
}
```
-② 中序
+② 中序
```java
-void dfs(TreeNode root){
- dfs(root.left);
- visit(root);
- dfs(root.right);
+void dfs(TreeNode root){
+ dfs(root.left);
+ visit(root);
+ dfs(root.right);
}
```
-③ 后序
+③ 后序
```java
-void dfs(TreeNode root){
- dfs(root.left);
- dfs(root.right);
- visit(root);
+void dfs(TreeNode root){
+ dfs(root.left);
+ dfs(root.right);
+ visit(root);
}
```
-**非递归实现二叉树的前序遍历**
+**非递归实现二叉树的前序遍历**
-[Leetcode : 144. Binary Tree Preorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-preorder-traversal/description/)
+[Leetcode : 144. Binary Tree Preorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-preorder-traversal/description/)
```java
-public List preorderTraversal(TreeNode root) {
- List ret = new ArrayList<>();
- if (root == null) return ret;
- Stack stack = new Stack<>();
- stack.push(root);
- while (!stack.isEmpty()) {
- TreeNode node = stack.pop();
- ret.add(node.val);
- if (node.right != null) stack.push(node.right);
- if (node.left != null) stack.push(node.left); // 先添加右子树再添加左子树，这样是为了让左子树在栈顶
- }
- return ret;
+public List preorderTraversal(TreeNode root) {
+ List ret = new ArrayList<>();
+ if (root == null) return ret;
+ Stack stack = new Stack<>();
+ stack.push(root);
+ while (!stack.isEmpty()) {
+ TreeNode node = stack.pop();
+ ret.add(node.val);
+ if (node.right != null) stack.push(node.right);
+ if (node.left != null) stack.push(node.left); // 先添加右子树再添加左子树，这样是为了让左子树在栈顶
+ }
+ return ret;
}
```
-**非递归实现二叉树的后序遍历**
+**非递归实现二叉树的后序遍历**
-[Leetcode : 145. Binary Tree Postorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-postorder-traversal/description/)
+[Leetcode : 145. Binary Tree Postorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-postorder-traversal/description/)
-前序遍历为 root -> left -> right，后序遍历为 left -> right -> root，可以修改前序遍历成为 root -> right -> left，那么这个顺序就和后序遍历正好相反。
+前序遍历为 root -> left -> right，后序遍历为 left -> right -> root，可以修改前序遍历成为 root -> right -> left，那么这个顺序就和后序遍历正好相反。
```java
-public List postorderTraversal(TreeNode root) {
- List ret = new ArrayList<>();
- if (root == null) return ret;
- Stack stack = new Stack<>();
- stack.push(root);
- while (!stack.isEmpty()) {
- TreeNode node = stack.pop();
- ret.add(node.val);
- if (node.left != null) stack.push(node.left);
- if (node.right != null) stack.push(node.right);
- }
- Collections.reverse(ret);
- return ret;
+public List postorderTraversal(TreeNode root) {
+ List ret = new ArrayList<>();
+ if (root == null) return ret;
+ Stack stack = new Stack<>();
+ stack.push(root);
+ while (!stack.isEmpty()) {
+ TreeNode node = stack.pop();
+ ret.add(node.val);
+ if (node.left != null) stack.push(node.left);
+ if (node.right != null) stack.push(node.right);
+ }
+ Collections.reverse(ret);
+ return ret;
}
```
-**非递归实现二叉树的中序遍历**
+**非递归实现二叉树的中序遍历**
-[Leetcode : 94. Binary Tree Inorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-inorder-traversal/description/)
+[Leetcode : 94. Binary Tree Inorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-inorder-traversal/description/)
```java
-public List inorderTraversal(TreeNode root) {
- List ret = new ArrayList<>();
- Stack stack = new Stack<>();
- TreeNode cur = root;
- while(cur != null || !stack.isEmpty()) {
- while(cur != null) { // 模拟递归栈的不断深入
- stack.add(cur);
- cur = cur.left;
- }
- TreeNode node = stack.pop();
- ret.add(node.val);
- cur = node.right;
- }
- return ret;
+public List inorderTraversal(TreeNode root) {
+ List ret = new ArrayList<>();
+ Stack stack = new Stack<>();
+ TreeNode cur = root;
+ while(cur != null || !stack.isEmpty()) {
+ while(cur != null) { // 模拟递归栈的不断深入
+ stack.add(cur);
+ cur = cur.left;
+ }
+ TreeNode node = stack.pop();
+ ret.add(node.val);
+ cur = node.right;
+ }
+ return ret;
}
```
-### BST
+### BST
-主要利用 BST 中序遍历有序的特点。
+主要利用 BST 中序遍历有序的特点。
-**在 BST 中寻找两个节点，使它们的和为一个给定值**
+**在 BST 中寻找两个节点，使它们的和为一个给定值**
-[653. Two Sum IV - Input is a BST (Easy)](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/description/)
+[653. Two Sum IV - Input is a BST (Easy)](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/description/)
```html
-Input:
- 5
- / \
- 3 6
- / \ \
-2 4 7
+Input:
+ 5
+ / \
+ 3 6
+ / \ \
+2 4 7
-Target = 9
+Target = 9
-Output: True
+Output: True
```
使用中序遍历得到有序数组之后，再利用双指针对数组进行查找。
@@ -4554,671 +4605,671 @@ Output: True
应该注意到，这一题不能用分别在左右子树两部分来处理这种思想，因为两个待求的节点可能分别在左右子树中。
```java
-public boolean findTarget(TreeNode root, int k) {
- List nums = new ArrayList<>();
- inOrder(root, nums);
- int i = 0, j = nums.size() - 1;
- while(i < j){
- int sum = nums.get(i) + nums.get(j);
- if(sum == k) return true;
- if(sum < k) i++;
- else j--;
- }
- return false;
+public boolean findTarget(TreeNode root, int k) {
+ List nums = new ArrayList<>();
+ inOrder(root, nums);
+ int i = 0, j = nums.size() - 1;
+ while(i < j){
+ int sum = nums.get(i) + nums.get(j);
+ if(sum == k) return true;
+ if(sum < k) i++;
+ else j--;
+ }
+ return false;
}
-private void inOrder(TreeNode root, List nums){
- if(root == null) return;
- inOrder(root.left, nums);
- nums.add(root.val);
- inOrder(root.right, nums);
+private void inOrder(TreeNode root, List nums){
+ if(root == null) return;
+ inOrder(root.left, nums);
+ nums.add(root.val);
+ inOrder(root.right, nums);
}
```
-**在 BST 中查找两个节点之差的最小绝对值**
+**在 BST 中查找两个节点之差的最小绝对值**
-[Leetcode : 530. Minimum Absolute Difference in BST (Easy)](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/)
+[Leetcode : 530. Minimum Absolute Difference in BST (Easy)](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/)
```html
Input:
- 1
- \
- 3
- /
- 2
+ 1
+ \
+ 3
+ /
+ 2
Output:
1
```
-利用 BST 的中序遍历为有序的性质，计算中序遍历中临近的两个节点之差的绝对值，取最小值。
+利用 BST 的中序遍历为有序的性质，计算中序遍历中临近的两个节点之差的绝对值，取最小值。
```java
-private int minDiff = Integer.MAX_VALUE;
-private int preVal = -1;
+private int minDiff = Integer.MAX_VALUE;
+private int preVal = -1;
-public int getMinimumDifference(TreeNode root) {
- inorder(root);
- return minDiff;
+public int getMinimumDifference(TreeNode root) {
+ inorder(root);
+ return minDiff;
}
-private void inorder(TreeNode node){
- if(node == null) return;
- inorder(node.left);
- if(preVal != -1) minDiff = Math.min(minDiff, Math.abs(node.val - preVal));
- preVal = node.val;
- inorder(node.right);
+private void inorder(TreeNode node){
+ if(node == null) return;
+ inorder(node.left);
+ if(preVal != -1) minDiff = Math.min(minDiff, Math.abs(node.val - preVal));
+ preVal = node.val;
+ inorder(node.right);
}
```
-**把 BST 每个节点的值都加上比它大的节点的值**
+**把 BST 每个节点的值都加上比它大的节点的值**
-[Leetcode : Convert BST to Greater Tree (Easy)](https://leetcode.com/problems/convert-bst-to-greater-tree/description/)
+[Leetcode : Convert BST to Greater Tree (Easy)](https://leetcode.com/problems/convert-bst-to-greater-tree/description/)
```html
-Input: The root of a Binary Search Tree like this:
- 5
- / \
- 2 13
+Input: The root of a Binary Search Tree like this:
+ 5
+ / \
+ 2 13
-Output: The root of a Greater Tree like this:
- 18
- / \
- 20 13
+Output: The root of a Greater Tree like this:
+ 18
+ / \
+ 20 13
```
先遍历右子树。
```java
-private int sum = 0;
+private int sum = 0;
-public TreeNode convertBST(TreeNode root) {
- traver(root);
- return root;
+public TreeNode convertBST(TreeNode root) {
+ traver(root);
+ return root;
}
-private void traver(TreeNode root) {
- if (root == null) {
- return;
- }
- if (root.right != null) {
- traver(root.right);
- }
- sum += root.val;
- root.val = sum;
- if (root.left != null) {
- traver(root.left);
- }
+private void traver(TreeNode root) {
+ if (root == null) {
+ return;
+ }
+ if (root.right != null) {
+ traver(root.right);
+ }
+ sum += root.val;
+ root.val = sum;
+ if (root.left != null) {
+ traver(root.left);
+ }
}
```
-**寻找 BST 中出现次数最多的节点**
+**寻找 BST 中出现次数最多的节点**
-[Leetcode : 501. Find Mode in Binary Search Tree (Easy)](https://leetcode.com/problems/find-mode-in-binary-search-tree/description/)
+[Leetcode : 501. Find Mode in Binary Search Tree (Easy)](https://leetcode.com/problems/find-mode-in-binary-search-tree/description/)
```html
- 1
- \
- 2
- /
- 2
-return [2].
+ 1
+ \
+ 2
+ /
+ 2
+return [2].
```
```java
-private int cnt = 1;
-private int maxCnt = 1;
-private TreeNode preNode = null;
-private List list;
+private int cnt = 1;
+private int maxCnt = 1;
+private TreeNode preNode = null;
+private List list;
-public int[] findMode(TreeNode root) {
- list = new ArrayList<>();
- inorder(root);
- int[] ret = new int[list.size()];
- int idx = 0;
- for(int num : list){
- ret[idx++] = num;
- }
- return ret;
+public int[] findMode(TreeNode root) {
+ list = new ArrayList<>();
+ inorder(root);
+ int[] ret = new int[list.size()];
+ int idx = 0;
+ for(int num : list){
+ ret[idx++] = num;
+ }
+ return ret;
}
-private void inorder(TreeNode node){
- if(node == null) return;
- inorder(node.left);
- if(preNode != null){
- if(preNode.val == node.val) cnt++;
- else cnt = 1;
- }
- if(cnt > maxCnt){
- maxCnt = cnt;
- list.clear();
- list.add(node.val);
- } else if(cnt == maxCnt){
- list.add(node.val);
- }
- preNode = node;
- inorder(node.right);
+private void inorder(TreeNode node){
+ if(node == null) return;
+ inorder(node.left);
+ if(preNode != null){
+ if(preNode.val == node.val) cnt++;
+ else cnt = 1;
+ }
+ if(cnt > maxCnt){
+ maxCnt = cnt;
+ list.clear();
+ list.add(node.val);
+ } else if(cnt == maxCnt){
+ list.add(node.val);
+ }
+ preNode = node;
+ inorder(node.right);
}
```
-**寻找 BST 的第 k 个元素**
+**寻找 BST 的第 k 个元素**
-[Leetcode : 230. Kth Smallest Element in a BST (Medium)](https://leetcode.com/problems/kth-smallest-element-in-a-bst/description/)
+[Leetcode : 230. Kth Smallest Element in a BST (Medium)](https://leetcode.com/problems/kth-smallest-element-in-a-bst/description/)
递归解法：
```java
-public int kthSmallest(TreeNode root, int k) {
- int leftCnt = count(root.left);
- if(leftCnt == k - 1) return root.val;
- if(leftCnt > k - 1) return kthSmallest(root.left, k);
- return kthSmallest(root.right, k - leftCnt - 1);
+public int kthSmallest(TreeNode root, int k) {
+ int leftCnt = count(root.left);
+ if(leftCnt == k - 1) return root.val;
+ if(leftCnt > k - 1) return kthSmallest(root.left, k);
+ return kthSmallest(root.right, k - leftCnt - 1);
}
-private int count(TreeNode node) {
- if(node == null) return 0;
- return 1 + count(node.left) + count(node.right);
+private int count(TreeNode node) {
+ if(node == null) return 0;
+ return 1 + count(node.left) + count(node.right);
}
```
中序遍历解法：
```java
-private int cnt = 0;
-private int val;
+private int cnt = 0;
+private int val;
-public int kthSmallest(TreeNode root, int k) {
- inorder(root, k);
- return val;
+public int kthSmallest(TreeNode root, int k) {
+ inorder(root, k);
+ return val;
}
-private void inorder(TreeNode node, int k) {
- if(node == null) return;
- inorder(node.left, k);
- cnt++;
- if(cnt == k) {
- val = node.val;
- return;
- }
- inorder(node.right, k);
+private void inorder(TreeNode node, int k) {
+ if(node == null) return;
+ inorder(node.left, k);
+ cnt++;
+ if(cnt == k) {
+ val = node.val;
+ return;
+ }
+ inorder(node.right, k);
}
```
-### Trie
+### Trie
-
+ 
Trie，又称前缀树或字典树，用于判断字符串是否存在或者是否具有某种字符串前缀。
-**实现一个 Trie**
+**实现一个 Trie**
-[Leetcode : 208. Implement Trie (Prefix Tree) (Medium)](https://leetcode.com/problems/implement-trie-prefix-tree/description/)
+[Leetcode : 208. Implement Trie (Prefix Tree) (Medium)](https://leetcode.com/problems/implement-trie-prefix-tree/description/)
```java
-class Trie {
+class Trie {
- private class Node{
- Node[] childs = new Node[26];
- boolean isLeaf;
- }
+ private class Node{
+ Node[] childs = new Node[26];
+ boolean isLeaf;
+ }
- private Node root = new Node();
+ private Node root = new Node();
- /** Initialize your data structure here. */
- public Trie() {
- }
+ /** Initialize your data structure here. */
+ public Trie() {
+ }
- /** Inserts a word into the trie. */
- public void insert(String word) {
- int idx = word.charAt(0) - 'a';
- insert(word, root);
- }
+ /** Inserts a word into the trie. */
+ public void insert(String word) {
+ int idx = word.charAt(0) - 'a';
+ insert(word, root);
+ }
- private void insert(String word, Node node){
- int idx = word.charAt(0) - 'a';
- if(node.childs[idx] == null){
- node.childs[idx] = new Node();
- }
- if(word.length() == 1) node.childs[idx].isLeaf = true;
- else insert(word.substring(1), node.childs[idx]);
- }
+ private void insert(String word, Node node){
+ int idx = word.charAt(0) - 'a';
+ if(node.childs[idx] == null){
+ node.childs[idx] = new Node();
+ }
+ if(word.length() == 1) node.childs[idx].isLeaf = true;
+ else insert(word.substring(1), node.childs[idx]);
+ }
- /** Returns if the word is in the trie. */
- public boolean search(String word) {
- return search(word, root);
- }
+ /** Returns if the word is in the trie. */
+ public boolean search(String word) {
+ return search(word, root);
+ }
- private boolean search(String word, Node node){
- if(node == null) return false;
- int idx = word.charAt(0) - 'a';
- if(node.childs[idx] == null) return false;
- if(word.length() == 1) return node.childs[idx].isLeaf;
- return search(word.substring(1), node.childs[idx]);
- }
+ private boolean search(String word, Node node){
+ if(node == null) return false;
+ int idx = word.charAt(0) - 'a';
+ if(node.childs[idx] == null) return false;
+ if(word.length() == 1) return node.childs[idx].isLeaf;
+ return search(word.substring(1), node.childs[idx]);
+ }
- /** Returns if there is any word in the trie that starts with the given prefix. */
- public boolean startsWith(String prefix) {
- return startWith(prefix, root);
- }
+ /** Returns if there is any word in the trie that starts with the given prefix. */
+ public boolean startsWith(String prefix) {
+ return startWith(prefix, root);
+ }
- private boolean startWith(String prefix, Node node){
- if(node == null) return false;
- if(prefix.length() == 0) return true;
- int idx = prefix.charAt(0) - 'a';
- return startWith(prefix.substring(1), node.childs[idx]);
- }
+ private boolean startWith(String prefix, Node node){
+ if(node == null) return false;
+ if(prefix.length() == 0) return true;
+ int idx = prefix.charAt(0) - 'a';
+ return startWith(prefix.substring(1), node.childs[idx]);
+ }
}
```
-**实现一个 Trie，用来求前缀和**
+**实现一个 Trie，用来求前缀和**
-[Leetcode : 677. Map Sum Pairs (Medium)](https://leetcode.com/problems/map-sum-pairs/description/)
+[Leetcode : 677. Map Sum Pairs (Medium)](https://leetcode.com/problems/map-sum-pairs/description/)
```html
-Input: insert("apple", 3), Output: Null
-Input: sum("ap"), Output: 3
-Input: insert("app", 2), Output: Null
-Input: sum("ap"), Output: 5
+Input: insert("apple", 3), Output: Null
+Input: sum("ap"), Output: 3
+Input: insert("app", 2), Output: Null
+Input: sum("ap"), Output: 5
```
```java
-class MapSum {
- private class Trie {
- int val;
- Map childs;
- boolean isWord;
+class MapSum {
+ private class Trie {
+ int val;
+ Map childs;
+ boolean isWord;
- Trie() {
- childs = new HashMap<>();
- }
- }
+ Trie() {
+ childs = new HashMap<>();
+ }
+ }
- private Trie root;
+ private Trie root;
- public MapSum() {
- root = new Trie();
- }
+ public MapSum() {
+ root = new Trie();
+ }
- public void insert(String key, int val) {
- Trie cur = root;
- for(char c : key.toCharArray()) {
- if(!cur.childs.containsKey(c)) {
- Trie next = new Trie();
- cur.childs.put(c, next);
- }
- cur = cur.childs.get(c);
- }
- cur.val = val;
- cur.isWord = true;
- }
+ public void insert(String key, int val) {
+ Trie cur = root;
+ for(char c : key.toCharArray()) {
+ if(!cur.childs.containsKey(c)) {
+ Trie next = new Trie();
+ cur.childs.put(c, next);
+ }
+ cur = cur.childs.get(c);
+ }
+ cur.val = val;
+ cur.isWord = true;
+ }
- public int sum(String prefix) {
- Trie cur = root;
- for(char c : prefix.toCharArray()) {
- if(!cur.childs.containsKey(c)) return 0;
- cur = cur.childs.get(c);
- }
- return dfs(cur);
- }
+ public int sum(String prefix) {
+ Trie cur = root;
+ for(char c : prefix.toCharArray()) {
+ if(!cur.childs.containsKey(c)) return 0;
+ cur = cur.childs.get(c);
+ }
+ return dfs(cur);
+ }
- private int dfs(Trie cur) {
- int sum = 0;
- if(cur.isWord) {
- sum += cur.val;
- }
- for(Trie next : cur.childs.values()) {
- sum += dfs(next);
- }
- return sum;
- }
+ private int dfs(Trie cur) {
+ int sum = 0;
+ if(cur.isWord) {
+ sum += cur.val;
+ }
+ for(Trie next : cur.childs.values()) {
+ sum += dfs(next);
+ }
+ return sum;
+ }
}
```
-## 图
+## 图
-## 位运算
+## 位运算
-**1. 基本原理**
+**1. 基本原理**
-0s 表示 一串 0 ，1s 表示一串 1。
+0s 表示 一串 0 ，1s 表示一串 1。
```
-x ^ 0s = x x & 0s = 0 x | 0s = x
-x ^ 1s = ~x x & 1s = x x | 1s = 1s
-x ^ x = 0 x & x = x x | x = x
+x ^ 0s = x x & 0s = 0 x | 0s = x
+x ^ 1s = ~x x & 1s = x x | 1s = 1s
+x ^ x = 0 x & x = x x | x = x
```
-① 利用 x ^ 1s = ~x 的特点，可以将位级表示翻转；利用 x ^ x = 0 的特点，可以将三个数中重复的两个数去除，只留下另一个数；
-② 利用 x & 0s = 0 和 x & 1s = x 的特点，可以实现掩码操作。一个数 num 与 mask ：00111100 进行位与操作，只保留 num 中与 mask 的 1 部分相对应的位；
-③ 利用 x | 0s = x 和 x | 1s = 1s 的特点，可以实现设置操作。一个数 num 与 mask：00111100 进行位或操作，将 num 中与 mask 的 1 部分相对应的位都设置为 1 。
+① 利用 x ^ 1s = \~x 的特点，可以将位级表示翻转；利用 x ^ x = 0 的特点，可以将三个数中重复的两个数去除，只留下另一个数；
+② 利用 x & 0s = 0 和 x & 1s = x 的特点，可以实现掩码操作。一个数 num 与 mask ：00111100 进行位与操作，只保留 num 中与 mask 的 1 部分相对应的位；
+③ 利用 x | 0s = x 和 x | 1s = 1s 的特点，可以实现设置操作。一个数 num 与 mask：00111100 进行位或操作，将 num 中与 mask 的 1 部分相对应的位都设置为 1 。
-\>\> n 为算术右移，相当于除以 2n；
-\>\>\> n 为无符号右移，左边会补上 0。
-<< n 为算术左移，相当于乘以 2n。
+\>\> n 为算术右移，相当于除以 2n；
+\>\>\> n 为无符号右移，左边会补上 0。
+<< n 为算术左移，相当于乘以 2n。
-n&(n-1) 该位运算是去除 n 的位级表示中最低的那一位。例如对于二进制表示 10110**100**，减去 1 得到 10110**011**，这两个数相与得到 10110**000**。
+n&(n-1) 该位运算是去除 n 的位级表示中最低的那一位。例如对于二进制表示 10110 **100** ，减去 1 得到 10110**011**，这两个数相与得到 10110**000**。
-n-n&(~n+1) 概运算是去除 n 的位级表示中最高的那一位。
+n-n&(\~n+1) 概运算是去除 n 的位级表示中最高的那一位。
-n&(-n) 该运算得到 n 的位级表示中最低的那一位。-n 得到 n 的反码加 1，对于二进制表示 10110**100**，-n 得到 01001**100**，相与得到 00000**100**
+n&(-n) 该运算得到 n 的位级表示中最低的那一位。-n 得到 n 的反码加 1，对于二进制表示 10110 **100** ，-n 得到 01001**100**，相与得到 00000**100**
-**2. mask 计算**
+**2. mask 计算**
-要获取 111111111，将 0 取反即可，~0。
+要获取 111111111，将 0 取反即可，\~0。
-要得到只有第 i 位为 1 的 mask，将 1 向左移动 i 位即可，1<<i 。例如 1<<5 得到只有第 5 位为 1 的 mask ：00010000。
+要得到只有第 i 位为 1 的 mask，将 1 向左移动 i 位即可，1<<i 。例如 1<<5 得到只有第 5 位为 1 的 mask ：00010000。
-要得到 1 到 i 位为 1 的 mask，1<<(i+1)-1 即可，例如将 1<<(4+1)-1 = 00010000-1 = 00001111。
+要得到 1 到 i 位为 1 的 mask，1<<(i+1)-1 即可，例如将 1<<(4+1)-1 = 00010000-1 = 00001111。
-要得到 1 到 i 位为 0 的 mask，只需将 1 到 i 位为 1 的 mask 取反，即 ~(1<<(i+1)-1)。
+要得到 1 到 i 位为 0 的 mask，只需将 1 到 i 位为 1 的 mask 取反，即 \~(1<<(i+1)-1)。
-**3. 位操作举例**
+**3. 位操作举例**
-① 获取第 i 位
+① 获取第 i 位
-num & 00010000 != 0
+num & 00010000 != 0
```java
-(num & (1 << i)) != 0;
+(num & (1 << i)) != 0;
```
-② 将第 i 位设置为 1
+② 将第 i 位设置为 1
-num | 00010000
+num | 00010000
```java
-num | (1 << i);
+num | (1 << i);
```
-③ 将第 i 位清除为 0
+③ 将第 i 位清除为 0
-num & 11101111
+num & 11101111
```java
-num & (~(1 << i))
+num & (~(1 << i))
```
-④ 将最高位到第 i 位清除为 0
+④ 将最高位到第 i 位清除为 0
-num & 00001111
+num & 00001111
```java
-num & ((1 << i) - 1);
+num & ((1 << i) - 1);
```
-⑤ 将第 0 位到第 i 位清除为 0
+⑤ 将第 0 位到第 i 位清除为 0
-num & 11110000
+num & 11110000
```java
-num & (~((1 << (i+1)) - 1));
+num & (~((1 << (i+1)) - 1));
```
-⑥ 将第 i 位设置为 0 或者 1
+⑥ 将第 i 位设置为 0 或者 1
-先将第 i 位清零，然后将 v 左移 i 位，执行“位或”运算。
+先将第 i 位清零，然后将 v 左移 i 位，执行“位或”运算。
```java
-(num & (1 << i)) | (v << i);
+(num & (1 << i)) | (v << i);
```
-**4. Java 中的位操作**
+**4. Java 中的位操作**
```html
-static int Integer.bitCount() // 统计 1 的数量
-static int Integer.highestOneBit() // 获得最高位
-static String toBinaryString(int i) // 转换位二进制表示的字符串
+static int Integer.bitCount() // 统计 1 的数量
+static int Integer.highestOneBit() // 获得最高位
+static String toBinaryString(int i) // 转换位二进制表示的字符串
```
-**统计两个数的二进制表示有多少位不同**
+**统计两个数的二进制表示有多少位不同**
-[Leetcode : 461. Hamming Distance (Easy)](https://leetcode.com/problems/hamming-distance/)
+[Leetcode : 461. Hamming Distance (Easy)](https://leetcode.com/problems/hamming-distance/)
-对两个数进行异或操作，不同的那一位结果为 1 ，统计有多少个 1 即可。
+对两个数进行异或操作，不同的那一位结果为 1 ，统计有多少个 1 即可。
```java
-public int hammingDistance(int x, int y) {
- int z = x ^ y;
- int cnt = 0;
- while(z != 0){
- if((z & 1) == 1) cnt++;
- z = z >> 1;
- }
- return cnt;
+public int hammingDistance(int x, int y) {
+ int z = x ^ y;
+ int cnt = 0;
+ while(z != 0){
+ if((z & 1) == 1) cnt++;
+ z = z >> 1;
+ }
+ return cnt;
}
```
-可以使用 Integer.bitcount() 来统计 1 个的个数。
+可以使用 Integer.bitcount() 来统计 1 个的个数。
```java
-public int hammingDistance(int x, int y) {
- return Integer.bitCount(x ^ y);
+public int hammingDistance(int x, int y) {
+ return Integer.bitCount(x ^ y);
}
```
-**翻转一个数的比特位**
+**翻转一个数的比特位**
-[Leetcode : 190. Reverse Bits (Easy)](https://leetcode.com/problems/reverse-bits/description/)
+[Leetcode : 190. Reverse Bits (Easy)](https://leetcode.com/problems/reverse-bits/description/)
```java
-public int reverseBits(int n) {
- int ret = 0;
- for(int i = 0; i < 32; i++){
- ret <<= 1;
- ret |= (n & 1);
- n >>>= 1;
- }
- return ret;
+public int reverseBits(int n) {
+ int ret = 0;
+ for(int i = 0; i < 32; i++){
+ ret <<= 1;
+ ret |= (n & 1);
+ n >>>= 1;
+ }
+ return ret;
}
```
-**不用额外变量交换两个整数**
+**不用额外变量交换两个整数**
-[程序员代码面试指南 ：P317](#)
+[程序员代码面试指南 ：P317](#)
```java
-a = a ^ b;
-b = a ^ b;
-a = a ^ b;
+a = a ^ b;
+b = a ^ b;
+a = a ^ b;
```
-将 c = a ^ b，那么 b ^ c = b ^ b ^ a = a，a ^ c = a ^ a ^ b = b。
+将 c = a ^ b，那么 b ^ c = b ^ b ^ a = a，a ^ c = a ^ a ^ b = b。
-**判断一个数是不是 4 的 n 次方**
+**判断一个数是不是 4 的 n 次方**
-[Leetcode : 342. Power of Four (Easy)](https://leetcode.com/problems/power-of-four/)
+[Leetcode : 342. Power of Four (Easy)](https://leetcode.com/problems/power-of-four/)
-该数二进制表示有且只有一个奇数位为 1 ，其余的都为 0 ，例如 16 ： 10000。可以每次把 1 向左移动 2 位，就能构造出这种数字，然后比较构造出来的数与要判断的数是否相同。
+该数二进制表示有且只有一个奇数位为 1 ，其余的都为 0 ，例如 16 ： 10000。可以每次把 1 向左移动 2 位，就能构造出这种数字，然后比较构造出来的数与要判断的数是否相同。
```java
-public boolean isPowerOfFour(int num) {
- int i = 1;
- while(i > 0){
- if(i == num) return true;
- i = i << 2;
- }
- return false;
+public boolean isPowerOfFour(int num) {
+ int i = 1;
+ while(i > 0){
+ if(i == num) return true;
+ i = i << 2;
+ }
+ return false;
}
```
-也可以用 Java 的 Integer.toString() 方法将该数转换为 4 进制形式的字符串，然后判断字符串是否以 1 开头。
+也可以用 Java 的 Integer.toString() 方法将该数转换为 4 进制形式的字符串，然后判断字符串是否以 1 开头。
```java
-public boolean isPowerOfFour(int num) {
- return Integer.toString(num, 4).matches("10*");
+public boolean isPowerOfFour(int num) {
+ return Integer.toString(num, 4).matches("10*");
}
```
-**判断一个数是不是 2 的 n 次方**
+**判断一个数是不是 2 的 n 次方**
-[Leetcode : 231. Power of Two (Easy)](https://leetcode.com/problems/power-of-two/description/)
+[Leetcode : 231. Power of Two (Easy)](https://leetcode.com/problems/power-of-two/description/)
-同样可以用 Power of Four 的方法，但是 2 的 n 次方更特殊，它的二进制表示只有一个 1 存在。
+同样可以用 Power of Four 的方法，但是 2 的 n 次方更特殊，它的二进制表示只有一个 1 存在。
```java
-public boolean isPowerOfTwo(int n) {
- return n > 0 && Integer.bitCount(n) == 1;
+public boolean isPowerOfTwo(int n) {
+ return n > 0 && Integer.bitCount(n) == 1;
}
```
-利用 1000 & 0111 == 0 这种性质，得到以下解法：
+利用 1000 & 0111 == 0 这种性质，得到以下解法：
```java
-public boolean isPowerOfTwo(int n) {
- return n > 0 && (n & (n - 1)) == 0;
+public boolean isPowerOfTwo(int n) {
+ return n > 0 && (n & (n - 1)) == 0;
}
```
-**数组中唯一一个不重复的元素**
+**数组中唯一一个不重复的元素**
-[Leetcode : 136. Single Number (Easy)](https://leetcode.com/problems/single-number/description/)
+[Leetcode : 136. Single Number (Easy)](https://leetcode.com/problems/single-number/description/)
-两个相同的数异或的结果为 0，对所有数进行异或操作，最后的结果就是单独出现的那个数。
+两个相同的数异或的结果为 0，对所有数进行异或操作，最后的结果就是单独出现的那个数。
-类似的有：[Leetcode : 389. Find the Difference (Easy)](https://leetcode.com/problems/find-the-difference/description/)，两个字符串仅有一个字符不相同，使用异或操作可以以 O(1) 的空间复杂度来求解，而不需要使用 HashSet。
+类似的有：[Leetcode : 389. Find the Difference (Easy)](https://leetcode.com/problems/find-the-difference/description/)，两个字符串仅有一个字符不相同，使用异或操作可以以 O(1) 的空间复杂度来求解，而不需要使用 HashSet。
```java
-public int singleNumber(int[] nums) {
- int ret = 0;
- for(int n : nums) ret = ret ^ n;
- return ret;
+public int singleNumber(int[] nums) {
+ int ret = 0;
+ for(int n : nums) ret = ret ^ n;
+ return ret;
}
```
-**数组中不重复的两个元素**
+**数组中不重复的两个元素**
-[Leetcode : 260. Single Number III (Medium)](https://leetcode.com/problems/single-number-iii/description/)
+[Leetcode : 260. Single Number III (Medium)](https://leetcode.com/problems/single-number-iii/description/)
两个不相等的元素在位级表示上必定会有一位存在不同。
将数组的所有元素异或得到的结果为不存在重复的两个元素异或的结果。
-diff &= -diff 得到出 diff 最右侧不为 0 的位，也就是不存在重复的两个元素在位级表示上最右侧不同的那一位，利用这一位就可以将两个元素区分开来。
+diff &= -diff 得到出 diff 最右侧不为 0 的位，也就是不存在重复的两个元素在位级表示上最右侧不同的那一位，利用这一位就可以将两个元素区分开来。
```java
-public int[] singleNumber(int[] nums) {
- int diff = 0;
- for(int num : nums) diff ^= num;
- // 得到最右一位
- diff &= -diff;
- int[] ret = new int[2];
- for(int num : nums) {
- if((num & diff) == 0) ret[0] ^= num;
- else ret[1] ^= num;
- }
- return ret;
+public int[] singleNumber(int[] nums) {
+ int diff = 0;
+ for(int num : nums) diff ^= num;
+ // 得到最右一位
+ diff &= -diff;
+ int[] ret = new int[2];
+ for(int num : nums) {
+ if((num & diff) == 0) ret[0] ^= num;
+ else ret[1] ^= num;
+ }
+ return ret;
}
```
-**判断一个数的位级表示是否不会出现连续的 0 和 1**
+**判断一个数的位级表示是否不会出现连续的 0 和 1**
-[Leetcode : 693. Binary Number with Alternating Bits (Easy)](https://leetcode.com/problems/binary-number-with-alternating-bits/description/)
+[Leetcode : 693. Binary Number with Alternating Bits (Easy)](https://leetcode.com/problems/binary-number-with-alternating-bits/description/)
-对于 10101 这种位级表示的数，把它向右移动 1 位得到 1010 ，这两个数每个位都不同，因此异或得到的结果为 11111。
+对于 10101 这种位级表示的数，把它向右移动 1 位得到 1010 ，这两个数每个位都不同，因此异或得到的结果为 11111。
```java
-public boolean hasAlternatingBits(int n) {
- int a = (n ^ (n >> 1));
- return (a & (a + 1)) == 0;
+public boolean hasAlternatingBits(int n) {
+ int a = (n ^ (n >> 1));
+ return (a & (a + 1)) == 0;
}
```
-**求一个数的补码**
+**求一个数的补码**
-[Leetcode : 476. Number Complement (Easy)](https://leetcode.com/problems/number-complement/description/)
+[Leetcode : 476. Number Complement (Easy)](https://leetcode.com/problems/number-complement/description/)
-不考虑二进制表示中的首 0 部分
+不考虑二进制表示中的首 0 部分
-对于 00000101，要求补码可以将它与 00000111 进行异或操作。那么问题就转换为求掩码 00000111。
+对于 00000101，要求补码可以将它与 00000111 进行异或操作。那么问题就转换为求掩码 00000111。
```java
-public int findComplement(int num) {
- if(num == 0) return 1;
- int mask = 1 << 30;
- while((num & mask) == 0) mask >>= 1;
- mask = (mask << 1) - 1;
- return num ^ mask;
+public int findComplement(int num) {
+ if(num == 0) return 1;
+ int mask = 1 << 30;
+ while((num & mask) == 0) mask >>= 1;
+ mask = (mask << 1) - 1;
+ return num ^ mask;
}
```
-可以利用 Java 的 Integer.highestOneBit() 方法来获得含有首 1 的数。
+可以利用 Java 的 Integer.highestOneBit() 方法来获得含有首 1 的数。
```java
-public int findComplement(int num) {
- if(num == 0) return 1;
- int mask = Integer.highestOneBit(num);
- mask = (mask << 1) - 1;
- return num ^ mask;
+public int findComplement(int num) {
+ if(num == 0) return 1;
+ int mask = Integer.highestOneBit(num);
+ mask = (mask << 1) - 1;
+ return num ^ mask;
}
```
-对于 10000000 这样的数要扩展成 11111111，可以利用以下方法：
+对于 10000000 这样的数要扩展成 11111111，可以利用以下方法：
```html
-mask |= mask >> 1 11000000
-mask |= mask >> 2 11110000
-mask |= mask >> 4 11111111
+mask |= mask >> 1 11000000
+mask |= mask >> 2 11110000
+mask |= mask >> 4 11111111
```
```java
-public int findComplement(int num) {
- int mask = num;
- mask |= mask >> 1;
- mask |= mask >> 2;
- mask |= mask >> 4;
- mask |= mask >> 8;
- mask |= mask >> 16;
- return (mask ^ num);
+public int findComplement(int num) {
+ int mask = num;
+ mask |= mask >> 1;
+ mask |= mask >> 2;
+ mask |= mask >> 4;
+ mask |= mask >> 8;
+ mask |= mask >> 16;
+ return (mask ^ num);
}
```
-**实现整数的加法**
+**实现整数的加法**
-[Leetcode : 371. Sum of Two Integers (Easy)](https://leetcode.com/problems/sum-of-two-integers/description/)
+[Leetcode : 371. Sum of Two Integers (Easy)](https://leetcode.com/problems/sum-of-two-integers/description/)
-a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进位。递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。
+a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进位。递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。
```java
-public int getSum(int a, int b) {
- return b == 0 ? a : getSum((a ^ b), (a & b) << 1);
+public int getSum(int a, int b) {
+ return b == 0 ? a : getSum((a ^ b), (a & b) << 1);
}
```
-**字符串数组最大乘积**
+**字符串数组最大乘积**
-[Leetcode : 318. Maximum Product of Word Lengths (Medium)](https://leetcode.com/problems/maximum-product-of-word-lengths/description/)
+[Leetcode : 318. Maximum Product of Word Lengths (Medium)](https://leetcode.com/problems/maximum-product-of-word-lengths/description/)
题目描述：字符串数组的字符串只含有小写字符。求解字符串数组中两个字符串长度的最大乘积，要求这两个字符串不能含有相同字符。
-解题思路：本题主要问题是判断两个字符串是否含相同字符，由于字符串只含有小写字符，总共 26 位，因此可以用一个 32 位的整数来存储每个字符是否出现过。
+解题思路：本题主要问题是判断两个字符串是否含相同字符，由于字符串只含有小写字符，总共 26 位，因此可以用一个 32 位的整数来存储每个字符是否出现过。
```java
-public int maxProduct(String[] words) {
- int n = words.length;
- if (n == 0) return 0;
- int[] val = new int[n];
- for (int i = 0; i < n; i++) {
- for (char c : words[i].toCharArray()) {
- val[i] |= 1 << (c - 'a');
- }
- }
- int ret = 0;
- for (int i = 0; i < n; i++) {
- for (int j = i + 1; j < n; j++) {
- if ((val[i] & val[j]) == 0) {
- ret = Math.max(ret, words[i].length() * words[j].length());
- }
- }
- }
- return ret;
+public int maxProduct(String[] words) {
+ int n = words.length;
+ if (n == 0) return 0;
+ int[] val = new int[n];
+ for (int i = 0; i < n; i++) {
+ for (char c : words[i].toCharArray()) {
+ val[i] |= 1 << (c - 'a');
+ }
+ }
+ int ret = 0;
+ for (int i = 0; i < n; i++) {
+ for (int j = i + 1; j < n; j++) {
+ if ((val[i] & val[j]) == 0) {
+ ret = Math.max(ret, words[i].length() * words[j].length());
+ }
+ }
+ }
+ return ret;
}
```
-# 参考资料
+# 参考资料
-- [Leetcode](https://leetcode.com/problemset/algorithms/?status=Todo)
-- Weiss M A, 冯舜玺. 数据结构与算法分析——C 语言描述[J]. 2004.
-- Sedgewick R. Algorithms[M]. Pearson Education India, 1988.
-- 何海涛, 软件工程师. 剑指 Offer: 名企面试官精讲典型编程题[M]. 电子工业出版社, 2014.
-- 《编程之美》小组. 编程之美[M]. 电子工业出版社, 2008.
-- 左程云. 程序员代码面试指南[M]. 电子工业出版社, 2015.
+- [Leetcode](https://leetcode.com/problemset/algorithms/?status=Todo)
+- Weiss M A, 冯舜玺. 数据结构与算法分析——C 语言描述[J]. 2004.
+- Sedgewick R. Algorithms[M]. Pearson Education India, 1988.
+- 何海涛, 软件工程师. 剑指 Offer: 名企面试官精讲典型编程题[M]. 电子工业出版社, 2014.
+- 《编程之美》小组. 编程之美[M]. 电子工业出版社, 2008.
+- 左程云. 程序员代码面试指南[M]. 电子工业出版社, 2015.
diff --git a/notes/Linux.md b/notes/Linux.md
index 345a205b..2c072e75 100644
--- a/notes/Linux.md
+++ b/notes/Linux.md
@@ -1,958 +1,1043 @@
-[TOC]
+
+* [常用操作以及概念](#常用操作以及概念)
+ * [求助](#求助)
+ * [关机](#关机)
+ * [查看进程](#查看进程)
+ * [查看端口](#查看端口)
+ * [PATH](#path)
+ * [运行等级](#运行等级)
+ * [sudo](#sudo)
+ * [GNU](#gnu)
+ * [包管理工具](#包管理工具)
+ * [常见发行版本](#常见发行版本)
+* [分区](#分区)
+ * [磁盘的文件名](#磁盘的文件名)
+ * [分区表](#分区表)
+ * [1. MBR](#1-mbr)
+ * [2. GPT](#2-gpt)
+ * [开机检测程序](#开机检测程序)
+ * [1. BIOS](#1-bios)
+ * [2. UEFI](#2-uefi)
+ * [挂载](#挂载)
+* [文件权限与目录配置](#文件权限与目录配置)
+ * [文件权限概念](#文件权限概念)
+ * [文件属性以及权限的修改](#文件属性以及权限的修改)
+ * [1. 修改文件所属群组](#1-修改文件所属群组)
+ * [2. 修改文件拥有者](#2-修改文件拥有者)
+ * [3. 修改权限](#3-修改权限)
+ * [目录的权限](#目录的权限)
+ * [文件默认权限](#文件默认权限)
+ * [目录配置](#目录配置)
+* [文件与目录](#文件与目录)
+ * [文件时间](#文件时间)
+ * [文件与目录的基本操作](#文件与目录的基本操作)
+ * [1. ls](#1-ls)
+ * [2. cp](#2-cp)
+ * [3. rm](#3-rm)
+ * [4. mv](#4-mv)
+ * [获取文件内容](#获取文件内容)
+ * [1. cat](#1-cat)
+ * [2. tac](#2-tac)
+ * [3. more](#3-more)
+ * [4. less](#4-less)
+ * [5. head](#5-head)
+ * [6. tail](#6-tail)
+ * [7. od](#7-od)
+ * [8. touch](#8-touch)
+ * [指令与文件搜索](#指令与文件搜索)
+ * [1. which](#1-which)
+ * [2. whereis](#2-whereis)
+ * [3. locate](#3-locate)
+ * [4. find](#4-find)
+ * [4.1 与时间有关的选项](#41-与时间有关的选项)
+ * [4.2 与文件拥有者和所属群组有关的选项](#42-与文件拥有者和所属群组有关的选项)
+ * [4.3 与文件权限和名称有关的选项](#43-与文件权限和名称有关的选项)
+* [磁盘与文件系统](#磁盘与文件系统)
+ * [文件系统的组成](#文件系统的组成)
+ * [inode](#inode)
+ * [目录的 inode 与 block](#目录的-inode-与-block)
+ * [实体链接与符号链接](#实体链接与符号链接)
+ * [1. 实体链接](#1-实体链接)
+ * [2. 符号链接](#2-符号链接)
+* [压缩与打包](#压缩与打包)
+ * [压缩](#压缩)
+ * [1. gzip](#1-gzip)
+ * [2. bzip2](#2-bzip2)
+ * [3. xz](#3-xz)
+ * [打包](#打包)
+* [Bash](#bash)
+ * [Bash 特性](#bash-特性)
+ * [变量操作](#变量操作)
+ * [指令搜索顺序](#指令搜索顺序)
+ * [数据流重定向](#数据流重定向)
+ * [管线指令](#管线指令)
+ * [1. 提取指令：cut](#1-提取指令cut)
+ * [2. 排序命令：sort、uniq](#2-排序命令sortuniq)
+ * [3. 双向输出重定向：tee](#3-双向输出重定向tee)
+ * [4. 字符转换指令：tr、col、expand、join、paste](#4-字符转换指令trcolexpandjoinpaste)
+ * [5. 分区指令：split](#5-分区指令split)
+* [正规表示法与文件格式化处理](#正规表示法与文件格式化处理)
+ * [grep](#grep)
+ * [printf](#printf)
+ * [awk](#awk)
+* [vim 三个模式](#vim-三个模式)
+* [参考资料](#参考资料)
+
-# 常用操作以及概念
-## 求助
+# 常用操作以及概念
-**1. --help**
+## 求助
+
+**1. --help**
指令的基本用法与选项介绍。
-**2. man**
+**2. man**
-man 是 manual 的缩写，将指令的具体信息显示出来。
+man 是 manual 的缩写，将指令的具体信息显示出来。
-当执行 man date 时，有 DATE(1) 出现，其中的数字代表指令的类型，常用的数字及其类型如下：
+当执行 man date 时，有 DATE(1) 出现，其中的数字代表指令的类型，常用的数字及其类型如下：
-| 代号 | 类型 |
-| -- | -- |
-| 1 | 用户在 shell 环境中可以操作的指令或者可执行文件 |
-| 5 | 配置文件 |
-| 8 | 系统管理员可以使用的管理指令 |
+| 代号 | 类型 |
+| -- | -- |
+| 1 | 用户在 shell 环境中可以操作的指令或者可执行文件 |
+| 5 | 配置文件 |
+| 8 | 系统管理员可以使用的管理指令 |
-**3. info**
+**3. info**
-info 与 man 类似，但是 info 将文档分成一个个页面，每个页面可以进行跳转。
+info 与 man 类似，但是 info 将文档分成一个个页面，每个页面可以进行跳转。
-## 关机
+## 关机
-**1. sync**
+**1. sync**
-为了加快对磁盘上文件的读写速度，位于内存中的文件数据不会立即同步到磁盘上，因此关机之前需要先进行 sync 同步操作。
+为了加快对磁盘上文件的读写速度，位于内存中的文件数据不会立即同步到磁盘上，因此关机之前需要先进行 sync 同步操作。
-**2. shutdown**
+**2. shutdown**
```html
-# /sbin/shutdown [-krhc] [时间] [警告讯息]
--k ： 不会关机，只是发送警告讯息，通知所有在线的用户
--r ： 将系统的服务停掉后就重新启动
--h ： 将系统的服务停掉后就立即关机
--c ： 取消已经在进行的 shutdown 指令内容
+# /sbin/shutdown [-krhc] [时间] [警告讯息]
+-k ： 不会关机，只是发送警告讯息，通知所有在线的用户
+-r ： 将系统的服务停掉后就重新启动
+-h ： 将系统的服务停掉后就立即关机
+-c ： 取消已经在进行的 shutdown 指令内容
```
-**3. 其它关机指令**
+**3. 其它关机指令**
reboot、halt、poweroff。
-## 查看进程
+## 查看进程
```html
-ps aux | grep threadx
+ps aux | grep threadx
```
-## 查看端口
+## 查看端口
```html
-netstat -anp | grep 80
+netstat -anp | grep 80
```
-## PATH
+## PATH
-可以在环境变量 PATH 中声明可执行文件的路径，路径之间用 : 分隔。
+可以在环境变量 PATH 中声明可执行文件的路径，路径之间用 : 分隔。
```html
/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/dmtsai/.local/bin:/home/dmtsai/bin
```
-## 运行等级
+## 运行等级
-- 0：关机模式
-- 1：单用户模式（可用于破解 root 密码）
-- 2：无网络支持的多用户模式
-- 3：有网络支持的多用户模式（文本模式，工作中最常用的模式）
-- 4：保留，未使用
-- 5：有网络支持的 X-windows 多用户模式（桌面）
-- 6：重新引导系统，即重启
+- 0：关机模式
+- 1：单用户模式（可用于破解 root 密码）
+- 2：无网络支持的多用户模式
+- 3：有网络支持的多用户模式（文本模式，工作中最常用的模式）
+- 4：保留，未使用
+- 5：有网络支持的 X-windows 多用户模式（桌面）
+- 6：重新引导系统，即重启
-## sudo
+## sudo
-使用 sudo 允许一般用户使用 root 可执行的命令，只有在 /etc/sudoers 配置文件中添加的用户才能使用该指令。
+使用 sudo 允许一般用户使用 root 可执行的命令，只有在 /etc/sudoers 配置文件中添加的用户才能使用该指令。
-## GNU
+## GNU
-GNU 计划，又译为革奴计划，它的目标是创建一套完全自由的操作系统，称为 GNU，其内容软件完全以 GPL 方式发布。其中 GPL 全称为 GNU 通用公共许可协议，包含了以下内容：
+GNU 计划，又译为革奴计划，它的目标是创建一套完全自由的操作系统，称为 GNU，其内容软件完全以 GPL 方式发布。其中 GPL 全称为 GNU 通用公共许可协议，包含了以下内容：
-- 以任何目的运行此程序的自由；
-- 再复制的自由；
-- 改进此程序，并公开发布改进的自由。
+- 以任何目的运行此程序的自由；
+- 再复制的自由；
+- 改进此程序，并公开发布改进的自由。
-## 包管理工具
+## 包管理工具
-RPM 和 DPKG 为最常见的两类软件包管理工具。RPM 全称为 Redhat Package Manager，最早由 Red Hat 公司制定实施，随后被 GNU 开源操作系统接受并成为很多 Linux 系统 (RHEL) 的既定软件标准。与 RPM 进行竞争的是基于 Debian 操作系统 (UBUNTU) 的 DEB 软件包管理工具－ DPKG，全称为 Debian Package，功能方面与 RPM 相似。
+RPM 和 DPKG 为最常见的两类软件包管理工具。RPM 全称为 Redhat Package Manager，最早由 Red Hat 公司制定实施，随后被 GNU 开源操作系统接受并成为很多 Linux 系统 (RHEL) 的既定软件标准。与 RPM 进行竞争的是基于 Debian 操作系统 (UBUNTU) 的 DEB 软件包管理工具－ DPKG，全称为 Debian Package，功能方面与 RPM 相似。
-YUM 基于 RPM 包管理工具，具有依赖管理功能，并具有软件升级的功能。
+YUM 基于 RPM 包管理工具，具有依赖管理功能，并具有软件升级的功能。
-## 常见发行版本
+## 常见发行版本
-Linux 发行版是 Linux 内核及各种应用软件的集成版本。
+Linux 发行版是 Linux 内核及各种应用软件的集成版本。
-| 基于的包管理工具 | 商业发行版 | 社区发行版 |
-| --- | --- | --- |
-| DPKG | Ubuntu | Debian |
-| RPM | Red Hat | Fedora / CentOS |
+| 基于的包管理工具 | 商业发行版 | 社区发行版 |
+| --- | --- | --- |
+| DPKG | Ubuntu | Debian |
+| RPM | Red Hat | Fedora / CentOS |
-# 分区
+# 分区
-## 磁盘的文件名
+## 磁盘的文件名
-Linux 中每个硬件都被当做一个文件。
+Linux 中每个硬件都被当做一个文件。
常见磁盘的文件名：
-- SCSI/SATA/USB 磁盘：/dev/sd[a-p]
-- IDE 磁盘：/dev/hd[a-d]
+- SCSI/SATA/USB 磁盘：/dev/sd[a-p]
+- IDE 磁盘：/dev/hd[a-d]
其中文件名后面的序号的确定与磁盘插入的顺序有关，而与磁盘所插入的插槽位置无关。
-## 分区表
+## 分区表
-磁盘分区表主要有两种格式，一种是限制较多的 MBR 分区表，一种是较新且限制较少的 GPT 分区表。
+磁盘分区表主要有两种格式，一种是限制较多的 MBR 分区表，一种是较新且限制较少的 GPT 分区表。
-### 1. MBR
+### 1. MBR
-MBR 中，第一个扇区最重要，里面有主要开机记录（Master boot record, MBR）及分区表（partition table），其中 MBR 占 446 bytes，partition table 占 64 bytes。
+MBR 中，第一个扇区最重要，里面有主要开机记录（Master boot record, MBR）及分区表（partition table），其中 MBR 占 446 bytes，partition table 占 64 bytes。
-分区表只有 64 bytes，最多只能存储 4 个分区，这 4 个分区为主分区（Primary）和扩展分区（Extended）。其中扩展分区只有一个，它将其它空间用来记录分区表，因此通过扩展分区可以分出更多区分，这些分区称为逻辑分区。
+分区表只有 64 bytes，最多只能存储 4 个分区，这 4 个分区为主分区（Primary）和扩展分区（Extended）。其中扩展分区只有一个，它将其它空间用来记录分区表，因此通过扩展分区可以分出更多区分，这些分区称为逻辑分区。
-Linux 也把分区当成文件，分区文件的命名方式为：磁盘文件名 + 编号，例如 /dev/sda1。注意，逻辑分区的编号从 5 开始。
+Linux 也把分区当成文件，分区文件的命名方式为：磁盘文件名 + 编号，例如 /dev/sda1。注意，逻辑分区的编号从 5 开始。
-### 2. GPT
+### 2. GPT
-不同的磁盘有不同的扇区大小，例如 512 bytes 和最新磁盘的 4 k。GPT 为了兼容所有磁盘，在定义扇区上使用逻辑区块地址（Logical Block Address, LBA）。
+不同的磁盘有不同的扇区大小，例如 512 bytes 和最新磁盘的 4 k。GPT 为了兼容所有磁盘，在定义扇区上使用逻辑区块地址（Logical Block Address, LBA）。
-GPT 第 1 个区块记录了 MBR，紧接着是 33 个区块记录分区信息，并把最后的 33 个区块用于对分区信息进行备份。
+GPT 第 1 个区块记录了 MBR，紧接着是 33 个区块记录分区信息，并把最后的 33 个区块用于对分区信息进行备份。
-GPT 没有扩展分区概念，都是主分区，最多可以分 128 个分区。
+GPT 没有扩展分区概念，都是主分区，最多可以分 128 个分区。
-
+
-## 开机检测程序
+## 开机检测程序
-### 1. BIOS
+### 1. BIOS
-BIOS 是开机的时候计算机执行的第一个程序，这个程序知道可以开机的磁盘，并读取磁盘第一个扇区的 MBR，由 MBR 执行其中的开机管理程序，这个开机管理程序的会加载操作系统的核心文件。
+BIOS 是开机的时候计算机执行的第一个程序，这个程序知道可以开机的磁盘，并读取磁盘第一个扇区的 MBR，由 MBR 执行其中的开机管理程序，这个开机管理程序的会加载操作系统的核心文件。
-MBR 中的开机管理程序提供以下功能：选单、载入核心文件以及转交其它开机管理程序。转交这个功能可以用来实现了多重引导，只需要将另一个操作系统的开机管理程序安装在其它分区的启动扇区上，在启动 MBR 中的开机管理程序时，就可以选择启动当前的操作系统或者转交给其它开机管理程序从而启动另一个操作系统。
+MBR 中的开机管理程序提供以下功能：选单、载入核心文件以及转交其它开机管理程序。转交这个功能可以用来实现了多重引导，只需要将另一个操作系统的开机管理程序安装在其它分区的启动扇区上，在启动 MBR 中的开机管理程序时，就可以选择启动当前的操作系统或者转交给其它开机管理程序从而启动另一个操作系统。
-
+
-安装多重引导，最好先安装 Windows 再安装 Linux。因为安装 Windows 时会覆盖掉 MBR，而 Linux 可以选择将开机管理程序安装在 MBR 或者其它分区的启动扇区，并且可以设置开机管理程序的选单。
+安装多重引导，最好先安装 Windows 再安装 Linux。因为安装 Windows 时会覆盖掉 MBR，而 Linux 可以选择将开机管理程序安装在 MBR 或者其它分区的启动扇区，并且可以设置开机管理程序的选单。
-### 2. UEFI
+### 2. UEFI
-UEFI 相比于 BIOS 来说功能更为全面，也更为安全。
+UEFI 相比于 BIOS 来说功能更为全面，也更为安全。
-## 挂载
+## 挂载
挂载利用目录作为分区的进入点，也就是说，进入目录之后就可以读取分区的数据。
-
+
-# 文件权限与目录配置
+# 文件权限与目录配置
-## 文件权限概念
+## 文件权限概念
把用户分为三种：文件拥有者、群组以及其它人，对不同的用户有不同的文件权限。
-使用 ls 查看一个文件时，会显示一个文件的信息，例如 drwxr-xr-x. 3 root root 17 May 6 00:14 .config，对这个信息的解释如下：
+使用 ls 查看一个文件时，会显示一个文件的信息，例如 drwxr-xr-x. 3 root root 17 May 6 00:14 .config，对这个信息的解释如下：
-- drwxr-xr-x：文件类型以及权限，第 1 位为文件类型字段，后 9 位为文件权限字段。
-- 3：链接数；
-- root：文件拥有者；
-- root：所属群组；
-- 17：文件大小；
-- May 6 00:14：文件最后被修改的时间；
-- .config：文件名。
+- drwxr-xr-x：文件类型以及权限，第 1 位为文件类型字段，后 9 位为文件权限字段。
+- 3：链接数；
+- root：文件拥有者；
+- root：所属群组；
+- 17：文件大小；
+- May 6 00:14：文件最后被修改的时间；
+- .config：文件名。
常见的文件类型及其含义有：
-- d：目录；
-- -：文件；
-- l：链接文件；
+- d：目录；
+- -：文件；
+- l：链接文件；
-9 位的文件权限字段中，每 3 个为一组，共 3 组，每一组分别代表对文件拥有者、所属群组以及其它人的文件权限。一组权限中的 3 位分别为 r、w、x 权限，表示可读、可写、可执行。
+9 位的文件权限字段中，每 3 个为一组，共 3 组，每一组分别代表对文件拥有者、所属群组以及其它人的文件权限。一组权限中的 3 位分别为 r、w、x 权限，表示可读、可写、可执行。
-## 文件属性以及权限的修改
+## 文件属性以及权限的修改
-### 1. 修改文件所属群组
+### 1. 修改文件所属群组
```html
-# chgrp [-R] groupname dirname/filename
+# chgrp [-R] groupname dirname/filename
-R：递归修改
```
-### 2. 修改文件拥有者
+### 2. 修改文件拥有者
不仅可以修改文件拥有者，也可以修改文件所属群组。
```html
-# chown [-R] 用户名:群组名 dirname/filename
+# chown [-R] 用户名:群组名 dirname/filename
```
-### 3. 修改权限
+### 3. 修改权限
-可以将一组权限用数字来表示，此时一组权限的 3 个位当做二进制数字的位，从左到右每个位的权值为 4、2、1，即每个权限对应的数字权值为 r : 4、w : 2、x : 1。
+可以将一组权限用数字来表示，此时一组权限的 3 个位当做二进制数字的位，从左到右每个位的权值为 4、2、1，即每个权限对应的数字权值为 r : 4、w : 2、x : 1。
```html
-# chmod [-R] xyz dirname/filename
+# chmod [-R] xyz dirname/filename
```
-范例：将 .bashrc 文件的权限修改为 -rwxr-xr--。
+范例：将 .bashrc 文件的权限修改为 -rwxr-xr--。
```html
-# chmod 754 .bashrc
+# chmod 754 .bashrc
```
也可以使用符号来设定权限。
```html
-# chmod [ugoa] [+-=] [rwx] dirname/filename
-- u：拥有者
-- g：所属群组
-- o：其他人
-- a：所有人
-- +：添加权限
-- -：移除权限
-- =：设定权限
+# chmod [ugoa] [+-=] [rwx] dirname/filename
+- u：拥有者
+- g：所属群组
+- o：其他人
+- a：所有人
+- +：添加权限
+- -：移除权限
+- =：设定权限
```
-范例：为 .bashrc 文件的所有用户添加写权限。
+范例：为 .bashrc 文件的所有用户添加写权限。
```html
-# chmod a+w .bashrc
+# chmod a+w .bashrc
```
-## 目录的权限
+## 目录的权限
-文件名不是存储在一个文件的内容中，而是存储在一个文件所在的目录中。因此，拥有文件的 w 权限并不能对文件名进行修改。
+文件名不是存储在一个文件的内容中，而是存储在一个文件所在的目录中。因此，拥有文件的 w 权限并不能对文件名进行修改。
-目录存储文件列表，一个目录的权限也就是对其文件列表的权限。因此，目录的 r 权限表示可以读取文件列表；w 权限表示可以修改文件列表，具体来说，就是添加删除文件，对文件名进行修改；x 权限可以让该目录成为工作目录，x 权限是 r 和 w 权限的基础，如果不能使一个目录成为工作目录，也就没办法读取文件列表以及对文件列表进行修改了。
+目录存储文件列表，一个目录的权限也就是对其文件列表的权限。因此，目录的 r 权限表示可以读取文件列表；w 权限表示可以修改文件列表，具体来说，就是添加删除文件，对文件名进行修改；x 权限可以让该目录成为工作目录，x 权限是 r 和 w 权限的基础，如果不能使一个目录成为工作目录，也就没办法读取文件列表以及对文件列表进行修改了。
-## 文件默认权限
+## 文件默认权限
-文件默认权限：文件默认没有可执行权限，因此为 666，也就是 -rw-rw-rw- 。
-目录默认权限：目录必须要能够进入，也就是必须拥有可执行权限，因此为 777 ，也就是 drwxrwxrwx。
+文件默认权限：文件默认没有可执行权限，因此为 666，也就是 -rw-rw-rw- 。
+目录默认权限：目录必须要能够进入，也就是必须拥有可执行权限，因此为 777 ，也就是 drwxrwxrwx。
-可以通过 umask 设置或者查看文件的默认权限，通常以掩码的形式来表示，例如 002 表示其它用户的权限去除了一个 2 的权限，也就是写权限，因此建立新文件时默认的权限为 -rw-rw-r-- 。
+可以通过 umask 设置或者查看文件的默认权限，通常以掩码的形式来表示，例如 002 表示其它用户的权限去除了一个 2 的权限，也就是写权限，因此建立新文件时默认的权限为 -rw-rw-r-- 。
-## 目录配置
+## 目录配置
-为了使不同 Linux 发行版本的目录结构保持一致性，Filesystem Hierarchy Standard (FHS) 规定了 Linux 的目录结构。最基础的三个目录如下：
+为了使不同 Linux 发行版本的目录结构保持一致性，Filesystem Hierarchy Standard (FHS) 规定了 Linux 的目录结构。最基础的三个目录如下：
-- / (root, 根目录)
-- /usr (unix software resource)：所有系统默认软件都会安装到这个目录；
-- /var (variable)：存放系统或程序运行过程中的数据文件。
+- / (root, 根目录)
+- /usr (unix software resource)：所有系统默认软件都会安装到这个目录；
+- /var (variable)：存放系统或程序运行过程中的数据文件。
完整的目录树如下：
-
+
-# 文件与目录
+# 文件与目录
-## 文件时间
+## 文件时间
-1. modification time (mtime)：文件的内容更新就会更新；
-2. status time (ctime)：文件的状态（权限、属性）更新就会更新；
-3. access time (atime)：读取文件时就会更新。
+1. modification time (mtime)：文件的内容更新就会更新；
+2. status time (ctime)：文件的状态（权限、属性）更新就会更新；
+3. access time (atime)：读取文件时就会更新。
-## 文件与目录的基本操作
+## 文件与目录的基本操作
-### 1. ls
+### 1. ls
列出文件或者目录的信息，目录的信息就是其中包含的文件。
```html
-# ls [-aAdfFhilnrRSt] file|dir
--a ：列出全部的文件
--d ：仅列出目录本身
--l ：以长数据串行列出，包含文件的属性与权限等等数据
+# ls [-aAdfFhilnrRSt] file|dir
+-a ：列出全部的文件
+-d ：仅列出目录本身
+-l ：以长数据串行列出，包含文件的属性与权限等等数据
```
-### 2. cp
+### 2. cp
复制操作。
如果源文件有两个以上，则目的文件一定要是目录才行。
```html
-cp [-adfilprsu] source destination
--a ：相当于 -dr --preserve=all 的意思，至于 dr 请参考下列说明
--d ：若来源文件为链接文件，则复制链接文件属性而非文件本身
--i ：若目标文件已经存在时，在覆盖前会先询问
--p ：连同文件的属性一起复制过去
--r ：递归持续复制
--u ：destination 比 source 旧才更新 destination，或 destination 不存在的情况下才复制
---preserve=all ：除了 -p 的权限相关参数外，还加入 SELinux 的属性, links, xattr 等也复制了
+cp [-adfilprsu] source destination
+-a ：相当于 -dr --preserve=all 的意思，至于 dr 请参考下列说明
+-d ：若来源文件为链接文件，则复制链接文件属性而非文件本身
+-i ：若目标文件已经存在时，在覆盖前会先询问
+-p ：连同文件的属性一起复制过去
+-r ：递归持续复制
+-u ：destination 比 source 旧才更新 destination，或 destination 不存在的情况下才复制
+--preserve=all ：除了 -p 的权限相关参数外，还加入 SELinux 的属性, links, xattr 等也复制了
```
-### 3. rm
+### 3. rm
移除操作。
```html
-# rm [-fir] 文件或目录
--r ：递归删除
+# rm [-fir] 文件或目录
+-r ：递归删除
```
-### 4. mv
+### 4. mv
移动操作。
```html
-# mv [-fiu] source destination
-# mv [options] source1 source2 source3 .... directory
--f ： force 强制的意思，如果目标文件已经存在，不会询问而直接覆盖
+# mv [-fiu] source destination
+# mv [options] source1 source2 source3 .... directory
+-f ： force 强制的意思，如果目标文件已经存在，不会询问而直接覆盖
```
-## 获取文件内容
+## 获取文件内容
-### 1. cat
+### 1. cat
取得文件内容。
```html
-# cat [-AbEnTv] filename
--n ：打印出行号，连同空白行也会有行号，-b 不会
+# cat [-AbEnTv] filename
+-n ：打印出行号，连同空白行也会有行号，-b 不会
```
-### 2. tac
+### 2. tac
-是 cat 的反向操作，从最后一行开始打印。
+是 cat 的反向操作，从最后一行开始打印。
-### 3. more
+### 3. more
可以一页一页查看文件内容，和文本编辑器类似。
-### 4. less
+### 4. less
-和 more 类似。
+和 more 类似。
-### 5. head
+### 5. head
可以取得文件前几行。
```html
-# head [-n number] filename
--n ：后面接数字，代表显示几行的意思
+# head [-n number] filename
+-n ：后面接数字，代表显示几行的意思
```
-### 6. tail
+### 6. tail
-是 head 的反向操作，只是取得是后几行。
+是 head 的反向操作，只是取得是后几行。
-### 7. od
+### 7. od
可以以字符或者十六进制的形式显示二进制文件。
-### 8. touch
+### 8. touch
修改文件时间或者建立新文件。
```html
-# touch [-acdmt] filename
--a ： 更新 atime
--c ： 更新 ctime，若该文件不存在则不建立新文件
--m ： 更新 mtime
--d ： 后面可以接欲更新的日期而不用当前的日期，也可以使用 --date="日期或时间"
--t ： 后面可以接欲更新的时间而不用当前的时间，格式为[YYYYMMDDhhmm]
+# touch [-acdmt] filename
+-a ： 更新 atime
+-c ： 更新 ctime，若该文件不存在则不建立新文件
+-m ： 更新 mtime
+-d ： 后面可以接欲更新的日期而不用当前的日期，也可以使用 --date="日期或时间"
+-t ： 后面可以接欲更新的时间而不用当前的时间，格式为[YYYYMMDDhhmm]
```
-## 指令与文件搜索
+## 指令与文件搜索
-### 1. which
+### 1. which
指令搜索。
```html
-# which [-a] command
--a ：将所有指令列出，而不是只列第一个
+# which [-a] command
+-a ：将所有指令列出，而不是只列第一个
```
-### 2. whereis
+### 2. whereis
-whereis 搜索文件的速度比较快，因为它只搜索几个特定的目录。
+whereis 搜索文件的速度比较快，因为它只搜索几个特定的目录。
```html
-# whereis [-bmsu] dirname/filename
+# whereis [-bmsu] dirname/filename
```
-### 3. locate
+### 3. locate
-locate 可以用关键字或者正则表达式进行搜索。
+locate 可以用关键字或者正则表达式进行搜索。
-locate 使用 /var/lib/mlocate/ 这个数据库来进行搜索，它存储在内存中，并且每天更新一次，所以无法用 locate 搜索新建的文件。可以使用 updatedb 来立即更新数据库。
+locate 使用 /var/lib/mlocate/ 这个数据库来进行搜索，它存储在内存中，并且每天更新一次，所以无法用 locate 搜索新建的文件。可以使用 updatedb 来立即更新数据库。
```html
-# locate [-ir] keyword
+# locate [-ir] keyword
-r：接正则表达式
```
-### 4. find
+### 4. find
-find 可以使用文件的属性和权限进行搜索。
+find 可以使用文件的属性和权限进行搜索。
```html
-# find filename [option]
+# find filename [option]
```
-#### 4.1 与时间有关的选项
+#### 4.1 与时间有关的选项
```html
--mtime n ：列出在 n 天前的那一天修改过内容的文件
--mtime +n ：列出在 n 天之前 (不含 n 天本身) 修改过内容的文件
--mtime -n ：列出在 n 天之内 (含 n 天本身) 修改过内容的文件
--newer file ： 列出比 file 更新的文件
+-mtime n ：列出在 n 天前的那一天修改过内容的文件
+-mtime +n ：列出在 n 天之前 (不含 n 天本身) 修改过内容的文件
+-mtime -n ：列出在 n 天之内 (含 n 天本身) 修改过内容的文件
+-newer file ： 列出比 file 更新的文件
```
-+4、4 和 -4 的指示的时间范围如下：
++4、4 和 -4 的指示的时间范围如下：
-
+
-#### 4.2 与文件拥有者和所属群组有关的选项
+#### 4.2 与文件拥有者和所属群组有关的选项
```html
--uid n
--gid n
--user name
--group name
--nouser ：搜索拥有者不存在 /etc/passwd 的文件
--nogroup：搜索所属群组不存在于 /etc/group 的文件
+-uid n
+-gid n
+-user name
+-group name
+-nouser ：搜索拥有者不存在 /etc/passwd 的文件
+-nogroup：搜索所属群组不存在于 /etc/group 的文件
```
-#### 4.3 与文件权限和名称有关的选项
+#### 4.3 与文件权限和名称有关的选项
```html
--name filename
--size [+-]SIZE：搜寻比 SIZE 还要大 (+) 或小 (-) 的文件。这个 SIZE 的规格有：c: 代表 byte，k: 代表 1024bytes。所以，要找比 50KB 还要大的文件，就是 -size +50k
--type TYPE
--perm mode ：搜索权限等于 mode 的文件
--perm -mode ：搜索权限包含 mode 的文件
--perm /mode ：搜索权限包含任一 mode 的文件
+-name filename
+-size [+-]SIZE：搜寻比 SIZE 还要大 (+) 或小 (-) 的文件。这个 SIZE 的规格有：c: 代表 byte，k: 代表 1024bytes。所以，要找比 50KB 还要大的文件，就是 -size +50k
+-type TYPE
+-perm mode ：搜索权限等于 mode 的文件
+-perm -mode ：搜索权限包含 mode 的文件
+-perm /mode ：搜索权限包含任一 mode 的文件
```
-# 磁盘与文件系统
+# 磁盘与文件系统
-## 文件系统的组成
+## 文件系统的组成
对分区进行格式化是为了在分区上建立文件系统。一个分区通常只能格式化为一个文件系统，但是磁盘阵列等技术可以将一个分区格式化为多个文件系统，因此只有文件系统能被挂载，而分区不能被挂载。
文件系统有以下三个结构：
-1. superblock：记录文件系统的整体信息，包括 inode 和 block 的总量、使用量、剩余量，以及文件系统的格式与相关信息等；
-2. inode：一个文件占用一个 inode，记录文件的属性，同时记录此文件的内容所在的 block 号码；
-3. block：记录文件的内容，文件太大时，会占用多个 block。
+1. superblock：记录文件系统的整体信息，包括 inode 和 block 的总量、使用量、剩余量，以及文件系统的格式与相关信息等；
+2. inode：一个文件占用一个 inode，记录文件的属性，同时记录此文件的内容所在的 block 号码；
+3. block：记录文件的内容，文件太大时，会占用多个 block。
-当要读取一个文件的内容时，先在 inode 中去查找文件内容所在的所有 block，然后把所有 block 的内容读出来。
+当要读取一个文件的内容时，先在 inode 中去查找文件内容所在的所有 block，然后把所有 block 的内容读出来。
-磁盘碎片是指一个文件内容所在的 block 过于分散。
+磁盘碎片是指一个文件内容所在的 block 过于分散。
-Ext2 文件系统使用了上述的文件结构，并在此之上加入了 block 群组的概念，也就是将一个文件系统划分为多个 block 群组，方便管理。
+Ext2 文件系统使用了上述的文件结构，并在此之上加入了 block 群组的概念，也就是将一个文件系统划分为多个 block 群组，方便管理。
-
+
-## inode
+## inode
-Ext2 文件系统支持的 block 大小有 1k、2k 和 4k 三种，不同的 block 大小限制了单一文件的大小。而每个 inode 大小是固定为 128 bytes。
+Ext2 文件系统支持的 block 大小有 1k、2k 和 4k 三种，不同的 block 大小限制了单一文件的大小。而每个 inode 大小是固定为 128 bytes。
-inode 中记录了文件内容所在的 block，但是每个 block 非常小，一个大文件随便都需要几十万的 block。而一个 inode 大小有限，无法直接引用这么多 block。因此引入了间接、双间接、三间接引用。间接引用是指，让 inode 记录的引用 block 块当成 inode 用来记录引用信息。
+inode 中记录了文件内容所在的 block，但是每个 block 非常小，一个大文件随便都需要几十万的 block。而一个 inode 大小有限，无法直接引用这么多 block。因此引入了间接、双间接、三间接引用。间接引用是指，让 inode 记录的引用 block 块当成 inode 用来记录引用信息。
-
+
-inode 具体包含以下信息：
+inode 具体包含以下信息：
-- 该文件的存取模式 (read/write/excute)；
-- 该文件的拥有者与群组 (owner/group)；
-- 该文件的容量；
-- 该文件建立或状态改变的时间 (ctime)；
-- 最近一次的读取时间 (atime)；
-- 最近修改的时间 (mtime)；
-- 定义文件特性的旗标 (flag)，如 SetUID...；
-- 该文件真正内容的指向 (pointer)。
+- 该文件的存取模式 (read/write/excute)；
+- 该文件的拥有者与群组 (owner/group)；
+- 该文件的容量；
+- 该文件建立或状态改变的时间 (ctime)；
+- 最近一次的读取时间 (atime)；
+- 最近修改的时间 (mtime)；
+- 定义文件特性的旗标 (flag)，如 SetUID...；
+- 该文件真正内容的指向 (pointer)。
-## 目录的 inode 与 block
+## 目录的 inode 与 block
-建立一个目录时，会分配一个 inode 与至少一个 block。block 记录的内容是目录下所有文件的 inode 编号以及文件名。可以看出文件的 inode 本身不记录文件名，文件名记录在目录中，因此新增文件、删除文件、更改文件名这些操作与目录的 w 权限有关。
+建立一个目录时，会分配一个 inode 与至少一个 block。block 记录的内容是目录下所有文件的 inode 编号以及文件名。可以看出文件的 inode 本身不记录文件名，文件名记录在目录中，因此新增文件、删除文件、更改文件名这些操作与目录的 w 权限有关。
-## 实体链接与符号链接
+## 实体链接与符号链接
```html
-# ln [-sf] source_filename dist_filename
--s ：默认是 hard link，加 -s 为 symbolic link
--f ：如果目标文件存在时，先删除目标文件
+# ln [-sf] source_filename dist_filename
+-s ：默认是 hard link，加 -s 为 symbolic link
+-f ：如果目标文件存在时，先删除目标文件
```
-### 1. 实体链接
+### 1. 实体链接
-hard link 只是在某个目录下新增一个条目，使得新增的条目链接到文件的 inode 上。删除任意一个条目，文件还是存在，只要引用数量不为 0。
+hard link 只是在某个目录下新增一个条目，使得新增的条目链接到文件的 inode 上。删除任意一个条目，文件还是存在，只要引用数量不为 0。
-有以下限制：不能跨越 File System；不能对目录进行链接。
+有以下限制：不能跨越 File System；不能对目录进行链接。
```html
-# ln /etc/crontab .
-# ll -i /etc/crontab crontab
-34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 crontab
-34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 /etc/crontab
+# ln /etc/crontab .
+# ll -i /etc/crontab crontab
+34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 crontab
+34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 /etc/crontab
```
-### 2. 符号链接
+### 2. 符号链接
-symbolic link 可以理解为 Windows 的快捷方式，通过建立一个独立的文件，这个文件的数据的读取指向链接的那个文件。当源文件被删除了，链接文件就打不开了。
+symbolic link 可以理解为 Windows 的快捷方式，通过建立一个独立的文件，这个文件的数据的读取指向链接的那个文件。当源文件被删除了，链接文件就打不开了。
-symbolic link 可以为目录建立链接。
+symbolic link 可以为目录建立链接。
```html
-# ll -i /etc/crontab /root/crontab2
-34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 /etc/crontab
-53745909 lrwxrwxrwx. 1 root root 12 Jun 23 22:31 /root/crontab2 -> /etc/crontab
+# ll -i /etc/crontab /root/crontab2
+34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 /etc/crontab
+53745909 lrwxrwxrwx. 1 root root 12 Jun 23 22:31 /root/crontab2 -> /etc/crontab
```
-# 压缩与打包
+# 压缩与打包
-## 压缩
+## 压缩
-Linux 底下有很多压缩文件的扩展名，常见的如下：
+Linux 底下有很多压缩文件的扩展名，常见的如下：
-| 扩展名 | 压缩程序 |
-| -- | -- |
-| \*.Z | compress |
-|\*.zip | zip |
-|\*.gz | gzip|
-|\*.bz2 | bzip2 |
-|\*.xz | xz |
-|\*.tar | tar 程序打包的数据，没有经过压缩 |
-|\*.tar.gz | tar 程序打包的文件，经过 gzip 的压缩 |
-|\*.tar.bz2 | tar 程序打包的文件，经过 bzip2 的压缩 |
-|\*.tar.xz | tar 程序打包的文件，经过 xz 的压缩 |
+| 扩展名 | 压缩程序 |
+| -- | -- |
+| \*.Z | compress |
+|\*.zip | zip |
+|\*.gz | gzip|
+|\*.bz2 | bzip2 |
+|\*.xz | xz |
+|\*.tar | tar 程序打包的数据，没有经过压缩 |
+|\*.tar.gz | tar 程序打包的文件，经过 gzip 的压缩 |
+|\*.tar.bz2 | tar 程序打包的文件，经过 bzip2 的压缩 |
+|\*.tar.xz | tar 程序打包的文件，经过 xz 的压缩 |
-### 1. gzip
+### 1. gzip
-gzip 是 Linux 使用最广的压缩指令，可以解开 compress、zip 与 gzip 所压缩的文件。
+gzip 是 Linux 使用最广的压缩指令，可以解开 compress、zip 与 gzip 所压缩的文件。
-经过 gzip 压缩过，源文件就不存在了。
+经过 gzip 压缩过，源文件就不存在了。
-有 9 个不同的压缩等级可以使用。
+有 9 个不同的压缩等级可以使用。
-可以使用 zcat、zmore、zless 来读取压缩文件的内容。
+可以使用 zcat、zmore、zless 来读取压缩文件的内容。
```html
-$ gzip [-cdtv#] filename
--c ：将压缩的数据输出到屏幕上
--d ：解压缩
--t ：检验压缩文件是否出错
--v ：显示压缩比等信息
--# ： # 为数字的意思，代表压缩等级，数字越大压缩比越高，默认为 6
+$ gzip [-cdtv#] filename
+-c ：将压缩的数据输出到屏幕上
+-d ：解压缩
+-t ：检验压缩文件是否出错
+-v ：显示压缩比等信息
+-# ： # 为数字的意思，代表压缩等级，数字越大压缩比越高，默认为 6
```
-### 2. bzip2
+### 2. bzip2
-提供比 gzip 更高的压缩比。
+提供比 gzip 更高的压缩比。
查看命令：bzcat、bzmore、bzless、bzgrep。
```html
-$ bzip2 [-cdkzv#] filename
--k ：保留源文件
+$ bzip2 [-cdkzv#] filename
+-k ：保留源文件
```
-### 3. xz
+### 3. xz
-提供比 bzip2 更佳的压缩比。
+提供比 bzip2 更佳的压缩比。
-可以看到，gzip、bzip2、xz 的压缩比不断优化。不过要注意，压缩比越高，压缩的时间也越长。
+可以看到，gzip、bzip2、xz 的压缩比不断优化。不过要注意，压缩比越高，压缩的时间也越长。
查看命令：xzcat、xzmore、xzless、xzgrep。
```html
-$ xz [-dtlkc#] filename
+$ xz [-dtlkc#] filename
```
-## 打包
+## 打包
-压缩指令只能对一个文件进行压缩，而打包能够将多个文件打包成一个大文件。tar 不仅可以用于打包，也可以使用 gip、bzip2、xz 将打包文件进行压缩。
+压缩指令只能对一个文件进行压缩，而打包能够将多个文件打包成一个大文件。tar 不仅可以用于打包，也可以使用 gip、bzip2、xz 将打包文件进行压缩。
```html
-$ tar [-z|-j|-J] [cv] [-f 新建的 tar 文件] filename... ==打包压缩
-$ tar [-z|-j|-J] [tv] [-f 已有的 tar 文件] ==查看
-$ tar [-z|-j|-J] [xv] [-f 已有的 tar 文件] [-C 目录] ==解压缩
--z ：使用 zip；
--j ：使用 bzip2；
--J ：使用 xz；
--c ：新建打包文件；
--t ：查看打包文件里面有哪些文件；
--x ：解打包或解压缩的功能；
--v ：在压缩/解压缩的过程中，显示正在处理的文件名；
--f : filename：要处理的文件；
--C 目录 ： 在特定目录解压缩。
+$ tar [-z|-j|-J] [cv] [-f 新建的 tar 文件] filename... ==打包压缩
+$ tar [-z|-j|-J] [tv] [-f 已有的 tar 文件] ==查看
+$ tar [-z|-j|-J] [xv] [-f 已有的 tar 文件] [-C 目录] ==解压缩
+-z ：使用 zip；
+-j ：使用 bzip2；
+-J ：使用 xz；
+-c ：新建打包文件；
+-t ：查看打包文件里面有哪些文件；
+-x ：解打包或解压缩的功能；
+-v ：在压缩/解压缩的过程中，显示正在处理的文件名；
+-f : filename：要处理的文件；
+-C 目录 ： 在特定目录解压缩。
```
-| 使用方式 | 命令 |
-| --- | --- |
-| 打包压缩 | tar -jcv -f filename.tar.bz2 要被压缩的文件或目录名称 |
-| 查 看 | tar -jtv -f filename.tar.bz2 |
-| 解压缩 | tar -jxv -f filename.tar.bz2 -C 要解压缩的目录 |
+| 使用方式 | 命令 |
+| --- | --- |
+| 打包压缩 | tar -jcv -f filename.tar.bz2 要被压缩的文件或目录名称 |
+| 查 看 | tar -jtv -f filename.tar.bz2 |
+| 解压缩 | tar -jxv -f filename.tar.bz2 -C 要解压缩的目录 |
-# Bash
+# Bash
-可以通过 Shell 请求内核提供服务，Bash 正是 Shell 的一种。
+可以通过 Shell 请求内核提供服务，Bash 正是 Shell 的一种。
-## Bash 特性
+## Bash 特性
-**1. 命令历史**
+**1. 命令历史**
-记录使用过的命令。本次登录所执行的命令都会暂时存放到内存中， ~/.bash_history 文件中记录的是前一次登录所执行过的命令。
+记录使用过的命令。本次登录所执行的命令都会暂时存放到内存中， \~/.bash_history 文件中记录的是前一次登录所执行过的命令。
-**2. 命令与文件补全**
+**2. 命令与文件补全**
快捷键：tab
-**3. 命名别名**
+**3. 命名别名**
-例如 lm 是 ls -al 的别名。
+例如 lm 是 ls -al 的别名。
-**4. shell scripts**
+**4. shell scripts**
-**5. 通配符**
+**5. 通配符**
-例如 ls -l /usr/bin/X\* 列出 /usr/bin 下面所有以 X 开头的文件。
+例如 ls -l /usr/bin/X\* 列出 /usr/bin 下面所有以 X 开头的文件。
-## 变量操作
+## 变量操作
-- 对一个变量赋值直接使用 = ；
-- 对变量取用需要在变量前加上 \$ ，也可以用 \${} 的形式；
-- 输出变量使用 echo 命令。
+- 对一个变量赋值直接使用 = ；
+- 对变量取用需要在变量前加上 \$ ，也可以用 \${} 的形式；
+- 输出变量使用 echo 命令。
```bash
-$ var=abc
-$ echo $var
-$ echo ${var}
+$ var=abc
+$ echo $var
+$ echo ${var}
```
-变量内容如果有空格，需要使用双引号或者单引号。双引号内的特殊字符可以保留原本特性，例如 var="lang is \$LANG"，则 var 的值为 lang is zh_TW.UTF-8；而单引号内的特殊字符就是特殊字符本身，例如 var='lang is \$LANG'，则 var 的值为 lang is \$LANG。
+变量内容如果有空格，需要使用双引号或者单引号。双引号内的特殊字符可以保留原本特性，例如 var="lang is \$LANG"，则 var 的值为 lang is zh_TW.UTF-8；而单引号内的特殊字符就是特殊字符本身，例如 var='lang is \$LANG'，则 var 的值为 lang is \$LANG。
-可以使用 \`指令\` 或者 \$(指令) 的方式将指令的执行结果赋值给变量。例如 version=\$(uname -r)，则 version 的值为 3.10.0-229.el7.x86_64。
+可以使用 \`指令\` 或者 \$(指令) 的方式将指令的执行结果赋值给变量。例如 version=\$(uname -r)，则 version 的值为 3.10.0-229.el7.x86_64。
-可以使用 export 命令将自定义变量转成环境变量，环境变量可以在子程序中使用，所谓子程序就是由当前 Bash 而产生的子 Bash。
+可以使用 export 命令将自定义变量转成环境变量，环境变量可以在子程序中使用，所谓子程序就是由当前 Bash 而产生的子 Bash。
-Bash 的变量可以声明为数组和整数数字。注意数字类型没有浮点数。如果不进行声明，默认是字符串类型。变量的声明使用 declare 命令：
+Bash 的变量可以声明为数组和整数数字。注意数字类型没有浮点数。如果不进行声明，默认是字符串类型。变量的声明使用 declare 命令：
```html
-$ declare [-aixr] variable
--a ： 定义为数组类型
--i ： 定义为整数类型
--x ： 定义为环境变量
--r ： 定义为 readonly 类型
+$ declare [-aixr] variable
+-a ： 定义为数组类型
+-i ： 定义为整数类型
+-x ： 定义为环境变量
+-r ： 定义为 readonly 类型
```
-使用 [ ] 来对数组进行索引操作：
+使用 [ ] 来对数组进行索引操作：
```bash
-$ array[1]=a
-$ array[2]=b
-$ echo ${array[1]}
+$ array[1]=a
+$ array[2]=b
+$ echo ${array[1]}
```
-## 指令搜索顺序
+## 指令搜索顺序
-1. 以绝对或相对路径来执行指令，例如 /bin/ls 或者 ./ls ；
-2. 由别名找到该指令来执行；
-3. 由 Bash 内建的指令来执行；
-4. 按 \$PATH 变量指定的搜索路径的顺序找到第一个指令来执行。
+1. 以绝对或相对路径来执行指令，例如 /bin/ls 或者 ./ls ；
+2. 由别名找到该指令来执行；
+3. 由 Bash 内建的指令来执行；
+4. 按 \$PATH 变量指定的搜索路径的顺序找到第一个指令来执行。
-## 数据流重定向
+## 数据流重定向
重定向就是使用文件代替标准输入、标准输出和标准错误输出。
-1. 标准输入 (stdin) ：代码为 0 ，使用 < 或 << ；
-2. 标准输出 (stdout) ：代码为 1 ，使用 > 或 >> ；
-3. 标准错误输出 (stderr)：代码为 2 ，使用 2> 或 2>> ；
+1. 标准输入 (stdin) ：代码为 0 ，使用 < 或 << ；
+2. 标准输出 (stdout) ：代码为 1 ，使用 > 或 >> ；
+3. 标准错误输出 (stderr)：代码为 2 ，使用 2> 或 2>> ；
其中，有一个箭头的表示以覆盖的方式重定向，而有两个箭头的表示以追加的方式重定向。
-可以将不需要的标准输出以及标准错误输出重定向到 /dev/null，相当于扔进垃圾箱。
+可以将不需要的标准输出以及标准错误输出重定向到 /dev/null，相当于扔进垃圾箱。
-如果需要将标准输出以及标准错误输出同时重定向到一个文件，需要将某个输出转换为另一个输出，例如 2>&1 表示将标准错误输出转换为标准输出。
+如果需要将标准输出以及标准错误输出同时重定向到一个文件，需要将某个输出转换为另一个输出，例如 2>&1 表示将标准错误输出转换为标准输出。
```bash
-$ find /home -name .bashrc > list 2>&1
+$ find /home -name .bashrc > list 2>&1
```
-## 管线指令
+## 管线指令
-管线是将一个命令的标准输出作为另一个命令的标准输入，在数据需要经过多个步骤的处理之后才能得到我们想要的内容时就可以使用管线。在命令之间使用 | 分隔各个管线命令。
+管线是将一个命令的标准输出作为另一个命令的标准输入，在数据需要经过多个步骤的处理之后才能得到我们想要的内容时就可以使用管线。在命令之间使用 | 分隔各个管线命令。
```bash
-$ ls -al /etc | less
+$ ls -al /etc | less
```
-### 1. 提取指令：cut
+### 1. 提取指令：cut
-cut 对数据进行切分，取出想要的部分。提取过程一行一行地进行。
+cut 对数据进行切分，取出想要的部分。提取过程一行一行地进行。
```html
-$ cut
--d ：分隔符
--f ：经过 -d 分隔后，使用 -f n 取出第 n 个区间
--c ：以字符为单位取出区间
+$ cut
+-d ：分隔符
+-f ：经过 -d 分隔后，使用 -f n 取出第 n 个区间
+-c ：以字符为单位取出区间
```
-范例 1：last 将显示的登入者的信息，要求仅显示用户名。
+范例 1：last 将显示的登入者的信息，要求仅显示用户名。
```html
-$ last
-root pts/1 192.168.201.101 Sat Feb 7 12:35 still logged in
-root pts/1 192.168.201.101 Fri Feb 6 12:13 - 18:46 (06:33)
-root pts/1 192.168.201.254 Thu Feb 5 22:37 - 23:53 (01:16)
+$ last
+root pts/1 192.168.201.101 Sat Feb 7 12:35 still logged in
+root pts/1 192.168.201.101 Fri Feb 6 12:13 - 18:46 (06:33)
+root pts/1 192.168.201.254 Thu Feb 5 22:37 - 23:53 (01:16)
-$ last | cut -d ' ' -f 1
+$ last | cut -d ' ' -f 1
```
-范例 2：将 export 输出的讯息，取得第 12 字符以后的所有字符串。
+范例 2：将 export 输出的讯息，取得第 12 字符以后的所有字符串。
```html
-$ export
-declare -x HISTCONTROL="ignoredups"
-declare -x HISTSIZE="1000"
-declare -x HOME="/home/dmtsai"
-declare -x HOSTNAME="study.centos.vbird"
+$ export
+declare -x HISTCONTROL="ignoredups"
+declare -x HISTSIZE="1000"
+declare -x HOME="/home/dmtsai"
+declare -x HOSTNAME="study.centos.vbird"
.....(其他省略).....
-$ export | cut -c 12
+$ export | cut -c 12
```
-### 2. 排序命令：sort、uniq
+### 2. 排序命令：sort、uniq
-**sort** 进行排序。
+**sort** 进行排序。
```html
-$ sort [-fbMnrtuk] [file or stdin]
--f ：忽略大小写
--b ：忽略最前面的空格
--M ：以月份的名字来排序，例如 JAN，DEC
--n ：使用数字
--r ：反向排序
--u ：相当于 unique，重复的内容只出现一次
--t ：分隔符，默认为 tab
--k ：指定排序的区间
+$ sort [-fbMnrtuk] [file or stdin]
+-f ：忽略大小写
+-b ：忽略最前面的空格
+-M ：以月份的名字来排序，例如 JAN，DEC
+-n ：使用数字
+-r ：反向排序
+-u ：相当于 unique，重复的内容只出现一次
+-t ：分隔符，默认为 tab
+-k ：指定排序的区间
```
-范例：/etc/passwd 内容是以 : 来分隔的，以第三栏来排序。
+范例：/etc/passwd 内容是以 : 来分隔的，以第三栏来排序。
```html
-$ cat /etc/passwd | sort -t ':' -k 3
+$ cat /etc/passwd | sort -t ':' -k 3
root:x:0:0:root:/root:/bin/bash
dmtsai:x:1000:1000:dmtsai:/home/dmtsai:/bin/bash
alex:x:1001:1002::/home/alex:/bin/bash
arod:x:1002:1003::/home/arod:/bin/bash
```
-**uniq** 可以将重复的数据只取一个。
+**uniq** 可以将重复的数据只取一个。
```html
-$ uniq [-ic]
--i ：忽略大小写
--c ：进行计数
+$ uniq [-ic]
+-i ：忽略大小写
+-c ：进行计数
```
范例：取得每个人的登录总次数
```html
-$ last | cut -d ' ' -f 1 | sort | uniq -c
+$ last | cut -d ' ' -f 1 | sort | uniq -c
1
-6 (unknown
-47 dmtsai
-4 reboot
-7 root
-1 wtmp
+6 (unknown
+47 dmtsai
+4 reboot
+7 root
+1 wtmp
```
-### 3. 双向输出重定向：tee
+### 3. 双向输出重定向：tee
-输出重定向会将输出内容重定向到文件中，而 **tee** 不仅能够完成这个功能，还能保留屏幕上的输出。也就是说，使用 tee 指令，一个输出会同时传送到文件和屏幕上。
+输出重定向会将输出内容重定向到文件中，而 **tee** 不仅能够完成这个功能，还能保留屏幕上的输出。也就是说，使用 tee 指令，一个输出会同时传送到文件和屏幕上。
```html
-$ tee [-a] file
+$ tee [-a] file
```
-### 4. 字符转换指令：tr、col、expand、join、paste
+### 4. 字符转换指令：tr、col、expand、join、paste
-**tr** 用来删除一行中的字符，或者对字符进行替换。
+**tr** 用来删除一行中的字符，或者对字符进行替换。
```html
-$ tr [-ds] SET1 ...
--d ： 删除行中 SET1 这个字符串
+$ tr [-ds] SET1 ...
+-d ： 删除行中 SET1 这个字符串
```
-范例，将 last 输出的信息所有小写转换为大写。
+范例，将 last 输出的信息所有小写转换为大写。
```html
-$ last | tr '[a-z]' '[A-Z]'
+$ last | tr '[a-z]' '[A-Z]'
```
- **col** 将 tab 字符转为空格字符。
+ **col** 将 tab 字符转为空格字符。
```html
-$ col [-xb]
--x ： 将 tab 键转换成对等的空格键
+$ col [-xb]
+-x ： 将 tab 键转换成对等的空格键
```
-**expand** 将 tab 转换一定数量的空格，默认是 8 个。
+**expand** 将 tab 转换一定数量的空格，默认是 8 个。
```html
-$ expand [-t] file
--t ：tab 转为空格的数量
+$ expand [-t] file
+-t ：tab 转为空格的数量
```
-**join** 将有相同数据的那一行合并在一起。
+**join** 将有相同数据的那一行合并在一起。
```html
-$ join [-ti12] file1 file2
--t ：分隔符，默认为空格
--i ：忽略大小写的差异
--1 ：第一个文件所用的比较字段
--2 ：第二个文件所用的比较字段
+$ join [-ti12] file1 file2
+-t ：分隔符，默认为空格
+-i ：忽略大小写的差异
+-1 ：第一个文件所用的比较字段
+-2 ：第二个文件所用的比较字段
```
-**paste** 直接将两行粘贴在一起。
+**paste** 直接将两行粘贴在一起。
```html
-$ paste [-d] file1 file2
--d ：分隔符，默认为 tab
+$ paste [-d] file1 file2
+-d ：分隔符，默认为 tab
```
-### 5. 分区指令：split
+### 5. 分区指令：split
-**split** 将一个文件划分成多个文件。
+**split** 将一个文件划分成多个文件。
```html
-$ split [-bl] file PREFIX
--b ：以大小来进行分区，可加单位，例如 b, k, m 等
--l ：以行数来进行分区。
-- PREFIX ：分区文件的前导名称
+$ split [-bl] file PREFIX
+-b ：以大小来进行分区，可加单位，例如 b, k, m 等
+-l ：以行数来进行分区。
+- PREFIX ：分区文件的前导名称
```
-# 正规表示法与文件格式化处理
+# 正规表示法与文件格式化处理
-## grep
+## grep
使用正则表示式把匹配的行提取出来。
```html
-$ grep [-acinv] [--color=auto] 搜寻字符串 filename
--a ： 将 binary 文件以 text 文件的方式进行搜寻
--c ： 计算找到个数
--i ： 忽略大小写
--n ： 输出行号
--v ： 反向选择，亦即显示出没有 搜寻字符串 内容的那一行
---color=auto ：找到的关键字加颜色显示
+$ grep [-acinv] [--color=auto] 搜寻字符串 filename
+-a ： 将 binary 文件以 text 文件的方式进行搜寻
+-c ： 计算找到个数
+-i ： 忽略大小写
+-n ： 输出行号
+-v ： 反向选择，亦即显示出没有 搜寻字符串 内容的那一行
+--color=auto ：找到的关键字加颜色显示
```
-范例：把含有 the 字符串的行提取出来（注意默认会有 --color=auto 选项，因此以下内容在 Linux 中有颜色显示 the 字符串）
+范例：把含有 the 字符串的行提取出来（注意默认会有 --color=auto 选项，因此以下内容在 Linux 中有颜色显示 the 字符串）
```html
-$ grep -n 'the' regular_express.txt
-8:I can't finish the test.
-12:the symbol '*' is represented as start.
-15:You are the best is mean you are the no. 1.
-16:The world Happy is the same with "glad".
-18:google is the best tools for search keyword
+$ grep -n 'the' regular_express.txt
+8:I can't finish the test.
+12:the symbol '*' is represented as start.
+15:You are the best is mean you are the no. 1.
+16:The world Happy is the same with "glad".
+18:google is the best tools for search keyword
```
-因为 { 与 } 的符号在 shell 是有特殊意义的，因此必须要使用使用转义字符进行转义。
+因为 { 与 } 的符号在 shell 是有特殊意义的，因此必须要使用使用转义字符进行转义。
```html
-$ grep -n 'go\{2,5\}g' regular_express.txt
+$ grep -n 'go\{2,5\}g' regular_express.txt
```
-## printf
+## printf
用于格式化输出。
-它不属于管道命令，在给 printf 传数据时需要使用 $( ) 形式。
+它不属于管道命令，在给 printf 传数据时需要使用 $( ) 形式。
```html
-$ printf '%10s %5i %5i %5i %8.2f \n' $(cat printf.txt)
- DmTsai 80 60 92 77.33
- VBird 75 55 80 70.00
- Ken 60 90 70 73.33
+$ printf '%10s %5i %5i %5i %8.2f \n' $(cat printf.txt)
+ DmTsai 80 60 92 77.33
+ VBird 75 55 80 70.00
+ Ken 60 90 70 73.33
```
-## awk
+## awk
```html
-$ awk '条件类型 1 {动作 1} 条件类型 2 {动作 2} ...' filename
+$ awk '条件类型 1 {动作 1} 条件类型 2 {动作 2} ...' filename
```
-awk 每次处理一行，处理的最小单位是字段，每个字段的命名方式为：\$n，n 为字段号，从 1 开始，\$0 表示一整行。
+awk 每次处理一行，处理的最小单位是字段，每个字段的命名方式为：\$n，n 为字段号，从 1 开始，\$0 表示一整行。
-范例 1：取出登录用户的用户名和 ip
+范例 1：取出登录用户的用户名和 ip
```html
-$ last -n 5
-dmtsai pts/0 192.168.1.100 Tue Jul 14 17:32 still logged in
-dmtsai pts/0 192.168.1.100 Thu Jul 9 23:36 - 02:58 (03:22)
-dmtsai pts/0 192.168.1.100 Thu Jul 9 17:23 - 23:36 (06:12)
-dmtsai pts/0 192.168.1.100 Thu Jul 9 08:02 - 08:17 (00:14)
-dmtsai tty1 Fri May 29 11:55 - 12:11 (00:15)
+$ last -n 5
+dmtsai pts/0 192.168.1.100 Tue Jul 14 17:32 still logged in
+dmtsai pts/0 192.168.1.100 Thu Jul 9 23:36 - 02:58 (03:22)
+dmtsai pts/0 192.168.1.100 Thu Jul 9 17:23 - 23:36 (06:12)
+dmtsai pts/0 192.168.1.100 Thu Jul 9 08:02 - 08:17 (00:14)
+dmtsai tty1 Fri May 29 11:55 - 12:11 (00:15)
-$ last -n 5 | awk '{print $1 "\t" $3}
+$ last -n 5 | awk '{print $1 "\t" $3}
```
-awk 变量：
+awk 变量：
-| 变量名称 | 代表意义 |
-| -- | -- |
-| NF | 每一行拥有的字段总数 |
-| NR | 目前所处理的是第几行数据 |
-| FS | 目前的分隔字符，默认是空格键 |
+| 变量名称 | 代表意义 |
+| -- | -- |
+| NF | 每一行拥有的字段总数 |
+| NR | 目前所处理的是第几行数据 |
+| FS | 目前的分隔字符，默认是空格键 |
-范例 2：输出正在处理的行号，并显示每一行有多少字段
+范例 2：输出正在处理的行号，并显示每一行有多少字段
```html
-$ last -n 5 | awk '{print $1 "\t lines: " NR "\t columns: " NF}'
-dmtsai lines: 1 columns: 10
-dmtsai lines: 2 columns: 10
-dmtsai lines: 3 columns: 10
-dmtsai lines: 4 columns: 10
-dmtsai lines: 5 columns: 9
+$ last -n 5 | awk '{print $1 "\t lines: " NR "\t columns: " NF}'
+dmtsai lines: 1 columns: 10
+dmtsai lines: 2 columns: 10
+dmtsai lines: 3 columns: 10
+dmtsai lines: 4 columns: 10
+dmtsai lines: 5 columns: 9
```
-可以使用条件，其中等于使用 ==。
+可以使用条件，其中等于使用 ==。
-范例 3：/etc/passwd 文件第三个字段为 UID，对 UID 小于 10 的数据进行处理。
+范例 3：/etc/passwd 文件第三个字段为 UID，对 UID 小于 10 的数据进行处理。
```text
-cat /etc/passwd | awk 'BEGIN {FS=":"} $3 < 10 {print $1 "\t " $3}'
-root 0
-bin 1
-daemon 2
+cat /etc/passwd | awk 'BEGIN {FS=":"} $3 < 10 {print $1 "\t " $3}'
+root 0
+bin 1
+daemon 2
```
-# vim 三个模式
+# vim 三个模式
-
+
在指令列模式下，有以下命令用于离开或者存储文件。
-| 命令 | 作用 |
-| -- | -- |
-| :w | 写入磁盘|
-| :w! | 当文件为只读时，强制写入磁盘。到底能不能写入，与用户对该文件的权限有关 |
-| :q | 离开 |
-| :q! | 强制离开不保存 |
-| :wq | 写入磁盘后离开 |
-| :wq!| 强制写入磁盘后离开 |
+| 命令 | 作用 |
+| -- | -- |
+| :w | 写入磁盘|
+| :w! | 当文件为只读时，强制写入磁盘。到底能不能写入，与用户对该文件的权限有关 |
+| :q | 离开 |
+| :q! | 强制离开不保存 |
+| :wq | 写入磁盘后离开 |
+| :wq!| 强制写入磁盘后离开 |
-# 参考资料
+# 参考资料
-- 鸟哥. 鸟 哥 的 Linux 私 房 菜 基 础 篇 第 三 版[J]. 2009.
-- [Linux 平台上的软件包管理](https://www.ibm.com/developerworks/cn/linux/l-cn-rpmdpkg/index.html)
+- 鸟哥. 鸟 哥 的 Linux 私 房 菜 基 础 篇 第 三 版[J]. 2009.
+- [Linux 平台上的软件包管理](https://www.ibm.com/developerworks/cn/linux/l-cn-rpmdpkg/index.html)
diff --git a/notes/MySQL.md b/notes/MySQL.md
index e4cb9bee..3a84da59 100644
--- a/notes/MySQL.md
+++ b/notes/MySQL.md
@@ -1,12 +1,61 @@
-[TOC]
+
+* [存储引擎](#存储引擎)
+ * [1. InnoDB](#1-innodb)
+ * [2. MyISAM](#2-myisam)
+ * [3. InnoDB 与 MyISAM 的比较](#3-innodb-与-myisam-的比较)
+* [数据类型](#数据类型)
+ * [1. 整型](#1-整型)
+ * [2. 浮点数](#2-浮点数)
+ * [3. 字符串](#3-字符串)
+ * [4. 时间和日期](#4-时间和日期)
+* [索引](#索引)
+ * [1. 索引分类](#1-索引分类)
+ * [1.1 B-Tree 索引](#11-b-tree-索引)
+ * [1.2 哈希索引](#12-哈希索引)
+ * [1.3. 空间索引（R-Tree）](#13-空间索引r-tree)
+ * [1.4 全文索引](#14-全文索引)
+ * [2. 索引的优点](#2-索引的优点)
+ * [3. 索引优化](#3-索引优化)
+ * [3.1 独立的列](#31-独立的列)
+ * [3.2 前缀索引](#32-前缀索引)
+ * [3.3 多列索引](#33-多列索引)
+ * [3.4 索引列的顺序](#34-索引列的顺序)
+ * [3.5 聚簇索引](#35-聚簇索引)
+ * [3.6 覆盖索引](#36-覆盖索引)
+ * [4. B-Tree 和 B+Tree 原理](#4-b-tree-和-b+tree-原理)
+ * [4. 1 B-Tree](#4-1-b-tree)
+ * [4.2 B+Tree](#42-b+tree)
+ * [4.3 带有顺序访问指针的 B+Tree](#43-带有顺序访问指针的-b+tree)
+ * [4.4 为什么使用 B-Tree 和 B+Tree](#44-为什么使用-b-tree-和-b+tree)
+* [查询性能优化](#查询性能优化)
+ * [1. Explain](#1-explain)
+ * [2. 减少返回的列](#2-减少返回的列)
+ * [3. 减少返回的行](#3-减少返回的行)
+ * [4. 拆分大的 DELETE 或 INSERT 语句](#4-拆分大的-delete-或-insert-语句)
+* [分库与分表](#分库与分表)
+ * [1. 分库与分表的原因](#1-分库与分表的原因)
+ * [2. 实现方式](#2-实现方式)
+ * [2.1 垂直切分](#21-垂直切分)
+ * [2.2 水平切分](#22-水平切分)
+ * [2.3 切分的选择](#23-切分的选择)
+ * [3. Merge 存储引擎](#3-merge-存储引擎)
+ * [4. 分库与分表存在的问题](#4-分库与分表存在的问题)
+ * [4.1 事务问题](#41-事务问题)
+ * [4.2 跨库跨表连接问题](#42-跨库跨表连接问题)
+ * [4.3 额外的数据管理负担和数据运算压力](#43-额外的数据管理负担和数据运算压力)
+ * [5. 分表与分区的不同](#5-分表与分区的不同)
+* [故障转移和故障恢复](#故障转移和故障恢复)
+* [参考资料](#参考资料)
+
-# 存储引擎
-## 1. InnoDB
+# 存储引擎
-InnoDB 是 MySQL 默认的事务型存储引擎，只有在需要 InnoDB 不支持的特性时，才考虑使用其它存储引擎。
+## 1. InnoDB
-采用 MVCC 来支持高并发，并且实现了四个标准的隔离级别，默认级别是可重复读。
+InnoDB 是 MySQL 默认的事务型存储引擎，只有在需要 InnoDB 不支持的特性时，才考虑使用其它存储引擎。
+
+采用 MVCC 来支持高并发，并且实现了四个标准的隔离级别，默认级别是可重复读。
表是基于聚簇索引建立的，它对主键的查询性能有很高的提升。
@@ -14,9 +63,9 @@ InnoDB 是 MySQL 默认的事务型存储引擎，只有在需要 InnoDB
通过一些机制和工具支持真正的热备份。
-## 2. MyISAM
+## 2. MyISAM
-MyISAM 提供了大量的特性，包括全文索引、压缩、空间函数（GIS）等。但 MyISAM 不支持事务和行级锁，而且崩溃后无法安全恢复。
+MyISAM 提供了大量的特性，包括全文索引、压缩、空间函数（GIS）等。但 MyISAM 不支持事务和行级锁，而且崩溃后无法安全恢复。
只能对整张表加锁，而不是针对行。
@@ -24,83 +73,83 @@ MyISAM 提供了大量的特性，包括全文索引、压缩、空间函数（
可以包含动态或者静态的行。
-如果指定了 DELAY_KEY_WRITE 选项，在每次修改执行完成时，不会立即将修改的索引数据写入磁盘，而是会写到内存中的键缓冲区，只有在清理键缓冲区或者关闭表的时候才会将对应的索引块写入磁盘。这种方式可以极大的提升写入性能，但是在数据库或者主机崩溃时会造成索引损坏，需要执行修复操作。
+如果指定了 DELAY_KEY_WRITE 选项，在每次修改执行完成时，不会立即将修改的索引数据写入磁盘，而是会写到内存中的键缓冲区，只有在清理键缓冲区或者关闭表的时候才会将对应的索引块写入磁盘。这种方式可以极大的提升写入性能，但是在数据库或者主机崩溃时会造成索引损坏，需要执行修复操作。
-如果表在创建并导入数据以后，不会再进行修改操作，那么这样的表适合采用 MyISAM 压缩表。
+如果表在创建并导入数据以后，不会再进行修改操作，那么这样的表适合采用 MyISAM 压缩表。
-对于只读数据，或者表比较小、可以容忍修复操作，则依然可以继续使用 MyISAM。
+对于只读数据，或者表比较小、可以容忍修复操作，则依然可以继续使用 MyISAM。
-MyISAM 设计简单，数据以紧密格式存储，所以在某些场景下性能很好。
+MyISAM 设计简单，数据以紧密格式存储，所以在某些场景下性能很好。
-## 3. InnoDB 与 MyISAM 的比较
+## 3. InnoDB 与 MyISAM 的比较
-**事务**
+**事务**
-InnoDB 是事务型的。
+InnoDB 是事务型的。
-**备份**
+**备份**
-InnoDB 支持在线热备份。
+InnoDB 支持在线热备份。
-**崩溃恢复**
+**崩溃恢复**
-MyISAM 崩溃后发生损坏的概率比 InnoDB 高很多，而且恢复的速度也更慢。
+MyISAM 崩溃后发生损坏的概率比 InnoDB 高很多，而且恢复的速度也更慢。
-**并发**
+**并发**
-MyISAM 只支持表级锁，而 InnoDB 还支持行级锁。
+MyISAM 只支持表级锁，而 InnoDB 还支持行级锁。
-**其它特性**
+**其它特性**
-MyISAM 支持全文索引，地理空间索引。
+MyISAM 支持全文索引，地理空间索引。
-# 数据类型
+# 数据类型
-## 1. 整型
+## 1. 整型
-TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT 分别使用 8, 16, 24, 32, 64 位存储空间，一般情况下越小的列越好。
+TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT 分别使用 8, 16, 24, 32, 64 位存储空间，一般情况下越小的列越好。
-INT(11) 中的数字只是规定了交互工具显示字符的个数，对于存储和计算来说是没有意义的。
+INT(11) 中的数字只是规定了交互工具显示字符的个数，对于存储和计算来说是没有意义的。
-## 2. 浮点数
+## 2. 浮点数
-FLOAT 和 DOUBLE 为浮点类型，DECIMAL 为高精度小数类型。CPU 原生支持浮点运算，但是不支持 DECIMAl 类型的计算，因此 DECIMAL 的计算比浮点类型需要更高的代价。
+FLOAT 和 DOUBLE 为浮点类型，DECIMAL 为高精度小数类型。CPU 原生支持浮点运算，但是不支持 DECIMAl 类型的计算，因此 DECIMAL 的计算比浮点类型需要更高的代价。
-FLOAT、DOUBLE 和 DECIMAL 都可以指定列宽，例如 DECIMAL(18, 9) 表示总共 18 位，取 9 位存储小数部分，剩下 9 位存储整数部分。
+FLOAT、DOUBLE 和 DECIMAL 都可以指定列宽，例如 DECIMAL(18, 9) 表示总共 18 位，取 9 位存储小数部分，剩下 9 位存储整数部分。
-## 3. 字符串
+## 3. 字符串
-主要有 CHAR 和 VARCHAR 两种类型，一种是定长的，一种是变长的。
+主要有 CHAR 和 VARCHAR 两种类型，一种是定长的，一种是变长的。
-VARCHAR 这种变长类型能够节省空间，因为只需要存储必要的内容。但是在执行 UPDATE 时可能会使行变得比原来长，当超出一个页所能容纳的大小时，就要执行额外的操作。MyISAM 会将行拆成不同的片段存储，而 InnoDB 则需要分裂页来使行放进页内。
+VARCHAR 这种变长类型能够节省空间，因为只需要存储必要的内容。但是在执行 UPDATE 时可能会使行变得比原来长，当超出一个页所能容纳的大小时，就要执行额外的操作。MyISAM 会将行拆成不同的片段存储，而 InnoDB 则需要分裂页来使行放进页内。
-VARCHAR 会保留字符串末尾的空格，而 CHAR 会删除。
+VARCHAR 会保留字符串末尾的空格，而 CHAR 会删除。
-## 4. 时间和日期
+## 4. 时间和日期
-MySQL 提供了两种相似的日期时间类型：DATATIME 和 TIMESTAMP。
+MySQL 提供了两种相似的日期时间类型：DATATIME 和 TIMESTAMP。
-**DATATIME**
+**DATATIME**
-能够保存从 1001 年到 9999 年的日期和时间，精度为秒，使用 8 字节的存储空间。
+能够保存从 1001 年到 9999 年的日期和时间，精度为秒，使用 8 字节的存储空间。
它与时区无关。
-默认情况下，MySQL 以一种可排序的、无歧义的格式显示 DATATIME 值，例如“2008-01-16 22:37:08”，这是 ANSI 标准定义的日期和时间表示方法。
+默认情况下，MySQL 以一种可排序的、无歧义的格式显示 DATATIME 值，例如“2008-01-16 22:37:08”，这是 ANSI 标准定义的日期和时间表示方法。
-**TIMESTAMP**
+**TIMESTAMP**
-和 UNIX 时间戳相同，保存从 1970 年 1 月 1 日午夜（格林威治时间）以来的秒数，使用 4 个字节，只能表示从 1970 年 到 2038 年。
+和 UNIX 时间戳相同，保存从 1970 年 1 月 1 日午夜（格林威治时间）以来的秒数，使用 4 个字节，只能表示从 1970 年 到 2038 年。
它和时区有关。
-MySQL 提供了 FROM_UNIXTIME() 函数把 UNIX 时间戳转换为日期，并提供了 UNIX_TIMESTAMP() 函数把日期转换为 UNIX 时间戳。
+MySQL 提供了 FROM_UNIXTIME() 函数把 UNIX 时间戳转换为日期，并提供了 UNIX_TIMESTAMP() 函数把日期转换为 UNIX 时间戳。
-默认情况下，如果插入时没有指定 TIMESTAMP 列的值，会将这个值设置为当前时间。
+默认情况下，如果插入时没有指定 TIMESTAMP 列的值，会将这个值设置为当前时间。
-应该尽量使用 TIMESTAMP，因为它比 DATETIME 空间效率更高。
+应该尽量使用 TIMESTAMP，因为它比 DATETIME 空间效率更高。
-# 索引
+# 索引
索引是在存储引擎层实现的，而不是在服务器层实现的，所以不同存储引擎具有不同的索引类型和实现。
@@ -108,277 +157,277 @@ MySQL 提供了 FROM_UNIXTIME() 函数把 UNIX 时间戳转换为日期，
对于非常小的表、大部分情况下简单的全表扫描比建立索引更高效。对于中到大型的表，索引就非常有效。但是对于特大型的表，建立和使用索引的代价将会随之增长。这种情况下，需要用到一种技术可以直接区分出需要查询的一组数据，而不是一条记录一条记录地匹配，例如可以使用分区技术。
-## 1. 索引分类
+## 1. 索引分类
-### 1.1 B-Tree 索引
+### 1.1 B-Tree 索引
-B-Tree 索引是大多数 MySQL 存储引擎的默认索引类型。
+B-Tree 索引是大多数 MySQL 存储引擎的默认索引类型。
因为不再需要进行全表扫描，只需要对树进行搜索即可，因此查找速度快很多。
-可以指定多个列作为索引列，多个索引列共同组成键。B-Tree 索引适用于全键值、键值范围和键前缀查找，其中键前缀查找只适用于最左前缀查找。
+可以指定多个列作为索引列，多个索引列共同组成键。B-Tree 索引适用于全键值、键值范围和键前缀查找，其中键前缀查找只适用于最左前缀查找。
除了用于查找，还可以用于排序和分组。
如果不是按照索引列的顺序进行查找，则无法使用索引。
-### 1.2 哈希索引
+### 1.2 哈希索引
基于哈希表实现，优点是查找非常快。
-在 MySQL 中只有 Memory 引擎显式支持哈希索引。
+在 MySQL 中只有 Memory 引擎显式支持哈希索引。
-InnoDB 引擎有一个特殊的功能叫“自适应哈希索引”，当某个索引值被使用的非常频繁时，会在 B-Tree 索引之上再创建一个哈希索引，这样就让 B-Tree 索引具有哈希索引的一些优点，比如快速的哈希查找。
+InnoDB 引擎有一个特殊的功能叫“自适应哈希索引”，当某个索引值被使用的非常频繁时，会在 B-Tree 索引之上再创建一个哈希索引，这样就让 B-Tree 索引具有哈希索引的一些优点，比如快速的哈希查找。
限制：哈希索引只包含哈希值和行指针，而不存储字段值，所以不能使用索引中的值来避免读取行。不过，访问内存中的行的速度很快，所以大部分情况下这一点对性能影响并不明显；无法用于分组与排序；只支持精确查找，无法用于部分查找和范围查找；如果哈希冲突很多，查找速度会变得很慢。
-### 1.3. 空间索引（R-Tree）
+### 1.3. 空间索引（R-Tree）
-MyISAM 存储引擎支持空间索引，可以用于地理数据存储。
+MyISAM 存储引擎支持空间索引，可以用于地理数据存储。
空间索引会从所有维度来索引数据，可以有效地使用任意维度来进行组合查询。
-### 1.4 全文索引
+### 1.4 全文索引
-MyISAM 存储引擎支持全文索引，用于查找文本中的关键词，而不是直接比较索引中的值。
+MyISAM 存储引擎支持全文索引，用于查找文本中的关键词，而不是直接比较索引中的值。
-使用 MATCH AGAINST，而不是普通的 WHERE。
+使用 MATCH AGAINST，而不是普通的 WHERE。
-## 2. 索引的优点
+## 2. 索引的优点
-- 大大减少了服务器需要扫描的数据量；
+- 大大减少了服务器需要扫描的数据量；
-- 帮助服务器避免进行排序和创建临时表；
+- 帮助服务器避免进行排序和创建临时表；
-- 将随机 I/O 变为顺序 I/O。
+- 将随机 I/O 变为顺序 I/O。
-## 3. 索引优化
+## 3. 索引优化
-### 3.1 独立的列
+### 3.1 独立的列
在进行查询时，索引列不能是表达式的一部分，也不能是函数的参数，否则无法使用索引。
-例如下面的查询不能使用 actor_id 列的索引：
+例如下面的查询不能使用 actor_id 列的索引：
```sql
-SELECT actor_id FROM sakila.actor WHERE actor_id + 1 = 5;
+SELECT actor_id FROM sakila.actor WHERE actor_id + 1 = 5;
```
-### 3.2 前缀索引
+### 3.2 前缀索引
-对于 BLOB、TEXT 和 VARCHAR 类型的列，必须使用前缀索引，只索引开始的部分字符。
+对于 BLOB、TEXT 和 VARCHAR 类型的列，必须使用前缀索引，只索引开始的部分字符。
-对于前缀长度的选取需要根据 **索引选择性** 来确定：不重复的索引值和记录总数的比值。选择性越高，查询效率也越高。最大值为 1 ，此时每个记录都有唯一的索引与其对应。
+对于前缀长度的选取需要根据 **索引选择性** 来确定：不重复的索引值和记录总数的比值。选择性越高，查询效率也越高。最大值为 1 ，此时每个记录都有唯一的索引与其对应。
-### 3.3 多列索引
+### 3.3 多列索引
-在需要使用多个列作为条件进行查询时，使用多列索引比使用多个单列索引性能更好。例如下面的语句中，最好把 actor_id 和 file_id 设置为多列索引。
+在需要使用多个列作为条件进行查询时，使用多列索引比使用多个单列索引性能更好。例如下面的语句中，最好把 actor_id 和 file_id 设置为多列索引。
```sql
-SELECT file_id, actor_ id FROM sakila.film_actor
-WhERE actor_id = 1 OR film_id = 1;
+SELECT file_id, actor_ id FROM sakila.film_actor
+WhERE actor_id = 1 OR film_id = 1;
```
-### 3.4 索引列的顺序
+### 3.4 索引列的顺序
-让选择性最强的索引列放在前面，例如下面显示的结果中 customer_id 的选择性比 staff_id 更高，因此最好把 customer_id 列放在多列索引的前面。
+让选择性最强的索引列放在前面，例如下面显示的结果中 customer_id 的选择性比 staff_id 更高，因此最好把 customer_id 列放在多列索引的前面。
```sql
-SELECT COUNT(DISTINCT staff_id)/COUNT(*) AS staff_id_selectivity,
-COUNT(DISTINCT customer_id)/COUNT(*) AS customer_id_selectivity,
+SELECT COUNT(DISTINCT staff_id)/COUNT(*) AS staff_id_selectivity,
+COUNT(DISTINCT customer_id)/COUNT(*) AS customer_id_selectivity,
COUNT(*)
-FROM payment;
+FROM payment;
```
```html
- staff_id_selectivity: 0.0001
-customer_id_selectivity: 0.0373
- COUNT(*): 16049
+ staff_id_selectivity: 0.0001
+customer_id_selectivity: 0.0373
+ COUNT(*): 16049
```
-### 3.5 聚簇索引
+### 3.5 聚簇索引
-
+
聚簇索引并不是一种索引类型，而是一种数据存储方式。
-术语“聚簇”表示数据行和相邻的键值紧密地存储在一起，InnoDB 的聚簇索引的数据行存放在 B-Tree 的叶子页中。
+术语“聚簇”表示数据行和相邻的键值紧密地存储在一起，InnoDB 的聚簇索引的数据行存放在 B-Tree 的叶子页中。
因为无法把数据行存放在两个不同的地方，所以一个表只能有一个聚簇索引。
-**优点**
+**优点**
-1. 可以把相关数据保存在一起，减少 I/O 操作；
-2. 因为数据保存在 B-Tree 中，因此数据访问更快。
+1. 可以把相关数据保存在一起，减少 I/O 操作；
+2. 因为数据保存在 B-Tree 中，因此数据访问更快。
-**缺点**
+**缺点**
-1. 聚簇索引最大限度提高了 I/O 密集型应用的性能，但是如果数据全部放在内存，就没必要用聚簇索引。
-2. 插入速度严重依赖于插入顺序，按主键的顺序插入是最快的。
-3. 更新操作代价很高，因为每个被更新的行都会移动到新的位置。
-4. 当插入到某个已满的页中，存储引擎会将该页分裂成两个页面来容纳该行，页分裂会导致表占用更多的磁盘空间。
-5. 如果行比较稀疏，或者由于页分裂导致数据存储不连续时，聚簇索引可能导致全表扫描速度变慢。
+1. 聚簇索引最大限度提高了 I/O 密集型应用的性能，但是如果数据全部放在内存，就没必要用聚簇索引。
+2. 插入速度严重依赖于插入顺序，按主键的顺序插入是最快的。
+3. 更新操作代价很高，因为每个被更新的行都会移动到新的位置。
+4. 当插入到某个已满的页中，存储引擎会将该页分裂成两个页面来容纳该行，页分裂会导致表占用更多的磁盘空间。
+5. 如果行比较稀疏，或者由于页分裂导致数据存储不连续时，聚簇索引可能导致全表扫描速度变慢。
-### 3.6 覆盖索引
+### 3.6 覆盖索引
索引包含所有需要查询的字段的值。
-## 4. B-Tree 和 B+Tree 原理
+## 4. B-Tree 和 B+Tree 原理
-### 4. 1 B-Tree
+### 4. 1 B-Tree
-
+
-为了描述 B-Tree，首先定义一条数据记录为一个二元组 [key, data]，key 为记录的键，data 为数据记录除 key 外的数据。
+为了描述 B-Tree，首先定义一条数据记录为一个二元组 [key, data]，key 为记录的键，data 为数据记录除 key 外的数据。
-B-Tree 是满足下列条件的数据结构：
+B-Tree 是满足下列条件的数据结构：
-- 所有叶节点具有相同的深度，也就是说 B-Tree 是平衡的；
-- 一个节点中的 key 从左到右非递减排列；
-- 如果某个指针的左右相邻 key 分别是 keyi 和 keyi+1，且不为 null，则该指针指向节点的所有 key 大于 keyi 且小于 keyi+1。
+- 所有叶节点具有相同的深度，也就是说 B-Tree 是平衡的；
+- 一个节点中的 key 从左到右非递减排列；
+- 如果某个指针的左右相邻 key 分别是 keyi 和 keyi+1，且不为 null，则该指针指向节点的所有 key 大于 keyi 且小于 keyi+1。
-在 B-Tree 中按 key 检索数据的算法非常直观：首先从根节点进行二分查找，如果找到则返回对应节点的 data，否则对相应区间的指针指向的节点递归进行查找，直到找到节点或找到 null 指针，前者查找成功，后者查找失败。
+在 B-Tree 中按 key 检索数据的算法非常直观：首先从根节点进行二分查找，如果找到则返回对应节点的 data，否则对相应区间的指针指向的节点递归进行查找，直到找到节点或找到 null 指针，前者查找成功，后者查找失败。
-由于插入删除新的数据记录会破坏 B-Tree 的性质，因此在插入删除时，需要对树进行一个分裂、合并、转移等操作以保持 B-Tree 性质。
+由于插入删除新的数据记录会破坏 B-Tree 的性质，因此在插入删除时，需要对树进行一个分裂、合并、转移等操作以保持 B-Tree 性质。
-### 4.2 B+Tree
+### 4.2 B+Tree
-
+ 
-与 B-Tree 相比，B+Tree 有以下不同点：
+与 B-Tree 相比，B+Tree 有以下不同点：
-- 每个节点的指针上限为 2d 而不是 2d+1；
-- 内节点不存储 data，只存储 key，叶子节点不存储指针。
+- 每个节点的指针上限为 2d 而不是 2d+1；
+- 内节点不存储 data，只存储 key，叶子节点不存储指针。
-### 4.3 带有顺序访问指针的 B+Tree
+### 4.3 带有顺序访问指针的 B+Tree
-
+ 
-一般在数据库系统或文件系统中使用的 B+Tree 结构都在经典 B+Tree 基础上进行了优化，在叶子节点增加了顺序访问指针，做这个优化的目的是为了提高区间访问的性能。
+一般在数据库系统或文件系统中使用的 B+Tree 结构都在经典 B+Tree 基础上进行了优化，在叶子节点增加了顺序访问指针，做这个优化的目的是为了提高区间访问的性能。
-### 4.4 为什么使用 B-Tree 和 B+Tree
+### 4.4 为什么使用 B-Tree 和 B+Tree
-红黑树等数据结构也可以用来实现索引，但是文件系统及数据库系统普遍采用 B-/+Tree 作为索引结构。
+红黑树等数据结构也可以用来实现索引，但是文件系统及数据库系统普遍采用 B-/+Tree 作为索引结构。
-页是计算机管理存储器的逻辑块，硬件及操作系统往往将主存和磁盘存储区分割为连续的大小相等的块，每个存储块称为一页（在许多操作系统中，页得大小通常为 4k），主存和磁盘以页为单位交换数据。
+页是计算机管理存储器的逻辑块，硬件及操作系统往往将主存和磁盘存储区分割为连续的大小相等的块，每个存储块称为一页（在许多操作系统中，页得大小通常为 4k），主存和磁盘以页为单位交换数据。
-一般来说，索引本身也很大，不可能全部存储在内存中，因此索引往往以索引文件的形式存储的磁盘上。为了减少磁盘 I/O，磁盘往往不是严格按需读取，而是每次都会预读。这样做的理论依据是计算机科学中著名的局部性原理：当一个数据被用到时，其附近的数据也通常会马上被使用。数据库系统的设计者巧妙利用了磁盘预读原理，将一个节点的大小设为等于一个页，这样每个节点只需要一次 I/O 就可以完全载入。B-Tree 中一次检索最多需要 h-1 次 I/O（根节点常驻内存），渐进复杂度为 O(h)=O(logdN)。一般实际应用中，出度 d 是非常大的数字，通常超过 100，因此 h 非常小（通常不超过 3）。而红黑树这种结构，h 明显要深的多。并且于逻辑上很近的节点（父子）物理上可能很远，无法利用局部性，效率明显比 B-Tree 差很多。
+一般来说，索引本身也很大，不可能全部存储在内存中，因此索引往往以索引文件的形式存储的磁盘上。为了减少磁盘 I/O，磁盘往往不是严格按需读取，而是每次都会预读。这样做的理论依据是计算机科学中著名的局部性原理：当一个数据被用到时，其附近的数据也通常会马上被使用。数据库系统的设计者巧妙利用了磁盘预读原理，将一个节点的大小设为等于一个页，这样每个节点只需要一次 I/O 就可以完全载入。B-Tree 中一次检索最多需要 h-1 次 I/O（根节点常驻内存），渐进复杂度为 O(h)=O(logdN)。一般实际应用中，出度 d 是非常大的数字，通常超过 100，因此 h 非常小（通常不超过 3）。而红黑树这种结构，h 明显要深的多。并且于逻辑上很近的节点（父子）物理上可能很远，无法利用局部性，效率明显比 B-Tree 差很多。
-B+Tree 更适合外存索引，原因和内节点出度 d 有关。由于 B+Tree 内节点去掉了 data 域，因此可以拥有更大的出度，拥有更好的性能。
+B+Tree 更适合外存索引，原因和内节点出度 d 有关。由于 B+Tree 内节点去掉了 data 域，因此可以拥有更大的出度，拥有更好的性能。
-# 查询性能优化
+# 查询性能优化
-## 1. Explain
+## 1. Explain
-用来分析 SQL 语句，分析结果中比较重要的字段有：
+用来分析 SQL 语句，分析结果中比较重要的字段有：
-- select_type : 查询类型，有简单查询、联合查询和子查询
+- select_type : 查询类型，有简单查询、联合查询和子查询
-- key : 使用的索引
+- key : 使用的索引
-- rows : 扫描的行数
+- rows : 扫描的行数
-## 2. 减少返回的列
+## 2. 减少返回的列
慢查询主要是因为访问了过多数据，除了访问过多行之外，也包括访问过多列。
-最好不要使用 SELECT * 语句，要根据需要选择查询的列。
+最好不要使用 SELECT * 语句，要根据需要选择查询的列。
-## 3. 减少返回的行
+## 3. 减少返回的行
-最好使用 LIMIT 语句来取出想要的那些行。
+最好使用 LIMIT 语句来取出想要的那些行。
-还可以建立索引来减少条件语句的全表扫描。例如对于下面的语句，不适用索引的情况下需要进行全表扫描，而使用索引只需要扫描几行记录即可，使用 Explain 语句可以通过观察 rows 字段来看出这种差异。
+还可以建立索引来减少条件语句的全表扫描。例如对于下面的语句，不适用索引的情况下需要进行全表扫描，而使用索引只需要扫描几行记录即可，使用 Explain 语句可以通过观察 rows 字段来看出这种差异。
```sql
-SELECT * FROM sakila.film_actor WHERE film_id = 1;
+SELECT * FROM sakila.film_actor WHERE film_id = 1;
```
-## 4. 拆分大的 DELETE 或 INSERT 语句
+## 4. 拆分大的 DELETE 或 INSERT 语句
如果一次性执行的话，可能一次锁住很多数据、占满整个事务日志、耗尽系统资源、阻塞很多小的但重要的查询。
```sql
-DELEFT FROM messages WHERE create < DATE_SUB(NOW(), INTERVAL 3 MONTH);
+DELEFT FROM messages WHERE create < DATE_SUB(NOW(), INTERVAL 3 MONTH);
```
```sql
-rows_affected = 0
-do {
- rows_affected = do_query(
- "DELETE FROM messages WHERE create < DATE_SUB(NOW(), INTERVAL 3 MONTH) LIMIT 10000")
-} while rows_affected > 0
+rows_affected = 0
+do {
+ rows_affected = do_query(
+ "DELETE FROM messages WHERE create < DATE_SUB(NOW(), INTERVAL 3 MONTH) LIMIT 10000")
+} while rows_affected > 0
```
-# 分库与分表
+# 分库与分表
-## 1. 分库与分表的原因
+## 1. 分库与分表的原因
随着时间和业务的发展，数据库中的表会越来越多，并且表中的数据量也会越来越大，那么读写操作的开销也会随着增大。
-## 2. 实现方式
+## 2. 实现方式
-### 2.1 垂直切分
+### 2.1 垂直切分
-将表按功能模块、关系密切程度划分出来，部署到不同的库上。例如，我们会建立商品数据库 payDB、用户数据库 userDB 等，分别用来存储项目与商品有关的表和与用户有关的表。
+将表按功能模块、关系密切程度划分出来，部署到不同的库上。例如，我们会建立商品数据库 payDB、用户数据库 userDB 等，分别用来存储项目与商品有关的表和与用户有关的表。
-### 2.2 水平切分
+### 2.2 水平切分
-把表中的数据按照某种规则存储到多个结构相同的表中，例如按 id 的散列值、性别等进行划分。
+把表中的数据按照某种规则存储到多个结构相同的表中，例如按 id 的散列值、性别等进行划分。
-### 2.3 切分的选择
+### 2.3 切分的选择
如果数据库中的表太多，并且项目各项业务逻辑清晰，那么垂直切分是首选。
如果数据库的表不多，但是单表的数据量很大，应该选择水平切分。
-## 3. Merge 存储引擎
+## 3. Merge 存储引擎
该存储引擎支持分表。
-## 4. 分库与分表存在的问题
+## 4. 分库与分表存在的问题
-### 4.1 事务问题
+### 4.1 事务问题
在执行分库分表之后，由于数据存储到了不同的库上，数据库事务管理出现了困难。如果依赖数据库本身的分布式事务管理功能去执行事务，将付出高昂的性能代价；如果由应用程序去协助控制，形成程序逻辑上的事务，又会造成编程方面的负担。
-### 4.2 跨库跨表连接问题
+### 4.2 跨库跨表连接问题
在执行了分库分表之后，难以避免会将原本逻辑关联性很强的数据划分到不同的表、不同的库上。这时，表的连接操作将受到限制，我们无法连接位于不同分库的表，也无法连接分表粒度不同的表，导致原本只需要一次查询就能够完成的业务需要进行多次才能完成。
-### 4.3 额外的数据管理负担和数据运算压力
+### 4.3 额外的数据管理负担和数据运算压力
最显而易见的就是数据的定位问题和数据的增删改查的重复执行问题，这些都可以通过应用程序解决，但必然引起额外的逻辑运算。
-## 5. 分表与分区的不同
+## 5. 分表与分区的不同
分表，就是讲一张表分成多个小表，这些小表拥有不同的表名；而分区是将一张表的数据分为多个区块，这些区块可以存储在同一个磁盘上，也可以存储在不同的磁盘上，这种方式下表仍然只有一个。
-# 故障转移和故障恢复
+# 故障转移和故障恢复
故障转移也叫做切换，当主库出现故障时就切换到备库，使备库成为主库。故障恢复顾名思义就是从故障中恢复过来，并且保证数据的正确性。
-**提升备库或切换角色**
+**提升备库或切换角色**
提升一台备库为主库，或者在一个主-主复制结构中调整主动和被动角色。
-**虚拟 IP 地址和 IP 托管**
+**虚拟 IP 地址和 IP 托管**
-为 MySQL 实例指定一个逻辑 IP 地址，当 MySQL 实例失效时，可以将 IP 地址转移到另一台 MySQL 服务器上。
+为 MySQL 实例指定一个逻辑 IP 地址，当 MySQL 实例失效时，可以将 IP 地址转移到另一台 MySQL 服务器上。
-**中间件解决方案**
+**中间件解决方案**
通过代理，可以路由流量到可以使用的服务器上。
-
+ 
-**在应用中处理故障转移**
+**在应用中处理故障转移**
将故障转移整合到应用中可能导致应用变得太过笨拙。
-# 参考资料
+# 参考资料
-- 高性能 MySQL
-- [MySQL 索引背后的数据结构及算法原理 ](http://blog.codinglabs.org/articles/theory-of-mysql-index.html)
-- [20+ 条 MySQL 性能优化的最佳经验 ](https://www.jfox.info/20-tiao-mysql-xing-nen-you-hua-de-zui-jia-jing-yan.html)
-- [数据库为什么分库分表？mysql的分库分表方案](https://www.i3geek.com/archives/1108)
\ No newline at end of file
+- 高性能 MySQL
+- [MySQL 索引背后的数据结构及算法原理 ](http://blog.codinglabs.org/articles/theory-of-mysql-index.html)
+- [20+ 条 MySQL 性能优化的最佳经验 ](https://www.jfox.info/20-tiao-mysql-xing-nen-you-hua-de-zui-jia-jing-yan.html)
+- [数据库为什么分库分表？mysql的分库分表方案](https://www.i3geek.com/archives/1108)
diff --git a/notes/SQL 语法.md b/notes/SQL 语法.md
index f382a148..20d5c00d 100644
--- a/notes/SQL 语法.md
+++ b/notes/SQL 语法.md
@@ -1,705 +1,738 @@
-[TOC]
+
+* [基础](#基础)
+* [创建表](#创建表)
+* [插入](#插入)
+* [更新](#更新)
+* [删除](#删除)
+* [修改表](#修改表)
+* [查询](#查询)
+* [排序](#排序)
+* [过滤](#过滤)
+* [通配符](#通配符)
+* [计算字段](#计算字段)
+* [函数](#函数)
+ * [文本处理](#文本处理)
+ * [日期和时间处理](#日期和时间处理)
+ * [数值处理](#数值处理)
+ * [汇总](#汇总)
+* [分组](#分组)
+* [子查询](#子查询)
+* [连接](#连接)
+ * [内连接](#内连接)
+ * [自连接](#自连接)
+ * [自然连接](#自然连接)
+ * [外连接](#外连接)
+* [组合查询](#组合查询)
+* [视图](#视图)
+* [存储过程](#存储过程)
+* [游标](#游标)
+* [触发器](#触发器)
+* [事务处理](#事务处理)
+* [字符集](#字符集)
+* [权限管理](#权限管理)
+
-# 基础
+
+# 基础
模式定义了数据如何存储、存储什么样的数据以及数据如何分解等信息，数据库和表都有模式。
主键的值不允许修改，也不允许复用（不能使用已经删除的主键值赋给新数据行的主键）。
-SQL（Structured Query Language)，标准 SQL 由 ANSI 标准委员会管理，从而称为 ANSI SQL。各个 DBMS 都有自己的实现，如 PL/SQL、Transact-SQL 等。
+SQL（Structured Query Language)，标准 SQL 由 ANSI 标准委员会管理，从而称为 ANSI SQL。各个 DBMS 都有自己的实现，如 PL/SQL、Transact-SQL 等。
-SQL 语句不区分大小写，但是数据库表名、列名和值是否区分依赖于具体的 DBMS 以及配置。
+SQL 语句不区分大小写，但是数据库表名、列名和值是否区分依赖于具体的 DBMS 以及配置。
-SQL 支持以下三种注释：
+SQL 支持以下三种注释：
```sql
-# 注释
-SELECT *
-FROM mytable; -- 注释
-/* 注释1
- 注释2 */
+# 注释
+SELECT *
+FROM mytable; -- 注释
+/* 注释1
+ 注释2 */
```
-# 创建表
+# 创建表
```sql
-CREATE TABLE mytable (
- id INT NOT NULL AUTO_INCREMENT,
- col1 INT NOT NULL DEFAULT 1,
- col2 VARCHAR(45) NULL,
- col3 DATE NULL,
- PRIMARY KEY (`id`));
+CREATE TABLE mytable (
+ id INT NOT NULL AUTO_INCREMENT,
+ col1 INT NOT NULL DEFAULT 1,
+ col2 VARCHAR(45) NULL,
+ col3 DATE NULL,
+ PRIMARY KEY (`id`));
```
-# 插入
+# 插入
-**普通插入**
+**普通插入**
```sql
-INSERT INTO mytable(col1, col2)
-VALUES(val1, val2);
+INSERT INTO mytable(col1, col2)
+VALUES(val1, val2);
```
-**插入检索出来的数据**
+**插入检索出来的数据**
```sql
-INSERT INTO mytable1(col1, col2)
-SELECT col1, col2
-FROM mytable2;
+INSERT INTO mytable1(col1, col2)
+SELECT col1, col2
+FROM mytable2;
```
-**将一个表的内容复制到一个新表**
+**将一个表的内容复制到一个新表**
```sql
-CREATE TABLE newtable AS
-SELECT * FROM mytable;
+CREATE TABLE newtable AS
+SELECT * FROM mytable;
```
-# 更新
+# 更新
```sql
-UPDATE mytable
-SET col = val
-WHERE id = 1;
+UPDATE mytable
+SET col = val
+WHERE id = 1;
```
-# 删除
+# 删除
```sql
-DELETE FROM mytable
-WHERE id = 1;
+DELETE FROM mytable
+WHERE id = 1;
```
-**TRUNCATE TABLE** 可以清空表，也就是删除所有行。
+**TRUNCATE TABLE** 可以清空表，也就是删除所有行。
-使用更新和删除操作时一定要用 WHERE 子句，不然会把整张表的数据都破坏。可以先用 SELECT 语句进行测试，防止错误删除。
+使用更新和删除操作时一定要用 WHERE 子句，不然会把整张表的数据都破坏。可以先用 SELECT 语句进行测试，防止错误删除。
-# 修改表
+# 修改表
-**添加列**
+**添加列**
```sql
-ALTER TABLE mytable
-ADD col CHAR(20);
+ALTER TABLE mytable
+ADD col CHAR(20);
```
-**删除列**
+**删除列**
```sql
-ALTER TABLE mytable
-DROP COLUMN col;
+ALTER TABLE mytable
+DROP COLUMN col;
```
-**删除表**
+**删除表**
```sql
-DROP TABLE mytable;
+DROP TABLE mytable;
```
-# 查询
+# 查询
-**DISTINCT**
+**DISTINCT**
相同值只会出现一次。它作用于所有列，也就是说所有列的值都相同才算相同。
```sql
-SELECT DISTINCT col1, col2
-FROM mytable;
+SELECT DISTINCT col1, col2
+FROM mytable;
```
-**LIMIT**
+**LIMIT**
-限制返回的行数。可以有两个参数，第一个参数为起始行，从 0 开始；第二个参数为返回的总行数。
+限制返回的行数。可以有两个参数，第一个参数为起始行，从 0 开始；第二个参数为返回的总行数。
-返回前 5 行：
+返回前 5 行：
```sql
-SELECT *
-FROM mytable
-LIMIT 5;
+SELECT *
+FROM mytable
+LIMIT 5;
```
```sql
-SELECT *
-FROM mytable
-LIMIT 0, 5;
+SELECT *
+FROM mytable
+LIMIT 0, 5;
```
-返回第 3 ~ 5 行：
+返回第 3 \~ 5 行：
```sql
-SELECT *
-FROM mytable
-LIMIT 2, 3;
+SELECT *
+FROM mytable
+LIMIT 2, 3;
```
-# 排序
+# 排序
-- **ASC**：升序（默认）
-- **DESC**：降序
+- **ASC** ：升序（默认）
+- **DESC** ：降序
可以按多个列进行排序，并且为每个列指定不同的排序方式：
```sql
-SELECT *
-FROM mytable
-ORDER BY col1 DESC, col2 ASC;
+SELECT *
+FROM mytable
+ORDER BY col1 DESC, col2 ASC;
```
-# 过滤
+# 过滤
-不进行过滤的数据非常大，导致通过网络传输了很多多余的数据，从而浪费了网络带宽。因此尽量使用 SQL 语句来过滤不必要的数据，而不是传输所有的数据到客户端中然后由客户端进行过滤。
+不进行过滤的数据非常大，导致通过网络传输了很多多余的数据，从而浪费了网络带宽。因此尽量使用 SQL 语句来过滤不必要的数据，而不是传输所有的数据到客户端中然后由客户端进行过滤。
```sql
-SELECT *
-FROM mytable
-WHERE col IS NULL;
+SELECT *
+FROM mytable
+WHERE col IS NULL;
```
-下表显示了 WHERE 子句可用的操作符
+下表显示了 WHERE 子句可用的操作符
-| 操作符 | 说明 |
-| ------------ | ------------ |
-| = < > | 等于 小于 大于 |
-| <> != | 不等于 |
-| <= !> | 小于等于 |
-| >= !< | 大于等于 |
-| BETWEEN | 在两个值之间 |
-| IS NULL | 为NULL值 |
+| 操作符 | 说明 |
+| ------------ | ------------ |
+| = < > | 等于 小于 大于 |
+| <> != | 不等于 |
+| <= !> | 小于等于 |
+| >= !< | 大于等于 |
+| BETWEEN | 在两个值之间 |
+| IS NULL | 为NULL值 |
-应该注意到，NULL 与 0 、空字符串都不同。
+应该注意到，NULL 与 0 、空字符串都不同。
-**AND OR** 用于连接多个过滤条件。优先处理 AND，因此当一个过滤表达式涉及到多个 AND 和 OR 时，应当使用 () 来决定优先级。
+**AND OR** 用于连接多个过滤条件。优先处理 AND，因此当一个过滤表达式涉及到多个 AND 和 OR 时，应当使用 () 来决定优先级。
-**IN** 操作符用于匹配一组值，其后也可以接一个 SELECT 子句，从而匹配子查询得到的一组值。
+**IN** 操作符用于匹配一组值，其后也可以接一个 SELECT 子句，从而匹配子查询得到的一组值。
-**NOT** 操作符用于否定一个条件。
+**NOT** 操作符用于否定一个条件。
-# 通配符
+# 通配符
通配符也是用在过滤语句中，但它只能用于文本字段。
-- **%** 匹配 >=0 个任意字符，类似于 \*；
+- **%** 匹配 >=0 个任意字符，类似于 \*；
-- **\_** 匹配 ==1 个任意字符，类似于 \.；
+- **\_** 匹配 ==1 个任意字符，类似于 \.；
-- **[ ]** 可以匹配集合内的字符，例如 [ab] 将匹配字符 a 或者 b。用脱字符 ^ 可以对其进行否定，也就是不匹配集合内的字符。
+- **[ ]** 可以匹配集合内的字符，例如 [ab] 将匹配字符 a 或者 b。用脱字符 ^ 可以对其进行否定，也就是不匹配集合内的字符。
-使用 Like 来进行通配符匹配。
+使用 Like 来进行通配符匹配。
```sql
-SELECT *
-FROM mytable
-WHERE col LIKE '[^AB]%' -- 不以 A 和 B 开头的任意文本
+SELECT *
+FROM mytable
+WHERE col LIKE '[^AB]%' -- 不以 A 和 B 开头的任意文本
```
不要滥用通配符，通配符位于开头处匹配会非常慢。
-# 计算字段
+# 计算字段
在数据库服务器上完成数据的转换和格式化的工作往往比客户端上快得多，并且转换和格式化后的数据量更少的话可以减少网络通信量。
-计算字段通常需要使用 **AS** 来取别名，否则输出的时候字段名为计算表达式。
+计算字段通常需要使用 **AS** 来取别名，否则输出的时候字段名为计算表达式。
```sql
-SELECT col1*col2 AS alias
-FROM mytable
+SELECT col1*col2 AS alias
+FROM mytable
```
-**Concat()** 用于连接两个字段。许多数据库会使用空格把一个值填充为列宽，因此连接的结果会出现一些不必要的空格，使用 **TRIM()** 可以去除首尾空格。
+**Concat()** 用于连接两个字段。许多数据库会使用空格把一个值填充为列宽，因此连接的结果会出现一些不必要的空格，使用 **TRIM()** 可以去除首尾空格。
```sql
-SELECT Concat(TRIM(col1), ' (', TRIM(col2), ')')
-FROM mytable
+SELECT Concat(TRIM(col1), ' (', TRIM(col2), ')')
+FROM mytable
```
-# 函数
+# 函数
-各个 DBMS 的函数都是不相同的，因此不可移植。
+各个 DBMS 的函数都是不相同的，因此不可移植。
-## 文本处理
+## 文本处理
-| 函数 | 说明 |
-| ------------ | ------------ |
-| LEFT() RIGHT() | 左边或者右边的字符 |
-| LOWER() UPPER() | 转换为小写或者大写 |
-| LTRIM() RTIM() | 去除左边或者右边的空格 |
-| LENGTH() | 长度 |
-| SUNDEX() | 转换为语音值 |
+| 函数 | 说明 |
+| ------------ | ------------ |
+| LEFT() RIGHT() | 左边或者右边的字符 |
+| LOWER() UPPER() | 转换为小写或者大写 |
+| LTRIM() RTIM() | 去除左边或者右边的空格 |
+| LENGTH() | 长度 |
+| SUNDEX() | 转换为语音值 |
-其中，**SOUNDEX()** 是将一个字符串转换为描述其语音表示的字母数字模式的算法，它是根据发音而不是字母比较。
+其中， **SOUNDEX()** 是将一个字符串转换为描述其语音表示的字母数字模式的算法，它是根据发音而不是字母比较。
```sql
-SELECT *
-FROM mytable
-WHERE SOUNDEX(col1) = SOUNDEX('apple')
+SELECT *
+FROM mytable
+WHERE SOUNDEX(col1) = SOUNDEX('apple')
```
-## 日期和时间处理
+## 日期和时间处理
-- 日期格式：YYYY-MM-DD
-- 时间格式：HH:MM:SS
+- 日期格式：YYYY-MM-DD
+- 时间格式：HH:MM:SS
-|函 数 | 说 明|
-| --- | --- |
-| AddDate() | 增加一个日期（天、周等）|
-| AddTime() | 增加一个时间（时、分等）|
-| CurDate() | 返回当前日期 |
-| CurTime() | 返回当前时间 |
-| Date() |返回日期时间的日期部分|
-| DateDiff() |计算两个日期之差|
-| Date_Add() |高度灵活的日期运算函数|
-| Date_Format() |返回一个格式化的日期或时间串|
-| Day()| 返回一个日期的天数部分|
-| DayOfWeek() |对于一个日期，返回对应的星期几|
-| Hour() |返回一个时间的小时部分|
-| Minute() |返回一个时间的分钟部分|
-| Month() |返回一个日期的月份部分|
-| Now() |返回当前日期和时间|
-| Second() |返回一个时间的秒部分|
-| Time() |返回一个日期时间的时间部分|
-| Year() |返回一个日期的年份部分|
+|函 数 | 说 明|
+| --- | --- |
+| AddDate() | 增加一个日期（天、周等）|
+| AddTime() | 增加一个时间（时、分等）|
+| CurDate() | 返回当前日期 |
+| CurTime() | 返回当前时间 |
+| Date() |返回日期时间的日期部分|
+| DateDiff() |计算两个日期之差|
+| Date_Add() |高度灵活的日期运算函数|
+| Date_Format() |返回一个格式化的日期或时间串|
+| Day()| 返回一个日期的天数部分|
+| DayOfWeek() |对于一个日期，返回对应的星期几|
+| Hour() |返回一个时间的小时部分|
+| Minute() |返回一个时间的分钟部分|
+| Month() |返回一个日期的月份部分|
+| Now() |返回当前日期和时间|
+| Second() |返回一个时间的秒部分|
+| Time() |返回一个日期时间的时间部分|
+| Year() |返回一个日期的年份部分|
```sql
-mysql> SELECT NOW();
- -> '2017-06-28 14:01:52'
+mysql> SELECT NOW();
+ -> '2017-06-28 14:01:52'
```
-## 数值处理
+## 数值处理
-| 函数 | 说明 |
-| --- | --- |
-| SIN() | 正弦 |
-| COS() | 余弦 |
-| TAN() | 正切 |
-| ABS() | 绝对值 |
-| SQRT() | 平方根 |
-| MOD() | 余数 |
-| EXP() | 指数 |
-| PI() | 圆周率 |
-| RAND() | 随机数 |
+| 函数 | 说明 |
+| --- | --- |
+| SIN() | 正弦 |
+| COS() | 余弦 |
+| TAN() | 正切 |
+| ABS() | 绝对值 |
+| SQRT() | 平方根 |
+| MOD() | 余数 |
+| EXP() | 指数 |
+| PI() | 圆周率 |
+| RAND() | 随机数 |
-## 汇总
+## 汇总
-|函 数 |说 明|
-| --- | --- |
-| AVG() | 返回某列的平均值 |
-| COUNT() | 返回某列的行数 |
-| MAX() | 返回某列的最大值 |
-| MIN() | 返回某列的最小值 |
-| SUM() |返回某列值之和 |
+|函 数 |说 明|
+| --- | --- |
+| AVG() | 返回某列的平均值 |
+| COUNT() | 返回某列的行数 |
+| MAX() | 返回某列的最大值 |
+| MIN() | 返回某列的最小值 |
+| SUM() |返回某列值之和 |
-AVG() 会忽略 NULL 行。
+AVG() 会忽略 NULL 行。
-使用 DISTINCT 可以汇总函数值汇总不同的值。
+使用 DISTINCT 可以汇总函数值汇总不同的值。
```sql
-SELECT AVG(DISTINCT col1) AS avg_col
-FROM mytable
+SELECT AVG(DISTINCT col1) AS avg_col
+FROM mytable
```
-# 分组
+# 分组
分组就是把具有相同的数据值的行放在同一组中。
可以对同一分组数据使用汇总函数进行处理，例如求分组数据的平均值等。
-指定的分组字段除了能让数组按该字段进行分组，也可以按该字段进行排序，例如按 col 字段排序并分组数据：
+指定的分组字段除了能让数组按该字段进行分组，也可以按该字段进行排序，例如按 col 字段排序并分组数据：
```sql
-SELECT col, COUNT(*) AS num
-FROM mytable
-GROUP BY col;
+SELECT col, COUNT(*) AS num
+FROM mytable
+GROUP BY col;
```
-WHERE 过滤行，HAVING 过滤分组。行过滤应当先与分组过滤；
+WHERE 过滤行，HAVING 过滤分组。行过滤应当先与分组过滤；
```sql
-SELECT col, COUNT(*) AS num
-FROM mytable
-WHERE col > 2
-GROUP BY col
-HAVING COUNT(*) >= 2;
+SELECT col, COUNT(*) AS num
+FROM mytable
+WHERE col > 2
+GROUP BY col
+HAVING COUNT(*) >= 2;
```
-GROUP BY 的排序结果为分组字段，而 ORDER BY 也可以以聚集字段来进行排序。
+GROUP BY 的排序结果为分组字段，而 ORDER BY 也可以以聚集字段来进行排序。
```sql
-SELECT col, COUNT(*) AS num
-FROM mytable
-GROUP BY col
-ORDER BY num;
+SELECT col, COUNT(*) AS num
+FROM mytable
+GROUP BY col
+ORDER BY num;
```
分组规定：
-1. GROUP BY 子句出现在 WHERE 子句之后，ORDER BY 子句之前；
-2. 除了汇总计算语句的字段外，SELECT 语句中的每一字段都必须在 GROUP BY 子句中给出；
-3. NULL 的行会单独分为一组；
-4. 大多数 SQL 实现不支持 GROUP BY 列具有可变长度的数据类型。
+1. GROUP BY 子句出现在 WHERE 子句之后，ORDER BY 子句之前；
+2. 除了汇总计算语句的字段外，SELECT 语句中的每一字段都必须在 GROUP BY 子句中给出；
+3. NULL 的行会单独分为一组；
+4. 大多数 SQL 实现不支持 GROUP BY 列具有可变长度的数据类型。
-# 子查询
+# 子查询
子查询中只能返回一个字段的数据。
-可以将子查询的结果作为 WHRER 语句的过滤条件：
+可以将子查询的结果作为 WHRER 语句的过滤条件：
```
-SELECT *
-FROM mytable1
-WHERE col1 IN (SELECT col2
- FROM mytable2);
+SELECT *
+FROM mytable1
+WHERE col1 IN (SELECT col2
+ FROM mytable2);
```
下面的语句可以检索出客户的订单数量，子查询语句会对第一个查询检索出的每个客户执行一次：
```sql
-SELECT cust_name, (SELECT COUNT(*)
- FROM Orders
- WHERE Orders.cust_id = Customers.cust_id)
- AS orders_num
-FROM Customers
-ORDER BY cust_name;
+SELECT cust_name, (SELECT COUNT(*)
+ FROM Orders
+ WHERE Orders.cust_id = Customers.cust_id)
+ AS orders_num
+FROM Customers
+ORDER BY cust_name;
```
-# 连接
+# 连接
-连接用于连接多个表，使用 JOIN 关键字，并且条件语句使用 ON 而不是 Where。
+连接用于连接多个表，使用 JOIN 关键字，并且条件语句使用 ON 而不是 Where。
连接可以替换子查询，并且比子查询的效率一般会更快。
-可以用 AS 给列名、计算字段和表名取别名，给表名取别名是为了简化 SQL 语句以及连接相同表。
+可以用 AS 给列名、计算字段和表名取别名，给表名取别名是为了简化 SQL 语句以及连接相同表。
-## 内连接
+## 内连接
-内连接又称等值连接，使用 INNER JOIN 关键字。
+内连接又称等值连接，使用 INNER JOIN 关键字。
```sql
-select a, b, c
-from A inner join B
-on A.key = B.key
+select a, b, c
+from A inner join B
+on A.key = B.key
```
-可以不明确使用 INNER JOIN，而使用普通查询并在 WHERE 中将两个表中要连接的列用等值方法连接起来。
+可以不明确使用 INNER JOIN，而使用普通查询并在 WHERE 中将两个表中要连接的列用等值方法连接起来。
```sql
-select a, b, c
-from A, B
-where A.key = B.key
+select a, b, c
+from A, B
+where A.key = B.key
```
在没有条件语句的情况下返回笛卡尔积。
-## 自连接
+## 自连接
自连接可以看成内连接的一种，只是连接的表是自身而已。
-一张员工表，包含员工姓名和员工所属部门，要找出与 Jim 处在同一部门的所有员工姓名。
+一张员工表，包含员工姓名和员工所属部门，要找出与 Jim 处在同一部门的所有员工姓名。
-**子查询版本**
+**子查询版本**
```sql
-select name
-from employee
-where department = (
- select department
- from employee
- where name = "Jim");
+select name
+from employee
+where department = (
+ select department
+ from employee
+ where name = "Jim");
```
-**自连接版本**
+**自连接版本**
```sql
-select name
-from employee as e1, employee as e2
-where e1.department = e2.department
- and e1.name = "Jim";
+select name
+from employee as e1, employee as e2
+where e1.department = e2.department
+ and e1.name = "Jim";
```
连接一般比子查询的效率高。
-## 自然连接
+## 自然连接
自然连接是把同名列通过等值测试连接起来的，同名列可以有多个。
内连接和自然连接的区别：内连接提供连接的列，而自然连接自动连接所有同名列。
```sql
-select *
-from employee natural join department;
+select *
+from employee natural join department;
```
-## 外连接
+## 外连接
外连接保留了没有关联的那些行。分为左外连接，右外连接以及全外连接，左外连接就是保留左表没有关联的行。
检索所有顾客的订单信息，包括还没有订单信息的顾客。
```sql
-select Customers.cust_id, Orders.order_num
- from Customers left outer join Orders
- on Customers.cust_id = Orders.curt_id;
+select Customers.cust_id, Orders.order_num
+ from Customers left outer join Orders
+ on Customers.cust_id = Orders.curt_id;
```
如果需要统计顾客的订单数，使用聚集函数。
```sql
-select Customers.cust_id,
- COUNT(Orders.order_num) as num_ord
-from Customers left outer join Orders
-on Customers.cust_id = Orders.curt_id
-group by Customers.cust_id;
+select Customers.cust_id,
+ COUNT(Orders.order_num) as num_ord
+from Customers left outer join Orders
+on Customers.cust_id = Orders.curt_id
+group by Customers.cust_id;
```
-# 组合查询
+# 组合查询
-使用 **UNION** 来组合两个查询，如果第一个查询返回 M 行，第二个查询返回 N 行，那么组合查询的结果为 M+N 行。
+使用 **UNION** 来组合两个查询，如果第一个查询返回 M 行，第二个查询返回 N 行，那么组合查询的结果为 M+N 行。
每个查询必须包含相同的列、表达式或者聚集函数。
-默认会去除相同行，如果需要保留相同行，使用 UNION ALL。
+默认会去除相同行，如果需要保留相同行，使用 UNION ALL。
-只能包含一个 ORDER BY 子句，并且必须位于语句的最后。
+只能包含一个 ORDER BY 子句，并且必须位于语句的最后。
```sql
-SELECT col
-FROM mytable
-WHERE col = 1
+SELECT col
+FROM mytable
+WHERE col = 1
UNION
-SELECT col
-FROM mytable
-WHERE col =2;
+SELECT col
+FROM mytable
+WHERE col =2;
```
-# 视图
+# 视图
视图是虚拟的表，本身不包含数据，也就不能对其进行索引操作。对视图的操作和对普通表的操作一样。
视图具有如下好处：
-1. 简化复杂的 SQL 操作，比如复杂的联结；
-2. 只使用实际表的一部分数据；
-3. 通过只给用户访问视图的权限，保证数据的安全性；
-4. 更改数据格式和表示。
+1. 简化复杂的 SQL 操作，比如复杂的联结；
+2. 只使用实际表的一部分数据；
+3. 通过只给用户访问视图的权限，保证数据的安全性；
+4. 更改数据格式和表示。
```sql
-CREATE VIEW myview AS
-SELECT Concat(col1, col2) AS concat_col, col3*col4 AS count_col
-FROM mytable
-WHERE col5 = val;
+CREATE VIEW myview AS
+SELECT Concat(col1, col2) AS concat_col, col3*col4 AS count_col
+FROM mytable
+WHERE col5 = val;
```
-# 存储过程
+# 存储过程
-存储过程可以看成是对一系列 SQL 操作的批处理；
+存储过程可以看成是对一系列 SQL 操作的批处理；
-**使用存储过程的好处**
+**使用存储过程的好处**
-1. 代码封装，保证了一定的安全性；
-2. 代码复用；
-3. 由于是预先编译，因此具有很高的性能。
+1. 代码封装，保证了一定的安全性；
+2. 代码复用；
+3. 由于是预先编译，因此具有很高的性能。
-**创建存储过程**
+**创建存储过程**
-命令行中创建存储过程需要自定义分隔符，因为命令行是以 ; 为结束符，而存储过程中也包含了分号，因此会错误把这部分分号当成是结束符，造成语法错误。
+命令行中创建存储过程需要自定义分隔符，因为命令行是以 ; 为结束符，而存储过程中也包含了分号，因此会错误把这部分分号当成是结束符，造成语法错误。
-包含 in、out 和 inout 三种参数。
+包含 in、out 和 inout 三种参数。
-给变量赋值都需要用 select into 语句。
+给变量赋值都需要用 select into 语句。
每次只能给一个变量赋值，不支持集合的操作。
```sql
-delimiter //
+delimiter //
-create procedure myprocedure( out ret int )
- begin
- declare y int;
- select sum(col1)
- from mytable
- into y;
- select y*y into ret;
- end //
-delimiter ;
+create procedure myprocedure( out ret int )
+ begin
+ declare y int;
+ select sum(col1)
+ from mytable
+ into y;
+ select y*y into ret;
+ end //
+delimiter ;
```
```sql
-call myprocedure(@ret);
-select @ret;
+call myprocedure(@ret);
+select @ret;
```
-# 游标
+# 游标
在存储过程中使用游标可以对一个结果集进行移动遍历。
游标主要用于交互式应用，其中用户需要对数据集中的任意行进行浏览和修改。
-**使用游标的四个步骤：**
+**使用游标的四个步骤：**
-1. 声明游标，这个过程没有实际检索出数据；
-2. 打开游标；
-3. 取出数据；
-4. 关闭游标；
+1. 声明游标，这个过程没有实际检索出数据；
+2. 打开游标；
+3. 取出数据；
+4. 关闭游标；
```sql
-delimiter //
-create procedure myprocedure(out ret int)
- begin
- declare done boolean default 0;
+delimiter //
+create procedure myprocedure(out ret int)
+ begin
+ declare done boolean default 0;
- declare mycursor cursor for
- select col1 from mytable;
- # 定义了一个continue handler，当 sqlstate '02000' 这个条件出现时，会执行 set done = 1
- declare continue handler for sqlstate '02000' set done = 1;
+ declare mycursor cursor for
+ select col1 from mytable;
+ # 定义了一个continue handler，当 sqlstate '02000' 这个条件出现时，会执行 set done = 1
+ declare continue handler for sqlstate '02000' set done = 1;
- open mycursor;
+ open mycursor;
- repeat
- fetch mycursor into ret;
- select ret;
- until done end repeat;
+ repeat
+ fetch mycursor into ret;
+ select ret;
+ until done end repeat;
- close mycursor;
- end //
- delimiter ;
+ close mycursor;
+ end //
+ delimiter ;
```
-# 触发器
+# 触发器
触发器会在某个表执行以下语句时而自动执行：DELETE、INSERT、UPDATE
-触发器必须指定在语句执行之前还是之后自动执行，之前执行使用 BEFORE 关键字，之后执行使用 AFTER 关键字。BEFORE 用于数据验证和净化。
+触发器必须指定在语句执行之前还是之后自动执行，之前执行使用 BEFORE 关键字，之后执行使用 AFTER 关键字。BEFORE 用于数据验证和净化。
-INSERT 触发器包含一个名为 NEW 的虚拟表。
+INSERT 触发器包含一个名为 NEW 的虚拟表。
```sql
-CREATE TRIGGER mytrigger AFTER INSERT ON mytable
-FOR EACH ROW SELECT NEW.col;
+CREATE TRIGGER mytrigger AFTER INSERT ON mytable
+FOR EACH ROW SELECT NEW.col;
```
-DELETE 触发器包含一个名为 OLD 的虚拟表，并且是只读的。
+DELETE 触发器包含一个名为 OLD 的虚拟表，并且是只读的。
-UPDATE 触发器包含一个名为 NEW 和一个名为 OLD 的虚拟表，其中 NEW 是可以被修改地，而 OLD 是只读的。
+UPDATE 触发器包含一个名为 NEW 和一个名为 OLD 的虚拟表，其中 NEW 是可以被修改地，而 OLD 是只读的。
可以使用触发器来进行审计跟踪，把修改记录到另外一张表中。
-MySQL 不允许在触发器中使用 CALL 语句 ，也就是不能调用存储过程。
+MySQL 不允许在触发器中使用 CALL 语句 ，也就是不能调用存储过程。
-# 事务处理
+# 事务处理
-**基本术语**
+**基本术语**
-1. 事务（transaction）指一组 SQL 语句；
-2. 回退（rollback）指撤销指定 SQL 语句的过程；
-3. 提交（commit）指将未存储的 SQL 语句结果写入数据库表；
-4. 保留点（savepoint）指事务处理中设置的临时占位符（placeholder），你可以对它发布回退（与回退整个事务处理不同）。
+1. 事务（transaction）指一组 SQL 语句；
+2. 回退（rollback）指撤销指定 SQL 语句的过程；
+3. 提交（commit）指将未存储的 SQL 语句结果写入数据库表；
+4. 保留点（savepoint）指事务处理中设置的临时占位符（placeholder），你可以对它发布回退（与回退整个事务处理不同）。
-不能回退 SELECT 语句，回退 SELECT 语句也没意义；也不能回退 CRETE 和 DROP 语句。
+不能回退 SELECT 语句，回退 SELECT 语句也没意义；也不能回退 CRETE 和 DROP 语句。
-MySQL 的事务提交默认是隐式提交，也就是每执行一条语句就把这条语句当成一个事务然后进行提交。当出现 START TRANSACTION 语句时，会关闭隐式提交；当 COMMIT 或 ROLLBACK 语句执行后，事务会自动关闭，重新恢复隐式提交。
+MySQL 的事务提交默认是隐式提交，也就是每执行一条语句就把这条语句当成一个事务然后进行提交。当出现 START TRANSACTION 语句时，会关闭隐式提交；当 COMMIT 或 ROLLBACK 语句执行后，事务会自动关闭，重新恢复隐式提交。
-通过设置 autocommit 为 0 可以取消自动提交，直到 autocommit 被设置为 1 才会提交；autocommit 标记是针对每个连接而不是针对服务器的。
+通过设置 autocommit 为 0 可以取消自动提交，直到 autocommit 被设置为 1 才会提交；autocommit 标记是针对每个连接而不是针对服务器的。
-如果没有设置保留点，ROLLBACK 会回退到 START TRANSACTION 语句处；如果设置了保留点，并且在 ROLLBACK 中指定该保留点，则会回退到该保留点。
+如果没有设置保留点，ROLLBACK 会回退到 START TRANSACTION 语句处；如果设置了保留点，并且在 ROLLBACK 中指定该保留点，则会回退到该保留点。
```sql
-START TRANSACTION
-// ...
-SAVEPOINT delete1
-// ...
-ROLLBACK TO delete1
-// ...
+START TRANSACTION
+// ...
+SAVEPOINT delete1
+// ...
+ROLLBACK TO delete1
+// ...
COMMIT
```
-# 字符集
+# 字符集
-**基本术语**
+**基本术语**
-1. 字符集为字母和符号的集合；
-2. 编码为某个字符集成员的内部表示；
-3. 校对字符指定如何比较，主要用于排序和分组。
+1. 字符集为字母和符号的集合；
+2. 编码为某个字符集成员的内部表示；
+3. 校对字符指定如何比较，主要用于排序和分组。
除了给表指定字符集和校对外，也可以给列指定：
```sql
-CREATE TABLE mytable
-(col VARCHAR(10) CHARACTER SET latin COLLATE latin1_general_ci )
-DEFAULT CHARACTER SET hebrew COLLATE hebrew_general_ci;
+CREATE TABLE mytable
+(col VARCHAR(10) CHARACTER SET latin COLLATE latin1_general_ci )
+DEFAULT CHARACTER SET hebrew COLLATE hebrew_general_ci;
```
可以在排序、分组时指定校对：
```sql
-SELECT *
-FROM mytable
-ORDER BY col COLLATE latin1_general_ci;
+SELECT *
+FROM mytable
+ORDER BY col COLLATE latin1_general_ci;
```
-# 权限管理
+# 权限管理
-MySQL 的账户信息保存在 mysql 这个数据库中。
+MySQL 的账户信息保存在 mysql 这个数据库中。
```sql
-USE mysql;
-SELECT user FROM user;
+USE mysql;
+SELECT user FROM user;
```
-**创建账户**
+**创建账户**
```sql
-CREATE USER myuser IDENTIFIED BY 'mypassword';
+CREATE USER myuser IDENTIFIED BY 'mypassword';
```
新创建的账户没有任何权限。
-**修改账户名**
+**修改账户名**
```sql
-RENAME myuser TO newuser;
+RENAME myuser TO newuser;
```
-**删除账户**
+**删除账户**
```sql
-DROP USER myuser;
+DROP USER myuser;
```
-**查看权限**
+**查看权限**
```sql
-SHOW GRANTS FOR myuser;
+SHOW GRANTS FOR myuser;
```
-**授予权限**
+**授予权限**
```sql
-GRANT SELECT, INSERT ON mydatabase.* TO myuser;
+GRANT SELECT, INSERT ON mydatabase.* TO myuser;
```
-
+ 
-账户用 username@host 的形式定义，username@% 使用的是默认主机名。
+账户用 username@host 的形式定义，username@% 使用的是默认主机名。
-**删除权限**
+**删除权限**
```sql
-REVOKE SELECT, INSERT ON mydatabase.* FROM myuser;
+REVOKE SELECT, INSERT ON mydatabase.* FROM myuser;
```
-GRANT 和 REVOKE 可在几个层次上控制访问权限：
+GRANT 和 REVOKE 可在几个层次上控制访问权限：
-- 整个服务器，使用 GRANT ALL 和 REVOKE ALL；
-- 整个数据库，使用 ON database.\*；
-- 特定的表，使用 ON database.table；
-- 特定的列；
-- 特定的存储过程。
+- 整个服务器，使用 GRANT ALL 和 REVOKE ALL；
+- 整个数据库，使用 ON database.\*；
+- 特定的表，使用 ON database.table；
+- 特定的列；
+- 特定的存储过程。
-**更改密码**
+**更改密码**
-必须使用 Password() 函数
+必须使用 Password() 函数
```sql
-SET PASSWROD FOR myuser = Password('newpassword');
+SET PASSWROD FOR myuser = Password('newpassword');
```
diff --git a/notes/代码可读性.md b/notes/代码可读性.md
index c06ce12b..0c5ab772 100644
--- a/notes/代码可读性.md
+++ b/notes/代码可读性.md
@@ -1,6 +1,21 @@
-[TOC]
+
+* [可读性的重要性](#可读性的重要性)
+* [用名字表达代码含义](#用名字表达代码含义)
+* [名字不能带来歧义](#名字不能带来歧义)
+* [良好的代码风格](#良好的代码风格)
+* [编写注释](#编写注释)
+* [如何编写注释](#如何编写注释)
+* [提高控制流的可读性](#提高控制流的可读性)
+* [拆分长表达式](#拆分长表达式)
+* [变量与可读性](#变量与可读性)
+* [抽取函数](#抽取函数)
+* [一次只做一件事](#一次只做一件事)
+* [用自然语言表述代码](#用自然语言表述代码)
+* [减少代码量](#减少代码量)
+
-# 可读性的重要性
+
+# 可读性的重要性
编程有很大一部分时间是在阅读代码，不仅要阅读自己的代码，而且要阅读别人的代码。因此，可读性良好的代码能够大大提高编程效率。
@@ -8,50 +23,50 @@
只有在核心领域为了效率才可以放弃可读性，否则可读性是第一位。
-# 用名字表达代码含义
+# 用名字表达代码含义
一些比较有表达力的单词：
-| 单词 | 可替代单词 |
-| --- | --- |
-| send | deliver、dispatch、announce、distribute、route |
-| find | search、extract、locate、recover |
-| start| launch、create、begin、open|
-| make | create、set up、build、generate、compose、add、new |
+| 单词 | 可替代单词 |
+| --- | --- |
+| send | deliver、dispatch、announce、distribute、route |
+| find | search、extract、locate、recover |
+| start| launch、create、begin、open|
+| make | create、set up、build、generate、compose、add、new |
-使用 i、j、k 作为循环迭代器的名字过于简单，user_i、member_i 这种名字会更有表达力。因为循环层次越多，代码越难理解，有表达力的迭代器名字可读性会更高
+使用 i、j、k 作为循环迭代器的名字过于简单，user_i、member_i 这种名字会更有表达力。因为循环层次越多，代码越难理解，有表达力的迭代器名字可读性会更高
为名字添加形容词等信息能让名字更具有表达力，但是名字也会变长。名字长短的准则是：作用域越大，名字越长。因此只有在短作用域才能使用一些简单名字。
-# 名字不能带来歧义
+# 名字不能带来歧义
起完名字要思考一下别人会对这个名字有何解读，会不会误解了原本想表达的含义。
-用 min、max 表示数量范围；用 first、last 表示访问空间的包含范围，begin、end 表示访问空间的排除范围，即 end 不包含尾部。
+用 min、max 表示数量范围；用 first、last 表示访问空间的包含范围，begin、end 表示访问空间的排除范围，即 end 不包含尾部。
-
+ 
-布尔相关的命名加上 is、can、should、has 等前缀。
+布尔相关的命名加上 is、can、should、has 等前缀。
-# 良好的代码风格
+# 良好的代码风格
适当的空行和缩进。
排列整齐的注释：
```
-int a = 1; // 注释
-int b = 11; // 注释
-int c = 111; // 注释
+int a = 1; // 注释
+int b = 11; // 注释
+int c = 111; // 注释
```
-语句顺序不能随意，比如与 html 表单相关联的变量的赋值应该和表单在 html 中的顺序一致；
+语句顺序不能随意，比如与 html 表单相关联的变量的赋值应该和表单在 html 中的顺序一致；
把相关的代码按块组织起来放在一起。
-# 编写注释
+# 编写注释
-阅读代码首先会注意到注释，如果注释没太大作用，那么就会浪费代码阅读的时间。那些能直接看出含义的代码不需要写注释，特别是并不需要为每个方法都加上注释，比如那些简单的 getter 和 setter 方法，为这些方法写注释反而让代码可读性更差。
+阅读代码首先会注意到注释，如果注释没太大作用，那么就会浪费代码阅读的时间。那些能直接看出含义的代码不需要写注释，特别是并不需要为每个方法都加上注释，比如那些简单的 getter 和 setter 方法，为这些方法写注释反而让代码可读性更差。
不能因为有注释就随便起个名字，而是争取起个好名字而不写注释。
@@ -59,209 +74,209 @@ int c = 111; // 注释
注释用来提醒一些特殊情况。
-用 TODO 等做标记：
+用 TODO 等做标记：
-| 标记 | 用法 |
+| 标记 | 用法 |
|---|---|
-|TODO| 待做 |
-|FIXME| 待修复 |
-|HACH| 粗糙的解决方案 |
-|XXX| 危险！这里有重要的问题 |
+|TODO| 待做 |
+|FIXME| 待修复 |
+|HACH| 粗糙的解决方案 |
+|XXX| 危险！这里有重要的问题 |
-# 如何编写注释
+# 如何编写注释
尽量简洁明了：
```
-// The first String is student's name
-// The Second Integer is student's score
-Map scoreMap = new HashMap<>();
+// The first String is student's name
+// The Second Integer is student's score
+Map scoreMap = new HashMap<>();
```
```
-// Student' name -> Student's score
-Map scoreMap = new HashMap<>();
+// Student' name -> Student's score
+Map scoreMap = new HashMap<>();
```
添加测试用例来说明：
```
//...
-// Example: add(1, 2), return 3
-int add(int x, int y) {
- return x + y;
+// Example: add(1, 2), return 3
+int add(int x, int y) {
+ return x + y;
}
```
在很复杂的函数调用中对每个参数标上名字：
```
-int a = 1;
-int b = 2;
-int num = add(\* x = *\ a, \* y = *\ b);
+int a = 1;
+int b = 2;
+int num = add(\* x = *\ a, \* y = *\ b);
```
使用专业名词来缩短概念上的解释，比如用设计模式名来说明代码。
-# 提高控制流的可读性
+# 提高控制流的可读性
条件表达式中，左侧是变量，右侧是常数。比如下面第一个语句正确：
```
-if(len < 10)
-if(10 > len)
+if(len < 10)
+if(10 > len)
```
-if / else 条件语句，逻辑的处理顺序为：① 正逻辑；② 关键逻辑；③ 简单逻辑。
+if / else 条件语句，逻辑的处理顺序为：① 正逻辑；② 关键逻辑；③ 简单逻辑。
```
-if(a == b) {
- // 正逻辑
-} else{
- // 反逻辑
+if(a == b) {
+ // 正逻辑
+} else{
+ // 反逻辑
}
```
-只有在逻辑简单的情况下使用 ? : 三目运算符来使代码更紧凑，否则应该拆分成 if / else；
+只有在逻辑简单的情况下使用 ? : 三目运算符来使代码更紧凑，否则应该拆分成 if / else；
-do / while 的条件放在后面，不够简单明了，并且会有一些迷惑的地方，最好使用 while 来代替。
+do / while 的条件放在后面，不够简单明了，并且会有一些迷惑的地方，最好使用 while 来代替。
-如果只有一个 goto 目标，那么 goto 尚且还能接受，但是过于复杂的 goto 会让代码可读性特别差，应该避免使用 goto。
+如果只有一个 goto 目标，那么 goto 尚且还能接受，但是过于复杂的 goto 会让代码可读性特别差，应该避免使用 goto。
-在嵌套的循环中，用一些 return 语句往往能减少嵌套的层数。
+在嵌套的循环中，用一些 return 语句往往能减少嵌套的层数。
-# 拆分长表达式
+# 拆分长表达式
长表达式的可读性很差，可以引入一些解释变量从而拆分表达式：
```
-if line.split(':')[0].strip() == "root":
- ...
+if line.split(':')[0].strip() == "root":
+ ...
```
```
-username = line.split(':')[0].strip()
-if username == "root":
- ...
+username = line.split(':')[0].strip()
+if username == "root":
+ ...
```
使用摩根定理简化一些逻辑表达式：
```
-if(!a && !b) {
- ...
+if(!a && !b) {
+ ...
}
```
```
-if(a || b) {
- ...
+if(a || b) {
+ ...
}
```
-# 变量与可读性
+# 变量与可读性
-**去除控制流变量**。在循环中通过使用 break 或者 return 可以减少控制流变量的使用。
+**去除控制流变量** 。在循环中通过使用 break 或者 return 可以减少控制流变量的使用。
```
-boolean done = false;
-while(/* condition */ && !done) {
- ...
- if(...) {
- done = true;
- continue;
- }
+boolean done = false;
+while(/* condition */ && !done) {
+ ...
+ if(...) {
+ done = true;
+ continue;
+ }
}
```
```
-while(/* condition */) {
- ...
- if(...) {
- break;
- }
+while(/* condition */) {
+ ...
+ if(...) {
+ break;
+ }
}
```
-**减小变量作用域**。作用域越小，越容易定位到变量所有使用的地方。
+**减小变量作用域** 。作用域越小，越容易定位到变量所有使用的地方。
-JavaScript 可以用闭包减小作用域。以下代码中 submit_form 是函数变量，submitted 变量控制函数不会被提交两次。第一个实现中 submitted 是全局变量，第二个实现把 submitted 放到匿名函数中，从而限制了起作用域范围。
+JavaScript 可以用闭包减小作用域。以下代码中 submit_form 是函数变量，submitted 变量控制函数不会被提交两次。第一个实现中 submitted 是全局变量，第二个实现把 submitted 放到匿名函数中，从而限制了起作用域范围。
```
-submitted = false;
-var submit_form = function(form_name) {
- if(submitted) {
- return;
- }
- submitted = true;
+submitted = false;
+var submit_form = function(form_name) {
+ if(submitted) {
+ return;
+ }
+ submitted = true;
};
```
```
-var submit_form = (function() {
- var submitted = false;
- return function(form_name) {
- if(submitted) {
- return;
- }
- submitted = true;
- }
-}()); // () 使得外层匿名函数立即执行
+var submit_form = (function() {
+ var submitted = false;
+ return function(form_name) {
+ if(submitted) {
+ return;
+ }
+ submitted = true;
+ }
+}()); // () 使得外层匿名函数立即执行
```
-JavaScript 中没有用 var 声明的变量都是全局变量，而全局变量很容易造成迷惑，因此应当总是用 var 来声明变量。
+JavaScript 中没有用 var 声明的变量都是全局变量，而全局变量很容易造成迷惑，因此应当总是用 var 来声明变量。
变量定义的位置应当离它使用的位置最近。
-**实例解析**
+**实例解析**
在一个网页中有以下文本输入字段：
```
-
-
-
-