auto commit
This commit is contained in:
CyC2018
parent
eacd9d07ac
commit
819060dc94
108
notes/Java 并发.md
108
notes/Java 并发.md
|
|
@ -733,7 +733,6 @@ java.util.concurrent（J.U.C）大大提高了并发性能，AQS 被认为是 J.
|
|||
|
||||
```java
|
||||
public class CountdownLatchExample {
|
||||
|
||||
public static void main(String[] args) throws InterruptedException {
|
||||
final int totalThread = 10;
|
||||
CountDownLatch countDownLatch = new CountDownLatch(totalThread);
|
||||
|
|
@ -759,15 +758,30 @@ run..run..run..run..run..run..run..run..run..run..end
|
|||
|
||||
用来控制多个线程互相等待，只有当多个线程都到达时，这些线程才会继续执行。
|
||||
|
||||
和 CountdownLatch 相似，都是通过维护计数器来实现的。但是它的计数器是递增的，每次执行 await() 方法之后，计数器会加 1，直到计数器的值和设置的值相等，等待的所有线程才会继续执行。和 CountdownLatch 的另一个区别是，CyclicBarrier 的计数器可以循环使用，所以它才叫做循环屏障。
|
||||
和 CountdownLatch 相似，都是通过维护计数器来实现的。线程执行 await() 方法之后计数器会减 1，并进行等待，直到计数器为 0，所有调用 awati() 方法而在等待的线程才能继续执行。
|
||||
|
||||
下图应该从下往上看才正确。
|
||||
CyclicBarrier 和 CountdownLatch 的一个区别是，CyclicBarrier 的计数器通过调用 reset() 方法可以循环使用，所以它才叫做循环屏障。
|
||||
|
||||
CyclicBarrier 有两个构造函数，其中 parties 指示计数器的初始值，barrierAction 在所有线程都到达屏障的时候会执行一次。
|
||||
|
||||
```java
|
||||
public CyclicBarrier(int parties, Runnable barrierAction) {
|
||||
if (parties <= 0) throw new IllegalArgumentException();
|
||||
this.parties = parties;
|
||||
this.count = parties;
|
||||
this.barrierCommand = barrierAction;
|
||||
}
|
||||
|
||||
public CyclicBarrier(int parties) {
|
||||
this(parties, null);
|
||||
}
|
||||
```
|
||||
|
||||
<div align="center"> <img src="../pics//CyclicBarrier.png" width=""/> </div><br>
|
||||
|
||||
```java
|
||||
public class CyclicBarrierExample {
|
||||
public static void main(String[] args) throws InterruptedException {
|
||||
public static void main(String[] args) {
|
||||
final int totalThread = 10;
|
||||
CyclicBarrier cyclicBarrier = new CyclicBarrier(totalThread);
|
||||
ExecutorService executorService = Executors.newCachedThreadPool();
|
||||
|
|
@ -776,9 +790,7 @@ public class CyclicBarrierExample {
|
|||
System.out.print("before..");
|
||||
try {
|
||||
cyclicBarrier.await();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
} catch (BrokenBarrierException e) {
|
||||
} catch (InterruptedException | BrokenBarrierException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
System.out.print("after..");
|
||||
|
|
@ -1198,8 +1210,6 @@ volatile 关键字通过添加内存屏障的方式来禁止指令重排，即
|
|||
|
||||
上面提到了可以用 volatile 和 synchronized 来保证有序性。除此之外，JVM 还规定了先行发生原则，让一个操作无需控制就能先于另一个操作完成。
|
||||
|
||||
主要有以下这些原则：
|
||||
|
||||
### 1. 单一线程原则
|
||||
|
||||
> Single Thread rule
|
||||
|
|
@ -1270,14 +1280,16 @@ Thread 对象的结束先行发生于 join() 方法返回。
|
|||
|
||||
### 1. 不可变
|
||||
|
||||
不可变（Immutable）的对象一定是线程安全的，无论是对象的方法实现还是方法的调用者，都不需要再采取任何的线程安全保障措施，只要一个不可变的对象被正确地构建出来，那其外部的可见状态永远也不会改变，永远也不会看到它在多个线程之中处于不一致的状态。
|
||||
不可变（Immutable）的对象一定是线程安全的，不需要再采取任何的线程安全保障措施。只要一个不可变的对象被正确地构建出来，永远也不会看到它在多个线程之中处于不一致的状态。
|
||||
|
||||
多线程环境下，应当尽量使对象成为不可变，来满足线程安全。
|
||||
|
||||
不可变的类型：
|
||||
|
||||
- final 关键字修饰的基本数据类型；
|
||||
- final 关键字修饰的基本数据类型
|
||||
- String
|
||||
- 枚举类型
|
||||
- Number 部分子类，如 Long 和 Double 等数值包装类型，BigInteger 和 BigDecimal 等大数据类型。但同为 Number 的子类型的原子类 AtomicInteger 和 AtomicLong 则并非不可变的。
|
||||
- Number 部分子类，如 Long 和 Double 等数值包装类型，BigInteger 和 BigDecimal 等大数据类型。但同为 Number 的原子类 AtomicInteger 和 AtomicLong 则是可变的。
|
||||
|
||||
对于集合类型，可以使用 Collections.unmodifiableXXX() 方法来获取一个不可变的集合。
|
||||
|
||||
|
|
@ -1305,21 +1317,19 @@ public V put(K key, V value) {
|
|||
}
|
||||
```
|
||||
|
||||
多线程环境下，应当尽量使对象成为不可变，来满足线程安全。
|
||||
|
||||
### 2. 绝对线程安全
|
||||
|
||||
不管运行时环境如何，调用者都不需要任何额外的同步措施。
|
||||
|
||||
### 3. 相对线程安全
|
||||
|
||||
相对的线程安全需要保证对这个对象单独的操作是线程安全的，在调用的时候不需要做额外的保障措施，但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性。
|
||||
相对线程安全需要保证对这个对象单独的操作是线程安全的，在调用的时候不需要做额外的保障措施。但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性。
|
||||
|
||||
在 Java 语言中，大部分的线程安全类都属于这种类型，例如 Vector、HashTable、Collections 的 synchronizedCollection() 方法包装的集合等。
|
||||
|
||||
对于下面的代码，如果删除元素的线程删除了一个元素，而获取元素的线程试图访问一个已经被删除的元素，那么就会抛出 ArrayIndexOutOfBoundsException。
|
||||
对于下面的代码，如果删除元素的线程删除了 Vector 的一个元素，而获取元素的线程试图访问一个已经被删除的元素，那么就会抛出 ArrayIndexOutOfBoundsException。
|
||||
|
||||
```java
|
||||
```Java
|
||||
public class VectorUnsafeExample {
|
||||
private static Vector<Integer> vector = new Vector<>();
|
||||
|
||||
|
|
@ -1389,15 +1399,17 @@ synchronized 和 ReentrantLock。
|
|||
|
||||
### 2. 非阻塞同步
|
||||
|
||||
互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。
|
||||
互斥同步最主要的问题就是线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。
|
||||
|
||||
互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施，那就肯定会出现问题。论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。
|
||||
互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施，那就肯定会出现问题。无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。
|
||||
|
||||
随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略：先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施（不断地重试，直到成功为止）。这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步。
|
||||
**（一）CAS**
|
||||
|
||||
乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。
|
||||
随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略：先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施（不断地重试，直到成功为止）。这种乐观的并发策略的许多实现都不需要将线程阻塞，因此这种同步操作称为非阻塞同步。
|
||||
|
||||
硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。
|
||||
乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。
|
||||
|
||||
**（二）AtomicInteger**
|
||||
|
||||
J.U.C 包里面的整数原子类 AtomicInteger，其中的 compareAndSet() 和 getAndIncrement() 等方法都使用了 Unsafe 类的 CAS 操作。
|
||||
|
||||
|
|
@ -1419,7 +1431,7 @@ public final int incrementAndGet() {
|
|||
}
|
||||
```
|
||||
|
||||
以下代码是 getAndAddInt() 源码，var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值 ==var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。
|
||||
以下代码是 getAndAddInt() 源码，var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值等于 var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。
|
||||
|
||||
可以看到 getAndAddInt() 在一个循环中进行，发生冲突的做法是不断的进行重试。
|
||||
|
||||
|
|
@ -1434,23 +1446,19 @@ public final int getAndAddInt(Object var1, long var2, int var4) {
|
|||
}
|
||||
```
|
||||
|
||||
ABA ：如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。
|
||||
**（三）ABA**
|
||||
|
||||
如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。
|
||||
|
||||
J.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
|
||||
|
||||
### 3. 无同步方案
|
||||
|
||||
要保证线程安全，并不是一定就要进行同步，两者没有因果关系。同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的。
|
||||
要保证线程安全，并不是一定就要进行同步。如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性。
|
||||
|
||||
**（一）可重入代码（Reentrant Code）**
|
||||
**（一）栈封闭**
|
||||
|
||||
这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。
|
||||
|
||||
可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。
|
||||
|
||||
**（二）栈封闭**
|
||||
|
||||
多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在栈中，属于线程私有的。
|
||||
多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在虚拟机栈中，属于线程私有的。
|
||||
|
||||
```java
|
||||
import java.util.concurrent.ExecutorService;
|
||||
|
|
@ -1482,11 +1490,11 @@ public static void main(String[] args) {
|
|||
100
|
||||
```
|
||||
|
||||
**（三）线程本地存储（Thread Local Storage）**
|
||||
**（二）线程本地存储（Thread Local Storage）**
|
||||
|
||||
如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。
|
||||
|
||||
符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完，其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。
|
||||
符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完。其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。
|
||||
|
||||
可以使用 java.lang.ThreadLocal 类来实现线程本地存储功能。
|
||||
|
||||
|
|
@ -1584,17 +1592,25 @@ public T get() {
|
|||
}
|
||||
```
|
||||
|
||||
ThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因为根本不存在多线程竞争。在一些场景 (尤其是使用线程池) 下，由于 ThreadLocal.ThreadLocalMap 的底层数据结构导致 ThreadLocal 有内存泄漏的情况，尽可能在每次使用 ThreadLocal 后手动调用 remove()，以避免出现 ThreadLocal 经典的内存泄漏甚至是造成自身业务混乱的风险。
|
||||
ThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因为根本不存在多线程竞争。
|
||||
|
||||
在一些场景 (尤其是使用线程池) 下，由于 ThreadLocal.ThreadLocalMap 的底层数据结构导致 ThreadLocal 有内存泄漏的情况，应该尽可能在每次使用 ThreadLocal 后手动调用 remove()，以避免出现 ThreadLocal 经典的内存泄漏甚至是造成自身业务混乱的风险。
|
||||
|
||||
**（三）可重入代码（Reentrant Code）**
|
||||
|
||||
这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。
|
||||
|
||||
可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。
|
||||
|
||||
# 十二、锁优化
|
||||
|
||||
这里的锁优化主要是指虚拟机对 synchronized 的优化。
|
||||
这里的锁优化主要是指 JVM 对 synchronized 的优化。
|
||||
|
||||
## 自旋锁
|
||||
|
||||
互斥同步的进入阻塞状态的开销都很大，应该尽量避免。在许多应用中，共享数据的锁定状态只会持续很短的一段时间。自旋锁的思想是让一个线程在请求一个共享数据的锁时执行忙循环（自旋）一段时间，如果在这段时间内能获得锁，就可以避免进入阻塞状态。
|
||||
互斥同步进入阻塞状态的开销都很大，应该尽量避免。在许多应用中，共享数据的锁定状态只会持续很短的一段时间。自旋锁的思想是让一个线程在请求一个共享数据的锁时执行忙循环（自旋）一段时间，如果在这段时间内能获得锁，就可以避免进入阻塞状态。
|
||||
|
||||
自选锁虽然能避免进入阻塞状态从而减少开销，但是它需要进行忙循环操作占用 CPU 时间，它只适用于共享数据的锁定状态很短的场景。
|
||||
自旋锁虽然能避免进入阻塞状态从而减少开销，但是它需要进行忙循环操作占用 CPU 时间，它只适用于共享数据的锁定状态很短的场景。
|
||||
|
||||
在 JDK 1.6 中引入了自适应的自旋锁。自适应意味着自旋的次数不再固定了，而是由前一次在同一个锁上的自旋次数及锁的拥有者的状态来决定。
|
||||
|
||||
|
|
@ -1624,7 +1640,7 @@ public static String concatString(String s1, String s2, String s3) {
|
|||
}
|
||||
```
|
||||
|
||||
每个 append() 方法中都有一个同步块。虚拟机观察变量 sb，很快就会发现它的动态作用域被限制在 concatString() 方法内部。也就是说，sb 的所有引用永远不会“逃逸”到 concatString() 方法之外，其他线程无法访问到它，因此可以进行消除。
|
||||
每个 append() 方法中都有一个同步块。虚拟机观察变量 sb，很快就会发现它的动态作用域被限制在 concatString() 方法内部。也就是说，sb 的所有引用永远不会逃逸到 concatString() 方法之外，其他线程无法访问到它，因此可以进行消除。
|
||||
|
||||
## 锁粗化
|
||||
|
||||
|
|
@ -1636,9 +1652,9 @@ public static String concatString(String s1, String s2, String s3) {
|
|||
|
||||
JDK 1.6 引入了偏向锁和轻量级锁，从而让锁拥有了四个状态：无锁状态（unlocked）、偏向锁状态（biasble）、轻量级锁状态（lightweight locked）和重量级锁状态（inflated）。
|
||||
|
||||
以下是 HotSpot 虚拟机对象头的内存布局，这些数据被称为 mark word。其中 tag bits 对应了五个状态，这些状态在右侧的 state 表格中给出，应该注意的是 state 表格不是存储在对象头中的。除了 marked for gc 状态，其它四个状态已经在前面介绍过了。
|
||||
以下是 HotSpot 虚拟机对象头的内存布局，这些数据被称为 Mark Word。其中 tag bits 对应了五个状态，这些状态在右侧的 state 表格中给出。除了 marked for gc 状态，其它四个状态已经在前面介绍过了。
|
||||
|
||||
<div align="center"> <img src="../pics//bb6a49be-00f2-4f27-a0ce-4ed764bc605c.png" width="600"/> </div><br>
|
||||
<div align="center"> <img src="../pics//bb6a49be-00f2-4f27-a0ce-4ed764bc605c.png" width="500"/> </div><br>
|
||||
|
||||
下图左侧是一个线程的虚拟机栈，其中有一部分称为 Lock Record 的区域，这是在轻量级锁运行过程创建的，用于存放锁对象的 Mark Word。而右侧就是一个锁对象，包含了 Mark Word 和其它信息。
|
||||
|
||||
|
|
@ -1646,9 +1662,9 @@ JDK 1.6 引入了偏向锁和轻量级锁，从而让锁拥有了四个状态：
|
|||
|
||||
轻量级锁是相对于传统的重量级锁而言，它使用 CAS 操作来避免重量级锁使用互斥量的开销。对于绝大部分的锁，在整个同步周期内都是不存在竞争的，因此也就不需要都使用互斥量进行同步，可以先采用 CAS 操作进行同步，如果 CAS 失败了再改用互斥量进行同步。
|
||||
|
||||
当尝试获取一个锁对象时，如果锁对象标记为 0 01，说明锁对象的锁未锁定（unlocked）状态。此时虚拟机在当前线程栈中创建 Lock Record，然后使用 CAS 操作将对象的 Mark Word 更新为 Lock Record 指针。如果 CAS 操作成功了，那么线程就获取了该对象上的锁，并且对象的 Mark Word 的锁标记变为 00，表示该对象处于轻量级锁状态。
|
||||
当尝试获取一个锁对象时，如果锁对象标记为 0 01，说明锁对象的锁未锁定（unlocked）状态。此时虚拟机在当前线程的虚拟机栈中创建 Lock Record，然后使用 CAS 操作将对象的 Mark Word 更新为 Lock Record 指针。如果 CAS 操作成功了，那么线程就获取了该对象上的锁，并且对象的 Mark Word 的锁标记变为 00，表示该对象处于轻量级锁状态。
|
||||
|
||||
<div align="center"> <img src="../pics//baaa681f-7c52-4198-a5ae-303b9386cf47.png" width="500"/> </div><br>
|
||||
<div align="center"> <img src="../pics//baaa681f-7c52-4198-a5ae-303b9386cf47.png" width="400"/> </div><br>
|
||||
|
||||
如果 CAS 操作失败了，虚拟机首先会检查对象的 Mark Word 是否指向当前线程的虚拟机栈，如果是的话说明当前线程已经拥有了这个锁对象，那就可以直接进入同步块继续执行，否则说明这个锁对象已经被其他线程线程抢占了。如果有两条以上的线程争用同一个锁，那轻量级锁就不再有效，要膨胀为重量级锁。
|
||||
|
||||
|
|
@ -1666,9 +1682,9 @@ JDK 1.6 引入了偏向锁和轻量级锁，从而让锁拥有了四个状态：
|
|||
|
||||
- 给线程起个有意义的名字，这样可以方便找 Bug。
|
||||
|
||||
- 缩小同步范围，例如对于 synchronized，应该尽量使用同步块而不是同步方法。
|
||||
- 缩小同步范围，从而减少锁争用。例如对于 synchronized，应该尽量使用同步块而不是同步方法。
|
||||
|
||||
- 多用同步类少用 wait() 和 notify()。首先，CountDownLatch, CyclicBarrier, Semaphore 和 Exchanger 这些同步类简化了编码操作，而用 wait() 和 notify() 很难实现对复杂的控制流；其次，这些同步类是由最好的企业编写和维护，在后续的 JDK 中还会不断优化和完善，使用这些更高等级的同步工具你的程序可以不费吹灰之力获得优化。
|
||||
- 多用同步工具少用 wait() 和 notify()。首先，CountDownLatch, CyclicBarrier, Semaphore 和 Exchanger 这些同步类简化了编码操作，而用 wait() 和 notify() 很难实现复杂控制流；其次，这些同步类是由最好的企业编写和维护，在后续的 JDK 中还会不断优化和完善，使用这些更高等级的同步工具你的程序可以不费吹灰之力获得优化。
|
||||
|
||||
- 多用并发集合少用同步集合，例如应该使用 ConcurrentHashMap 而不是 Hashtable。
|
||||
|
||||
|
|
|
|||
|
|
@ -2520,7 +2520,7 @@ public void FindNumsAppearOnce(int[] nums, int num1[], int num2[]) {
|
|||
|
||||
## 题目描述
|
||||
|
||||
输入一个递增排序的数组和一个数字 S，在数组中查找两个数，使得他们的和正好是 S，如果有多对数字的和等于 S，输出两个数的乘积最小的。
|
||||
输入一个递增排序的数组和一个数字 S，在数组中查找两个数，使得他们的和正好是 S。如果有多对数字的和等于 S，输出两个数的乘积最小的。
|
||||
|
||||
## 解题思路
|
||||
|
||||
|
|
@ -2596,9 +2596,13 @@ public ArrayList<ArrayList<Integer>> FindContinuousSequence(int sum) {
|
|||
|
||||
## 题目描述
|
||||
|
||||
输入："I am a student."
|
||||
```html
|
||||
Input:
|
||||
"I am a student."
|
||||
|
||||
输出："student. a am I"
|
||||
Output:
|
||||
"student. a am I"
|
||||
```
|
||||
|
||||
## 解题思路
|
||||
|
||||
|
|
@ -2640,7 +2644,14 @@ private void swap(char[] c, int i, int j) {
|
|||
|
||||
## 题目描述
|
||||
|
||||
对于一个给定的字符序列 S，请你把其循环左移 K 位后的序列输出。例如，字符序列 S=”abcXYZdef”, 要求输出循环左移 3 位后的结果，即“XYZdefabc”。
|
||||
```html
|
||||
Input:
|
||||
S="abcXYZdef"
|
||||
K=3
|
||||
|
||||
Output:
|
||||
"XYZdefabc"
|
||||
```
|
||||
|
||||
## 解题思路
|
||||
|
||||
|
|
@ -2675,7 +2686,9 @@ private void swap(char[] chars, int i, int j) {
|
|||
|
||||
## 题目描述
|
||||
|
||||
给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组 {2, 3, 4, 2, 6, 2, 5, 1} 及滑动窗口的大小 3，那么一共存在 6 个滑动窗口，他们的最大值分别为 {4, 4, 6, 6, 6, 5}。
|
||||
给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。
|
||||
|
||||
例如，如果输入数组 {2, 3, 4, 2, 6, 2, 5, 1} 及滑动窗口的大小 3，那么一共存在 6 个滑动窗口，他们的最大值分别为 {4, 4, 6, 6, 6, 5}。
|
||||
|
||||
## 解题思路
|
||||
|
||||
|
|
@ -2774,7 +2787,7 @@ public List<Map.Entry<Integer, Double>> dicesSum(int n) {
|
|||
|
||||
## 题目描述
|
||||
|
||||
五张牌，其中大小鬼为癞子，牌面大小为 0。判断是否能组成顺子。
|
||||
五张牌，其中大小鬼为癞子，牌面大小为 0。判断这五张牌是否能组成顺子。
|
||||
|
||||
## 解题思路
|
||||
|
||||
|
|
@ -2803,7 +2816,7 @@ public boolean isContinuous(int[] nums) {
|
|||
|
||||
## 题目描述
|
||||
|
||||
让小朋友们围成一个大圈。然后，他随机指定一个数 m，让编号为 0 的小朋友开始报数。每次喊到 m-1 的那个小朋友要出列唱首歌，然后可以在礼品箱中任意的挑选礼物，并且不再回到圈中，从他的下一个小朋友开始，继续 0...m-1 报数 .... 这样下去 .... 直到剩下最后一个小朋友，可以不用表演。
|
||||
让小朋友们围成一个大圈。然后，随机指定一个数 m，让编号为 0 的小朋友开始报数。每次喊到 m-1 的那个小朋友要出列唱首歌，然后可以在礼品箱中任意的挑选礼物，并且不再回到圈中，从他的下一个小朋友开始，继续 0...m-1 报数 .... 这样下去 .... 直到剩下最后一个小朋友，可以不用表演。
|
||||
|
||||
## 解题思路
|
||||
|
||||
|
|
@ -2813,7 +2826,7 @@ public boolean isContinuous(int[] nums) {
|
|||
public int LastRemaining_Solution(int n, int m) {
|
||||
if (n == 0) /* 特殊输入的处理 */
|
||||
return -1;
|
||||
if (n == 1) /* 返回条件 */
|
||||
if (n == 1) /* 递归返回条件 */
|
||||
return 0;
|
||||
return (LastRemaining_Solution(n - 1, m) + m) % n;
|
||||
}
|
||||
|
|
@ -2851,7 +2864,7 @@ public int maxProfit(int[] prices) {
|
|||
|
||||
## 题目描述
|
||||
|
||||
求 1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case 等关键字及条件判断语句（A?B:C）。
|
||||
要求不能使用乘除法、for、while、if、else、switch、case 等关键字及条件判断语句 A ? B : C。
|
||||
|
||||
## 解题思路
|
||||
|
||||
|
|
@ -2859,7 +2872,7 @@ public int maxProfit(int[] prices) {
|
|||
|
||||
条件与 && 具有短路原则，即在第一个条件语句为 false 的情况下不会去执行第二个条件语句。利用这一特性，将递归的返回条件取非然后作为 && 的第一个条件语句，递归的主体转换为第二个条件语句，那么当递归的返回条件为 true 的情况下就不会执行递归的主体部分，递归返回。
|
||||
|
||||
以下实现中，递归的返回条件为 n <= 0，取非后就是 n > 0，递归的主体部分为 sum += Sum_Solution(n - 1)，转换为条件语句后就是 (sum += Sum_Solution(n - 1)) > 0。
|
||||
本题的递归返回条件为 n <= 0，取非后就是 n > 0；递归的主体部分为 sum += Sum_Solution(n - 1)，转换为条件语句后就是 (sum += Sum_Solution(n - 1)) > 0。
|
||||
|
||||
```java
|
||||
public int Sum_Solution(int n) {
|
||||
|
|
@ -2875,7 +2888,7 @@ public int Sum_Solution(int n) {
|
|||
|
||||
## 题目描述
|
||||
|
||||
写一个函数，求两个整数之和，要求在函数体内不得使用 +、-、\*、/ 四则运算符号。
|
||||
写一个函数，求两个整数之和，要求不得使用 +、-、\*、/ 四则运算符号。
|
||||
|
||||
## 解题思路
|
||||
|
||||
|
|
@ -2895,7 +2908,7 @@ public int Add(int a, int b) {
|
|||
|
||||
## 题目描述
|
||||
|
||||
给定一个数组 A[0, 1,..., n-1], 请构建一个数组 B[0, 1,..., n-1], 其中 B 中的元素 B[i]=A[0]\*A[1]\*...\*A[i-1]\*A[i+1]\*...\*A[n-1]。不能使用除法。
|
||||
给定一个数组 A[0, 1,..., n-1]，请构建一个数组 B[0, 1,..., n-1]，其中 B 中的元素 B[i]=A[0]\*A[1]\*...\*A[i-1]\*A[i+1]\*...\*A[n-1]。要求不能使用除法。
|
||||
|
||||
## 解题思路
|
||||
|
||||
|
|
@ -2917,7 +2930,7 @@ public int[] multiply(int[] A) {
|
|||
|
||||
## 题目描述
|
||||
|
||||
将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为 0 或者字符串不是一个合法的数值则返回 0。
|
||||
将一个字符串转换成一个整数，字符串不是一个合法的数值则返回 0，要求不能使用字符串转换整数的库函数。
|
||||
|
||||
```html
|
||||
Iuput:
|
||||
|
|
@ -2979,7 +2992,7 @@ public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
|
|||
|
||||
[Leetcode : 236. Lowest Common Ancestor of a Binary Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
|
||||
|
||||
在左右子树中查找是否存在 p 或者 q，如果 p 和 q 分别在两个子树中，那么就说明根节点就是 LCA。
|
||||
在左右子树中查找是否存在 p 或者 q，如果 p 和 q 分别在两个子树中，那么就说明根节点就是最低公共祖先。
|
||||
|
||||
```java
|
||||
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user