From 9a4f6ea86cffff577870849dcdd5d724295937e9 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 12 Aug 2018 22:53:28 +0800
Subject: [PATCH] auto commit
---
notes/HTTP.md | 33 +-
notes/Java 容器.md | 61 +-
notes/Leetcode 题解.md | 2933 +++++++++++-----------
notes/Leetcode-Database 题解.md | 20 +-
notes/剑指 offer 题解.md | 281 +--
notes/攻击技术.md | 8 +-
notes/数据库系统原理.md | 30 +-
notes/算法.md | 30 +-
notes/系统设计基础.md | 2 +-
notes/设计模式.md | 43 +-
pics/VP4n3i8m34Ntd28NQ4_0KCJ2q044Oez.png | Bin 0 -> 21504 bytes
11 files changed, 1719 insertions(+), 1722 deletions(-)
create mode 100644 pics/VP4n3i8m34Ntd28NQ4_0KCJ2q044Oez.png
diff --git a/notes/HTTP.md b/notes/HTTP.md
index 243dc283..537b24fe 100644
--- a/notes/HTTP.md
+++ b/notes/HTTP.md
@@ -45,7 +45,7 @@
* [二进制分帧层](#二进制分帧层)
* [服务端推送](#服务端推送)
* [首部压缩](#首部压缩)
-* [八、GET 和 POST 的区别](#八get-和-post-的区别)
+* [八、GET 和 POST 比较](#八get-和-post-比较)
* [作用](#作用)
* [参数](#参数)
* [安全](#安全)
@@ -61,13 +61,13 @@
## URL
-- URI（Uniform Resource Identifier，统一资源标识符）
-- URL（Uniform Resource Locator，统一资源定位符）
-- URN（Uniform Resource Name，统一资源名称），例如 urn:isbn:0-486-27557-4。
-
URI 包含 URL 和 URN，目前 WEB 只有 URL 比较流行，所以见到的基本都是 URL。
- 
+- URI（Uniform Resource Identifier，统一资源标识符）
+- URL（Uniform Resource Locator，统一资源定位符）
+- URN（Uniform Resource Name，统一资源名称）
+
+ 
## 请求和响应报文
@@ -197,7 +197,7 @@ CONNECT www.example.com:443 HTTP/1.1
- **204 No Content** ：请求已经成功处理，但是返回的响应报文不包含实体的主体部分。一般在只需要从客户端往服务器发送信息，而不需要返回数据时使用。
-- **206 Partial Content** ：表示客户端进行了范围请求。响应报文包含由 Content-Range 指定范围的实体内容。
+- **206 Partial Content** ：表示客户端进行了范围请求，响应报文包含由 Content-Range 指定范围的实体内容。
## 3XX 重定向
@@ -219,7 +219,7 @@ CONNECT www.example.com:443 HTTP/1.1
- **401 Unauthorized** ：该状态码表示发送的请求需要有认证信息（BASIC 认证、DIGEST 认证）。如果之前已进行过一次请求，则表示用户认证失败。
-- **403 Forbidden** ：请求被拒绝，服务器端没有必要给出拒绝的详细理由。
+- **403 Forbidden** ：请求被拒绝。
- **404 Not Found**
@@ -331,7 +331,7 @@ Set-Cookie: tasty_cookie=strawberry
[page content]
```
-客户端之后对同一个服务器发送请求时，会从浏览器中读出 Cookie 信息通过 Cookie 请求首部字段发送给服务器。
+客户端之后对同一个服务器发送请求时，会从浏览器中取出 Cookie 信息并通过 Cookie 请求首部字段发送给服务器。
```html
GET /sample_page.html HTTP/1.1
@@ -382,9 +382,9 @@ Path 标识指定了主机下的哪些路径可以接受 Cookie（该 URL 路径
除了可以将用户信息通过 Cookie 存储在用户浏览器中，也可以利用 Session 存储在服务器端，存储在服务器端的信息更加安全。
-Session 可以存储在服务器上的文件、数据库或者内存中。也可以将 Session 存储在内存型数据库中，比如 Redis，效率会更高。
+Session 可以存储在服务器上的文件、数据库或者内存中。也可以将 Session 存储在 Redis 这种内存型数据库中，效率会更高。
-使用 Session 维护用户登录的过程如下：
+使用 Session 维护用户登录状态的过程如下：
- 用户进行登录时，用户提交包含用户名和密码的表单，放入 HTTP 请求报文中；
- 服务器验证该用户名和密码；
@@ -499,7 +499,7 @@ If-Modified-Since: Wed, 21 Oct 2015 07:28:00 GMT
### 1. 短连接与长连接
-当浏览器访问一个包含多张图片的 HTML 页面时，除了请求访问 HTML 页面资源，还会请求图片资源。如果每进行一次 HTTP 通信就要断开一次 TCP 连接，连接建立和断开的开销会很大。
+当浏览器访问一个包含多张图片的 HTML 页面时，除了请求访问 HTML 页面资源，还会请求图片资源。如果每进行一次 HTTP 通信就要新建一个 TCP 连接，那么开销会很大。
长连接只需要建立一次 TCP 连接就能进行多次 HTTP 通信。
@@ -688,7 +688,7 @@ HTTPs 并不是新协议，而是让 HTTP 先和 SSL（Secure Sockets Layer）
### 3. HTTPs 采用的加密方式
-HTTPs 采用混合的加密机制，使用非对称密钥加密用于传输对称密钥来保证安全性，之后使用对称密钥加密进行通信来保证效率。（下图中的 Session Key 就是对称密钥）
+HTTPs 采用混合的加密机制，使用非对称密钥加密用于传输对称密钥来保证传输过程的安全性，之后使用对称密钥加密进行通信来保证通信过程的效率。（下图中的 Session Key 就是对称密钥）
@@ -717,7 +717,7 @@ HTTPs 的报文摘要功能之所以安全，是因为它结合了加密和认
## HTTPs 的缺点
- 因为需要进行加密解密等过程，因此速度会更慢；
-- 需要支付证书授权的高费用。
+- 需要支付证书授权的高额费用。
## 配置 HTTPs
@@ -727,7 +727,7 @@ HTTPs 的报文摘要功能之所以安全，是因为它结合了加密和认
## HTTP/1.x 缺陷
- HTTP/1.x 实现简单是以牺牲应用性能为代价的：
+ HTTP/1.x 实现简单是以牺牲性能为代价的：
- 客户端需要使用多个连接才能实现并发和缩短延迟；
- 不会压缩请求和响应首部，从而导致不必要的网络流量；
@@ -763,7 +763,7 @@ HTTP/2.0 要求客户端和服务器同时维护和更新一个包含之前见
-# 八、GET 和 POST 的区别
+# 八、GET 和 POST 比较
## 作用
@@ -870,6 +870,7 @@ DELETE /idX/delete HTTP/1.1 -> Returns 404
- [MDN : HTTP](https://developer.mozilla.org/en-US/docs/Web/HTTP)
- [HTTP/2 简介](https://developers.google.com/web/fundamentals/performance/http2/?hl=zh-cn)
- [htmlspecialchars](http://php.net/manual/zh/function.htmlspecialchars.php)
+- [Difference between file URI and URL in java](http://java2db.com/java-io/how-to-get-and-the-difference-between-file-uri-and-url-in-java)
- [How to Fix SQL Injection Using Java PreparedStatement & CallableStatement](https://software-security.sans.org/developer-how-to/fix-sql-injection-in-java-using-prepared-callable-statement)
- [浅谈 HTTP 中 Get 与 Post 的区别](https://www.cnblogs.com/hyddd/archive/2009/03/31/1426026.html)
- [Are http:// and www really necessary?](https://www.webdancers.com/are-http-and-www-necesary/)
diff --git a/notes/Java 容器.md b/notes/Java 容器.md
index bf1921fc..af118e4c 100644
--- a/notes/Java 容器.md
+++ b/notes/Java 容器.md
@@ -25,7 +25,7 @@
## Collection
- 
+ 
### 1. Set
@@ -129,12 +129,67 @@ private static final int DEFAULT_CAPACITY = 10;
ArrayList 基于数组实现，并且具有动态扩容特性，因此保存元素的数组不一定都会被使用，那么就没必要全部进行序列化。
-保存元素的数组 elementData 使用 transient 修饰，该关键字声明数组默认不会被序列化。ArrayList 重写了 writeObject() 和 readObject() 来控制只序列化数组中有元素填充那部分内容。
+保存元素的数组 elementData 使用 transient 修饰，该关键字声明数组默认不会被序列化。
```java
transient Object[] elementData; // non-private to simplify nested class access
```
+ArrayList 实现了 writeObject() 和 readObject() 来控制只序列化数组中有元素填充那部分内容。
+
+```java
+private void readObject(java.io.ObjectInputStream s)
+ throws java.io.IOException, ClassNotFoundException {
+ elementData = EMPTY_ELEMENTDATA;
+
+ // Read in size, and any hidden stuff
+ s.defaultReadObject();
+
+ // Read in capacity
+ s.readInt(); // ignored
+
+ if (size > 0) {
+ // be like clone(), allocate array based upon size not capacity
+ ensureCapacityInternal(size);
+
+ Object[] a = elementData;
+ // Read in all elements in the proper order.
+ for (int i=0; i> 1)`，也就是旧容量的 1.5 倍。
@@ -1080,7 +1135,7 @@ Set <|.. LinkedHashSet
SortSet <|.. TreeSet
List <|.. ArrayList
List <|.. Vector
-List <|.. LinkeList
+List <|.. LinkedList
Queue <|.. LinkedList
Queue <|.. PriorityQueue
diff --git a/notes/Leetcode 题解.md b/notes/Leetcode 题解.md
index 2813ce5d..44f3d9dc 100644
--- a/notes/Leetcode 题解.md
+++ b/notes/Leetcode 题解.md
@@ -1,18 +1,18 @@
* [算法思想](#算法思想)
- * [贪心思想](#贪心思想)
* [双指针](#双指针)
* [排序](#排序)
* [快速选择](#快速选择)
* [堆排序](#堆排序)
* [桶排序](#桶排序)
* [荷兰国旗问题](#荷兰国旗问题)
+ * [贪心思想](#贪心思想)
* [二分查找](#二分查找)
+ * [分治](#分治)
* [搜索](#搜索)
* [BFS](#bfs)
* [DFS](#dfs)
* [Backtracking](#backtracking)
- * [分治](#分治)
* [动态规划](#动态规划)
* [斐波那契数列](#斐波那契数列)
* [矩阵路径](#矩阵路径)
@@ -33,10 +33,6 @@
* [多数投票问题](#多数投票问题)
* [其它](#其它)
* [数据结构相关](#数据结构相关)
- * [栈和队列](#栈和队列)
- * [哈希表](#哈希表)
- * [字符串](#字符串)
- * [数组与矩阵](#数组与矩阵)
* [链表](#链表)
* [树](#树)
* [递归](#递归)
@@ -44,6 +40,10 @@
* [前中后序遍历](#前中后序遍历)
* [BST](#bst)
* [Trie](#trie)
+ * [栈和队列](#栈和队列)
+ * [哈希表](#哈希表)
+ * [字符串](#字符串)
+ * [数组与矩阵](#数组与矩阵)
* [图](#图)
* [二分图](#二分图)
* [拓扑排序](#拓扑排序)
@@ -55,9 +55,449 @@
# 算法思想
+## 双指针
+
+双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。
+
+**有序数组的 Two Sum**
+
+[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
+```
+
+题目描述：在有序数组中找出两个数，使它们的和为 target。
+
+使用双指针，一个指针指向值较小的元素，一个指针指向值较大的元素。指向较小元素的指针从头向尾遍历，指向较大元素的指针从尾向头遍历。
+
+- 如果两个指针指向元素的和 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;
+}
+```
+
+**两数平方和**
+
+[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
+```
+
+题目描述：判断一个数是否为两个数的平方和，例如 5 = 12 + 22。
+
+```java
+public boolean judgeSquareSum(int c) {
+ int i = 0, j = (int) Math.sqrt(c);
+ while (i <= j) {
+ int powSum = i * i + j * j;
+ if (powSum == c) {
+ return true;
+ } else if (powSum > c) {
+ j--;
+ } else {
+ i++;
+ }
+ }
+ return false;
+}
+```
+
+**反转字符串中的元音字符**
+
+[345. Reverse Vowels of a String (Easy)](https://leetcode.com/problems/reverse-vowels-of-a-string/description/)
+
+```html
+Given s = "leetcode", return "leotcede".
+```
+
+使用双指针，指向待反转的两个元音字符，一个指针从头向尾遍历，一个指针从尾到头遍历。
+
+```java
+private final static HashSet vowels = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));
+
+public String reverseVowels(String 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;
+ } else if (!vowels.contains(cj)) {
+ result[j--] = cj;
+ } else {
+ result[i++] = cj;
+ result[j--] = ci;
+ }
+ }
+ return new String(result);
+}
+```
+
+**回文字符串**
+
+[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'.
+```
+
+题目描述：可以删除一个字符，判断是否能构成回文字符串。
+
+```java
+public boolean validPalindrome(String s) {
+ int i = -1, j = s.length();
+ while (++i < --j) {
+ if (s.charAt(i) != s.charAt(j)) {
+ return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);
+ }
+ }
+ return true;
+}
+
+private boolean isPalindrome(String s, int i, int j) {
+ while (i < j) {
+ if (s.charAt(i++) != s.charAt(j--)) {
+ return false;
+ }
+ }
+ return true;
+}
+```
+
+**归并两个有序数组**
+
+[88. Merge Sorted Array (Easy)](https://leetcode.com/problems/merge-sorted-array/description/)
+
+```html
+Input:
+nums1 = [1,2,3,0,0,0], m = 3
+nums2 = [2,5,6], n = 3
+
+Output: [1,2,2,3,5,6]
+```
+
+题目描述：把归并结果存到第一个数组上。
+
+需要从尾开始遍历，否则在 nums1 上归并得到的值会覆盖还未进行归并比较的值。
+
+```java
+public void merge(int[] nums1, int m, int[] nums2, int n) {
+ int index1 = m - 1, index2 = n - 1;
+ int indexMerge = m + n - 1;
+ while (index1 >= 0 || index2 >= 0) {
+ if (index1 < 0) {
+ nums1[indexMerge--] = nums2[index2--];
+ } else if (index2 < 0) {
+ nums1[indexMerge--] = nums1[index1--];
+ } else if (nums1[index1] > nums2[index2]) {
+ nums1[indexMerge--] = nums1[index1--];
+ } else {
+ nums1[indexMerge--] = nums2[index2--];
+ }
+ }
+}
+```
+
+**判断链表是否存在环**
+
+[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 && l2.next != null) {
+ if (l1 == l2) {
+ return true;
+ }
+ l1 = l1.next;
+ l2 = l2.next.next;
+ }
+ return false;
+}
+```
+
+**最长子序列**
+
+[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"]
+
+Output:
+"apple"
+```
+
+题目描述：删除 s 中的一些字符，使得它构成字符串列表 d 中的一个字符串，找出能构成的最长字符串。如果有多个相同长度的结果，返回字典序的最大字符串。
+
+```java
+public String findLongestWord(String s, List d) {
+ String longestWord = "";
+ for (String target : d) {
+ int l1 = longestWord.length(), l2 = target.length();
+ if (l1 > l2 || (l1 == l2 && longestWord.compareTo(target) < 0)) {
+ continue;
+ }
+ if (isValid(s, target)) {
+ longestWord = target;
+ }
+ }
+ return longestWord;
+}
+
+private boolean isValid(String s, String target) {
+ int i = 0, j = 0;
+ while (i < s.length() && j < target.length()) {
+ if (s.charAt(i) == target.charAt(j)) {
+ j++;
+ }
+ i++;
+ }
+ return j == target.length();
+}
+```
+
+## 排序
+
+### 快速选择
+
+用于求解 **Kth Element** 问题，使用快速排序的 partition() 进行实现。
+
+需要先打乱数组，否则最坏情况下时间复杂度为 O(N2)。
+
+### 堆排序
+
+用于求解 **TopK Elements** 问题，通过维护一个大小为 K 的堆，堆中的元素就是 TopK Elements。
+
+堆排序也可以用于求解 Kth Element 问题，堆顶元素就是 Kth Element。
+
+快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。
+
+可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。
+
+**Kth Element**
+
+[215. Kth Largest Element in an Array (Medium)](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
+
+**排序** ：时间复杂度 O(NlogN)，空间复杂度 O(1)
+
+```java
+public int findKthLargest(int[] nums, int k) {
+ Arrays.sort(nums);
+ return nums[nums.length - k];
+}
+```
+
+**堆排序** ：时间复杂度 O(NlogK)，空间复杂度 O(K)。
+
+```java
+public int findKthLargest(int[] nums, int k) {
+ PriorityQueue pq = new PriorityQueue<>(); // 小顶堆
+ for (int val : nums) {
+ pq.add(val);
+ if (pq.size() > k) // 维护堆的大小为 K
+ pq.poll();
+ }
+ return pq.peek();
+}
+```
+
+**快速选择** ：时间复杂度 O(N)，空间复杂度 O(1)
+
+```java
+public int findKthLargest(int[] nums, int k) {
+ k = nums.length - k;
+ int l = 0, h = nums.length - 1;
+ while (l < h) {
+ int j = partition(nums, l, h);
+ if (j == k) {
+ break;
+ } else if (j < k) {
+ l = j + 1;
+ } else {
+ h = j - 1;
+ }
+ }
+ return nums[k];
+}
+
+private int partition(int[] a, int l, int h) {
+ int i = l, j = h + 1;
+ while (true) {
+ while (a[++i] < a[l] && i < h) ;
+ while (a[--j] > a[l] && j > l) ;
+ if (i >= j) {
+ break;
+ }
+ swap(a, i, j);
+ }
+ swap(a, l, j);
+ return j;
+}
+
+private void swap(int[] a, int i, int j) {
+ int t = a[i];
+ a[i] = a[j];
+ a[j] = t;
+}
+```
+
+### 桶排序
+
+**出现频率最多的 k 个数**
+
+[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].
+```
+
+设置若干个桶，每个桶存储出现频率相同的数，并且桶的下标代表桶中数出现的频率，即第 i 个桶中存储的数出现的频率为 i。
+
+把数都放到桶之后，从后向前遍历桶，最先得到的 k 个数就是出现频率最多的的 k 个数。
+
+```java
+public List topKFrequent(int[] nums, int k) {
+ Map frequencyForNum = new HashMap<>();
+ for (int num : nums) {
+ frequencyForNum.put(num, frequencyForNum.getOrDefault(num, 0) + 1);
+ }
+ List[] buckets = new ArrayList[nums.length + 1];
+ for (int key : frequencyForNum.keySet()) {
+ int frequency = frequencyForNum.get(key);
+ if (buckets[frequency] == null) {
+ buckets[frequency] = new ArrayList<>();
+ }
+ buckets[frequency].add(key);
+ }
+ List topK = new ArrayList<>();
+ for (int i = buckets.length - 1; i >= 0 && topK.size() < k; i--) {
+ if (buckets[i] != null) {
+ topK.addAll(buckets[i]);
+ }
+ }
+ return topK;
+}
+```
+
+**按照字符出现次数对字符串排序**
+
+[451. Sort Characters By Frequency (Medium)](https://leetcode.com/problems/sort-characters-by-frequency/description/)
+
+```html
+Input:
+"tree"
+
+Output:
+"eert"
+
+Explanation:
+'e' appears twice while 'r' and 't' both appear once.
+So 'e' must appear before both 'r' and 't'. Therefore "eetr" is also a valid answer.
+```
+
+```java
+public String frequencySort(String s) {
+ Map frequencyForNum = new HashMap<>();
+ for (char c : s.toCharArray())
+ frequencyForNum.put(c, frequencyForNum.getOrDefault(c, 0) + 1);
+
+ List[] frequencyBucket = new ArrayList[s.length() + 1];
+ for (char c : frequencyForNum.keySet()) {
+ int f = frequencyForNum.get(c);
+ if (frequencyBucket[f] == null) {
+ frequencyBucket[f] = new ArrayList<>();
+ }
+ frequencyBucket[f].add(c);
+ }
+ StringBuilder str = new StringBuilder();
+ for (int i = frequencyBucket.length - 1; i >= 0; i--) {
+ if (frequencyBucket[i] == null) {
+ continue;
+ }
+ for (char c : frequencyBucket[i]) {
+ for (int j = 0; j < i; j++) {
+ str.append(c);
+ }
+ }
+ }
+ return str.toString();
+}
+```
+
+### 荷兰国旗问题
+
+荷兰国旗包含三种颜色：红、白、蓝。
+
+有三种颜色的球，算法的目标是将这三种球按颜色顺序正确地排列。
+
+它其实是三向切分快速排序的一种变种，在三向切分快速排序中，每次切分都将数组分成三个区间：小于切分元素、等于切分元素、大于切分元素，而该算法是将数组分成三个区间：等于红色、等于白色、等于蓝色。
+
+
+
+**按颜色进行排序**
+
+[75. Sort Colors (Medium)](https://leetcode.com/problems/sort-colors/description/)
+
+```html
+Input: [2,0,2,1,1,0]
+Output: [0,0,1,1,2,2]
+```
+
+题目描述：只有 0/1/2 三种颜色。
+
+```java
+public void sortColors(int[] nums) {
+ int zero = -1, one = 0, two = nums.length;
+ while (one < two) {
+ if (nums[one] == 0) {
+ swap(nums, ++zero, one++);
+ } else if (nums[one] == 2) {
+ swap(nums, --two, one);
+ } else {
+ ++one;
+ }
+ }
+}
+
+private void swap(int[] nums, int i, int j) {
+ int t = nums[i];
+ nums[i] = nums[j];
+ nums[j] = t;
+}
+```
+
## 贪心思想
-贪心思想保证每次操作都是局部最优的，并且最后得到的结果是全局最优的。
+保证每次操作都是局部最优的，并且最后得到的结果是全局最优的。
**分配饼干**
@@ -74,7 +514,7 @@ You need to output 2.
题目描述：每个孩子都有一个满足度，每个饼干都有一个大小，只有饼干的大小大于等于一个孩子的满足度，该孩子才会获得满足。求解最多可以获得满足的孩子数量。
-因为最小的孩子最容易得到满足，因此先满足最小孩子。给一个孩子的饼干应当尽量小又能满足该孩子，这样大饼干就能拿来给满足度比较大的孩子。因此贪心策略
+给一个孩子的饼干应当尽量小又能满足该孩子，这样大饼干就能拿来给满足度比较大的孩子。因为最小的孩子最容易得到满足，所以先满足最小的孩子。
证明：假设在某次选择中，贪心策略选择给当前满足度最小的孩子分配第 m 个饼干，第 m 个饼干为可以满足该孩子的最小饼干。假设存在一种最优策略，给该孩子分配第 n 个饼干，并且 m < n。我们可以发现，经过这一轮分配，贪心策略分配后剩下的饼干一定有一个比最优策略来得大。因此在后续的分配中，贪心策略一定能满足更多的孩子。也就是说不存在比贪心策略更优的策略，即贪心策略就是最优策略。
@@ -362,434 +802,6 @@ public int maxProfit(int[] prices) {
}
```
-## 双指针
-
-双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。
-
-**有序数组的 Two Sum**
-
-[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
-```
-
-题目描述：在有序数组中找出两个数，使它们的和为 target。
-
-使用双指针，一个指针指向值较小的元素，一个指针指向值较大的元素。指向较小元素的指针从头向尾遍历，指向较大元素的指针从尾向头遍历。
-
-如果两个指针指向元素的和 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;
-}
-```
-
-**两数平方和**
-
-[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
-```
-
-题目描述：判断一个数是否为两个数的平方和，例如 5 = 12 + 22。
-
-```java
-public boolean judgeSquareSum(int c) {
- int i = 0, j = (int) Math.sqrt(c);
- while (i <= j) {
- int powSum = i * i + j * j;
- if (powSum == c) {
- return true;
- } else if (powSum > c) {
- j--;
- } else {
- i++;
- }
- }
- return false;
-}
-```
-
-**反转字符串中的元音字符**
-
-[345. Reverse Vowels of a String (Easy)](https://leetcode.com/problems/reverse-vowels-of-a-string/description/)
-
-```html
-Given s = "leetcode", return "leotcede".
-```
-
-使用双指针，指向待反转的两个元音字符，一个指针从头向尾遍历，一个指针从尾到头遍历。
-
-```java
-private final static HashSet vowels = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));
-
-public String reverseVowels(String 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;
- } else if (!vowels.contains(cj)) {
- result[j--] = cj;
- } else {
- result[i++] = cj;
- result[j--] = ci;
- }
- }
- return new String(result);
-}
-```
-
-**回文字符串**
-
-[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'.
-```
-
-题目描述：可以删除一个字符，判断是否能构成回文字符串。
-
-```java
-public boolean validPalindrome(String s) {
- int i = -1, j = s.length();
- while (++i < --j) {
- if (s.charAt(i) != s.charAt(j)) {
- return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);
- }
- }
- return true;
-}
-
-private boolean isPalindrome(String s, int i, int j) {
- while (i < j) {
- if (s.charAt(i++) != s.charAt(j--)) {
- return false;
- }
- }
- return true;
-}
-```
-
-**归并两个有序数组**
-
-[88. Merge Sorted Array (Easy)](https://leetcode.com/problems/merge-sorted-array/description/)
-
-```html
-Input:
-nums1 = [1,2,3,0,0,0], m = 3
-nums2 = [2,5,6], n = 3
-
-Output: [1,2,2,3,5,6]
-```
-
-题目描述：把归并结果存到第一个数组上。
-
-需要从尾开始遍历，否则在 nums1 上归并得到的值会覆盖还未进行归并比较的值
-
-```java
-public void merge(int[] nums1, int m, int[] nums2, int n) {
- int index1 = m - 1, index2 = n - 1;
- int indexMerge = m + n - 1;
- while (index1 >= 0 || index2 >= 0) {
- if (index1 < 0) {
- nums1[indexMerge--] = nums2[index2--];
- } else if (index2 < 0) {
- nums1[indexMerge--] = nums1[index1--];
- } else if (nums1[index1] > nums2[index2]) {
- nums1[indexMerge--] = nums1[index1--];
- } else {
- nums1[indexMerge--] = nums2[index2--];
- }
- }
-}
-```
-
-**判断链表是否存在环**
-
-[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 && l2.next != null) {
- if (l1 == l2) {
- return true;
- }
- l1 = l1.next;
- l2 = l2.next.next;
- }
- return false;
-}
-```
-
-**最长子序列**
-
-[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"]
-
-Output:
-"apple"
-```
-
-题目描述：删除 s 中的一些字符，使得它构成字符串列表 d 中的一个字符串，找出能构成的最长字符串。如果有多个相同长度的结果，返回按字典序排序的最大字符串。
-
-```java
-public String findLongestWord(String s, List d) {
- String longestWord = "";
- for (String target : d) {
- int l1 = longestWord.length(), l2 = target.length();
- if (l1 > l2 || (l1 == l2 && longestWord.compareTo(target) < 0)) {
- continue;
- }
- if (isValid(s, target)) {
- longestWord = target;
- }
- }
- return longestWord;
-}
-
-private boolean isValid(String s, String target) {
- int i = 0, j = 0;
- while (i < s.length() && j < target.length()) {
- if (s.charAt(i) == target.charAt(j)) {
- j++;
- }
- i++;
- }
- return j == target.length();
-}
-```
-
-## 排序
-
-### 快速选择
-
-一般用于求解 **Kth Element** 问题，可以在 O(N) 时间复杂度，O(1) 空间复杂度完成求解工作。
-
-与快速排序一样，快速选择一般需要先打乱数组，否则最坏情况下时间复杂度为 O(N2)。
-
-### 堆排序
-
-堆排序用于求解 **TopK Elements** 问题，通过维护一个大小为 K 的堆，堆中的元素就是 TopK Elements。当然它也可以用于求解 Kth Element 问题，堆顶元素就是 Kth Element。快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。
-
-**Kth Element**
-
-[215. Kth Largest Element in an Array (Medium)](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
-
-**排序** ：时间复杂度 O(NlogN)，空间复杂度 O(1)
-
-```java
-public int findKthLargest(int[] nums, int k) {
- Arrays.sort(nums);
- return nums[nums.length - k];
-}
-```
-
-**堆排序** ：时间复杂度 O(NlogK)，空间复杂度 O(K)。
-
-```java
-public int findKthLargest(int[] nums, int k) {
- PriorityQueue pq = new PriorityQueue<>(); // 小顶堆
- for (int val : nums) {
- pq.add(val);
- if (pq.size() > k) // 维护堆的大小为 K
- pq.poll();
- }
- return pq.peek();
-}
-```
-
-**快速选择** ：时间复杂度 O(N)，空间复杂度 O(1)
-
-```java
-public int findKthLargest(int[] nums, int k) {
- k = nums.length - k;
- int l = 0, h = nums.length - 1;
- while (l < h) {
- int j = partition(nums, l, h);
- if (j == k) {
- break;
- } else if (j < k) {
- l = j + 1;
- } else {
- h = j - 1;
- }
- }
- return nums[k];
-}
-
-private int partition(int[] a, int l, int h) {
- int i = l, j = h + 1;
- while (true) {
- while (a[++i] < a[l] && i < h) ;
- while (a[--j] > a[l] && j > l) ;
- if (i >= j) {
- break;
- }
- swap(a, i, j);
- }
- swap(a, l, j);
- return j;
-}
-
-private void swap(int[] a, int i, int j) {
- int t = a[i];
- a[i] = a[j];
- a[j] = t;
-}
-```
-
-### 桶排序
-
-**出现频率最多的 k 个数**
-
-[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].
-```
-
-设置若干个桶，每个桶存储出现频率相同的数，并且桶的下标代表桶中数出现的频率，即第 i 个桶中存储的数出现的频率为 i。把数都放到桶之后，从后向前遍历桶，最先得到的 k 个数就是出现频率最多的的 k 个数。
-
-```java
-public List topKFrequent(int[] nums, int k) {
- Map frequencyForNum = new HashMap<>();
- for (int num : nums) {
- frequencyForNum.put(num, frequencyForNum.getOrDefault(num, 0) + 1);
- }
- List[] buckets = new ArrayList[nums.length + 1];
- for (int key : frequencyForNum.keySet()) {
- int frequency = frequencyForNum.get(key);
- if (buckets[frequency] == null) {
- buckets[frequency] = new ArrayList<>();
- }
- buckets[frequency].add(key);
- }
- List topK = new ArrayList<>();
- for (int i = buckets.length - 1; i >= 0 && topK.size() < k; i--) {
- if (buckets[i] != null) {
- topK.addAll(buckets[i]);
- }
- }
- return topK;
-}
-```
-
-**按照字符出现次数对字符串排序**
-
-[451. Sort Characters By Frequency (Medium)](https://leetcode.com/problems/sort-characters-by-frequency/description/)
-
-```html
-Input:
-"tree"
-
-Output:
-"eert"
-
-Explanation:
-'e' appears twice while 'r' and 't' both appear once.
-So 'e' must appear before both 'r' and 't'. Therefore "eetr" is also a valid answer.
-```
-
-```java
-public String frequencySort(String s) {
- Map frequencyForNum = new HashMap<>();
- for (char c : s.toCharArray())
- frequencyForNum.put(c, frequencyForNum.getOrDefault(c, 0) + 1);
-
- List[] frequencyBucket = new ArrayList[s.length() + 1];
- for (char c : frequencyForNum.keySet()) {
- int f = frequencyForNum.get(c);
- if (frequencyBucket[f] == null) {
- frequencyBucket[f] = new ArrayList<>();
- }
- frequencyBucket[f].add(c);
- }
- StringBuilder str = new StringBuilder();
- for (int i = frequencyBucket.length - 1; i >= 0; i--) {
- if (frequencyBucket[i] == null) {
- continue;
- }
- for (char c : frequencyBucket[i]) {
- for (int j = 0; j < i; j++) {
- str.append(c);
- }
- }
- }
- return str.toString();
-}
-```
-
-### 荷兰国旗问题
-
-荷兰国旗包含三种颜色：红、白、蓝。有这三种颜色的球，算法的目标是将这三种球按颜色顺序正确地排列。
-
-它其实是三向切分快速排序的一种变种，在三向切分快速排序中，每次切分都将数组分成三个区间：小于切分元素、等于切分元素、大于切分元素，而该算法是将数组分成三个区间：等于红色、等于白色、等于蓝色。
-
- 
-
-**按颜色进行排序**
-
-[75. Sort Colors (Medium)](https://leetcode.com/problems/sort-colors/description/)
-
-```html
-Input: [2,0,2,1,1,0]
-Output: [0,0,1,1,2,2]
-```
-
-题目描述：只有 0/1/2 三种颜色。
-
-```java
-public void sortColors(int[] nums) {
- int zero = -1, one = 0, two = nums.length;
- while (one < two) {
- if (nums[one] == 0) {
- swap(nums, ++zero, one++);
- } else if (nums[one] == 2) {
- swap(nums, --two, one);
- } else {
- ++one;
- }
- }
-}
-
-private void swap(int[] nums, int i, int j) {
- int t = nums[i];
- nums[i] = nums[j];
- nums[j] = t;
-}
-```
-
## 二分查找
**正常实现**
@@ -1065,6 +1077,53 @@ private int binarySearch(int[] nums, int target) {
}
```
+## 分治
+
+**给表达式加括号**
+
+[241. Different Ways to Add Parentheses (Medium)](https://leetcode.com/problems/different-ways-to-add-parentheses/description/)
+
+```html
+Input: "2-1-1".
+
+((2-1)-1) = 0
+(2-(1-1)) = 2
+
+Output : [0, 2]
+```
+
+```java
+public List diffWaysToCompute(String input) {
+ List ways = new ArrayList<>();
+ for (int i = 0; i < input.length(); 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 '+':
+ ways.add(l + r);
+ break;
+ case '-':
+ ways.add(l - r);
+ break;
+ case '*':
+ ways.add(l * r);
+ break;
+ }
+ }
+ }
+ }
+ }
+ if (ways.size() == 0) {
+ ways.add(Integer.valueOf(input));
+ }
+ return ways;
+}
+```
+
## 搜索
深度优先搜索和广度优先搜索广泛运用于树和图中，但是它们的应用远远不止如此。
@@ -2312,53 +2371,6 @@ private void backtracking(int row) {
}
```
-## 分治
-
-**给表达式加括号**
-
-[241. Different Ways to Add Parentheses (Medium)](https://leetcode.com/problems/different-ways-to-add-parentheses/description/)
-
-```html
-Input: "2-1-1".
-
-((2-1)-1) = 0
-(2-(1-1)) = 2
-
-Output : [0, 2]
-```
-
-```java
-public List diffWaysToCompute(String input) {
- List ways = new ArrayList<>();
- for (int i = 0; i < input.length(); 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 '+':
- ways.add(l + r);
- break;
- case '-':
- ways.add(l - r);
- break;
- case '*':
- ways.add(l * r);
- break;
- }
- }
- }
- }
- }
- if (ways.size() == 0) {
- ways.add(Integer.valueOf(input));
- }
- return ways;
-}
-```
-
## 动态规划
递归和动态规划都是将原问题拆成多个子问题然后求解，他们之间最本质的区别是，动态规划保存了子问题的解，避免重复计算。
@@ -4036,973 +4048,6 @@ public int maximumProduct(int[] nums) {
# 数据结构相关
-## 栈和队列
-
-**用栈实现队列**
-
-[232. Implement Queue using Stacks (Easy)](https://leetcode.com/problems/implement-queue-using-stacks/description/)
-
-```java
-class MyQueue {
-
- private Stack in = new Stack<>();
- private Stack out = new Stack<>();
-
- public void push(int x) {
- in.push(x);
- }
-
- public int pop() {
- in2out();
- return out.pop();
- }
-
- public int peek() {
- in2out();
- return out.peek();
- }
-
- private void in2out() {
- if (out.isEmpty()) {
- while (!in.isEmpty()) {
- out.push(in.pop());
- }
- }
- }
-
- public boolean empty() {
- return in.isEmpty() && out.isEmpty();
- }
-}
-```
-
-**用队列实现栈**
-
-[225. Implement Stack using Queues (Easy)](https://leetcode.com/problems/implement-stack-using-queues/description/)
-
-在将一个元素 x 插入队列时，需要让除了 x 之外的所有元素出队列，再入队列。此时 x 在队首，第一个出队列，实现了后进先出顺序。
-
-```java
-class MyStack {
-
- private Queue queue;
-
- public MyStack() {
- queue = new LinkedList<>();
- }
-
- public void push(int x) {
- queue.add(x);
- int cnt = queue.size();
- while (cnt-- > 1) {
- queue.add(queue.poll());
- }
- }
-
- public int pop() {
- return queue.remove();
- }
-
- public int top() {
- return queue.peek();
- }
-
- public boolean empty() {
- return queue.isEmpty();
- }
-}
-```
-
-**最小值栈**
-
-[155. Min Stack (Easy)](https://leetcode.com/problems/min-stack/description/)
-
-```java
-class MinStack {
-
- private Stack dataStack;
- private Stack minStack;
- private int min;
-
- public MinStack() {
- dataStack = new Stack<>();
- minStack = new Stack<>();
- min = Integer.MAX_VALUE;
- }
-
- public void push(int x) {
- dataStack.add(x);
- min = Math.min(min, x);
- minStack.add(min);
- }
-
- public void pop() {
- dataStack.pop();
- minStack.pop();
- min = minStack.isEmpty() ? Integer.MAX_VALUE : minStack.peek();
- }
-
- public int top() {
- return dataStack.peek();
- }
-
- public int getMin() {
- return minStack.peek();
- }
-}
-```
-
-对于实现最小值队列问题，可以先将队列使用栈来实现，然后就将问题转换为最小值栈，这个问题出现在 编程之美：3.7。
-
-**用栈实现括号匹配**
-
-[20. Valid Parentheses (Easy)](https://leetcode.com/problems/valid-parentheses/description/)
-
-```html
-"()[]{}"
-
-Output : true
-```
-
-```java
-public boolean isValid(String s) {
- Stack stack = new Stack<>();
- for (char c : s.toCharArray()) {
- if (c == '(' || c == '{' || c == '[') {
- stack.push(c);
- } else {
- if (stack.isEmpty()) {
- return false;
- }
- char cStack = stack.pop();
- boolean b1 = c == ')' && cStack != '(';
- boolean b2 = c == ']' && cStack != '[';
- boolean b3 = c == '}' && cStack != '{';
- if (b1 || b2 || b3) {
- return false;
- }
- }
- }
- return stack.isEmpty();
-}
-```
-
-**数组中元素与下一个比它大的元素之间的距离**
-
-[739. Daily Temperatures (Medium)](https://leetcode.com/problems/daily-temperatures/description/)
-
-```html
-Input: [73, 74, 75, 71, 69, 72, 76, 73]
-Output: [1, 1, 4, 2, 1, 1, 0, 0]
-```
-
-在遍历数组时用 Stack 把数组中的数存起来，如果当前遍历的数比栈顶元素来的大，说明栈顶元素的下一个比它大的数就是当前元素。
-
-```java
-public int[] dailyTemperatures(int[] temperatures) {
- int n = temperatures.length;
- int[] dist = new int[n];
- Stack indexs = new Stack<>();
- for (int curIndex = 0; curIndex < n; curIndex++) {
- while (!indexs.isEmpty() && temperatures[curIndex] > temperatures[indexs.peek()]) {
- int preIndex = indexs.pop();
- dist[preIndex] = curIndex - preIndex;
- }
- indexs.add(curIndex);
- }
- return dist;
-}
-```
-
-**循环数组中比当前元素大的下一个元素**
-
-[503. Next Greater Element II (Medium)](https://leetcode.com/problems/next-greater-element-ii/description/)
-
-```text
-Input: [1,2,1]
-Output: [2,-1,2]
-Explanation: The first 1's next greater number is 2;
-The number 2 can't find next greater number;
-The second 1's next greater number needs to search circularly, which is also 2.
-```
-
-与 739. Daily Temperatures (Medium) 不同的是，数组是循环数组，并且最后要求的不是距离而是下一个元素。
-
-```java
-public int[] nextGreaterElements(int[] nums) {
- int n = nums.length;
- int[] next = new int[n];
- Arrays.fill(next, -1);
- Stack pre = new Stack<>();
- for (int i = 0; i < n * 2; i++) {
- int num = nums[i % n];
- while (!pre.isEmpty() && nums[pre.peek()] < num) {
- next[pre.pop()] = num;
- }
- if (i < n){
- pre.push(i);
- }
- }
- return next;
-}
-```
-
-## 哈希表
-
-哈希表使用 O(N) 空间复杂度存储数据，从而能够以 O(1) 时间复杂度求解问题。
-
-Java 中的 **HashSet** 用于存储一个集合，可以查找元素是否在集合中。
-
-如果元素有穷，并且范围不大，那么可以用一个布尔数组来存储一个元素是否存在。例如对于只有小写字符的元素，就可以用一个长度为 26 的布尔数组来存储一个字符集合，使得空间复杂度降低为 O(1)。
-
-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 也可以用来对元素进行计数统计，此时键为元素，值为计数。和 HashSet 类似，如果元素有穷并且范围不大，可以用整型数组来进行统计。
-
-**数组中的两个数和为给定值**
-
-[1. Two Sum (Easy)](https://leetcode.com/problems/two-sum/description/)
-
-可以先对数组进行排序，然后使用双指针方法或者二分查找方法。这样做的时间复杂度为 O(NlogN)，空间复杂度为 O(1)。
-
-用 HashMap 存储数组元素和索引的映射，在访问到 nums[i] 时，判断 HashMap 中是否存在 target - nums[i]，如果存在说明 target - nums[i] 所在的索引和 i 就是要找的两个数。该方法的时间复杂度为 O(N)，空间复杂度为 O(N)，使用空间来换取时间。
-
-```java
-public int[] twoSum(int[] nums, int target) {
- HashMap indexForNum = new HashMap<>();
- for (int i = 0; i < nums.length; i++) {
- if (indexForNum.containsKey(target - nums[i])) {
- return new int[]{indexForNum.get(target - nums[i]), i};
- } else {
- indexForNum.put(nums[i], i);
- }
- }
- return null;
-}
-```
-
-**判断数组是否含有重复元素**
-
-[217. Contains Duplicate (Easy)](https://leetcode.com/problems/contains-duplicate/description/)
-
-```java
-public boolean containsDuplicate(int[] nums) {
- Set set = new HashSet<>();
- for (int num : nums) {
- set.add(num);
- }
- return set.size() < nums.length;
-}
-```
-
-**最长和谐序列**
-
-[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].
-```
-
-和谐序列中最大数和最小数只差正好为 1，应该注意的是序列的元素不一定是数组的连续元素。
-
-```java
-public int findLHS(int[] nums) {
- Map countForNum = new HashMap<>();
- for (int num : nums) {
- countForNum.put(num, countForNum.getOrDefault(num, 0) + 1);
- }
- int longest = 0;
- for (int num : countForNum.keySet()) {
- if (countForNum.containsKey(num + 1)) {
- longest = Math.max(longest, countForNum.get(num + 1) + countForNum.get(num));
- }
- }
- return longest;
-}
-```
-
-**最长连续序列**
-
-[128. Longest Consecutive Sequence (Hard)](https://leetcode.com/problems/longest-consecutive-sequence/description/)
-
-```html
-Given [100, 4, 200, 1, 3, 2],
-The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.
-```
-
-要求以 O(N) 的时间复杂度求解。
-
-```java
-public int longestConsecutive(int[] nums) {
- Map countForNum = new HashMap<>();
- for (int num : nums) {
- countForNum.put(num, 1);
- }
- for (int num : nums) {
- forward(countForNum, num);
- }
- return maxCount(countForNum);
-}
-
-private int forward(Map countForNum, int num) {
- if (!countForNum.containsKey(num)) {
- return 0;
- }
- int cnt = countForNum.get(num);
- if (cnt > 1) {
- return cnt;
- }
- cnt = forward(countForNum, num + 1) + 1;
- countForNum.put(num, cnt);
- return cnt;
-}
-
-private int maxCount(Map countForNum) {
- int max = 0;
- for (int num : countForNum.keySet()) {
- max = Math.max(max, countForNum.get(num));
- }
- return max;
-}
-```
-
-## 字符串
-
-**两个字符串包含的字符是否完全相同**
-
-[242. Valid Anagram (Easy)](https://leetcode.com/problems/valid-anagram/description/)
-
-```html
-s = "anagram", t = "nagaram", return true.
-s = "rat", t = "car", return false.
-```
-
-字符串只包含小写字符，总共有 26 个小写字符。可以用 HashMap 来映射字符与出现次数。因为键的范围很小，因此可以使用长度为 26 的整型数组对字符串出现的字符进行统计，然后比较两个字符串出现的字符数量是否相同。
-
-```java
-public boolean isAnagram(String s, String t) {
- int[] cnts = new int[26];
- for (char c : s.toCharArray()) {
- cnts[c - 'a']++;
- }
- for (char c : t.toCharArray()) {
- cnts[c - 'a']--;
- }
- for (int cnt : cnts) {
- if (cnt != 0) {
- return false;
- }
- }
- return true;
-}
-```
-
-**计算一组字符集合可以组成的回文字符串的最大长度**
-
-[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.
-```
-
-使用长度为 256 的整型数组来统计每个字符出现的个数，每个字符有偶数个可以用来构成回文字符串。
-
-因为回文字符串最中间的那个字符可以单独出现，所以如果有单独的字符就把它放到最中间。
-
-```java
-public int longestPalindrome(String s) {
- int[] cnts = new int[256];
- for (char c : s.toCharArray()) {
- cnts[c]++;
- }
- int palindrome = 0;
- for (int cnt : cnts) {
- palindrome += (cnt / 2) * 2;
- }
- if (palindrome < s.length()) {
- palindrome++; // 这个条件下 s 中一定有单个未使用的字符存在，可以把这个字符放到回文的最中间
- }
- return palindrome;
-}
-```
-
-**字符串同构**
-
-[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.
-```
-
-记录一个字符上次出现的位置，如果两个字符串中的字符上次出现的位置一样，那么就属于同构。
-
-```java
-public boolean isIsomorphic(String s, String t) {
- int[] preIndexOfS = new int[256];
- int[] preIndexOfT = new int[256];
- for (int i = 0; i < s.length(); i++) {
- char sc = s.charAt(i), tc = t.charAt(i);
- if (preIndexOfS[sc] != preIndexOfT[tc]) {
- return false;
- }
- preIndexOfS[sc] = i + 1;
- preIndexOfT[tc] = i + 1;
- }
- return true;
-}
-```
-
-**回文子字符串**
-
-[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".
-```
-
-从字符串的某一位开始，尝试着去扩展子字符串。
-
-```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 void extendSubstrings(String s, int start, int end) {
- while (start >= 0 && end < s.length() && s.charAt(start) == s.charAt(end)) {
- start--;
- end++;
- cnt++;
- }
-}
-```
-
-**判断一个整数是否是回文数**
-
-[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 || x % 10 == 0) {
- return false;
- }
- int right = 0;
- while (x > right) {
- right = right * 10 + x % 10;
- x /= 10;
- }
- return x == right || x == right / 10;
-}
-```
-
-**统计二进制字符串中连续 1 和连续 0 数量相同的子字符串个数**
-
-[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".
-```
-
-```java
-public int countBinarySubstrings(String s) {
- int preLen = 0, curLen = 1, count = 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) {
- count++;
- }
- }
- return count;
-}
-```
-
-**字符串循环移位包含**
-
-[编程之美：3.1](#)
-
-```html
-s1 = AABCD, s2 = CDAA
-Return : true
-```
-
-给定两个字符串 s1 和 s2，要求判定 s2 是否能够被 s1 做循环移位得到的字符串包含。
-
-s1 进行循环移位的结果是 s1s1 的子字符串，因此只要判断 s2 是否是 s1s1 的子字符串即可。
-
-**字符串循环移位**
-
-[编程之美：2.17](#)
-
-```html
-s = "abcd123" k = 3
-Return "123abcd"
-```
-
-将字符串向右循环移动 k 位。
-
-将 abcd123 中的 abcd 和 123 单独逆序，得到 dcba321，然后对整个字符串进行逆序，得到 123abcd。
-
-**字符串中单词的翻转**
-
-[程序员代码面试指南](#)
-
-```html
-s = "I am a student"
-return "student a am I"
-```
-
-将每个单词逆序，然后将整个字符串逆序。
-
-## 数组与矩阵
-
-**把数组中的 0 移到末尾**
-
-[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].
-```
-
-```java
-public void moveZeroes(int[] nums) {
- int idx = 0;
- for (int num : nums) {
- if (num != 0) {
- nums[idx++] = num;
- }
- }
- while (idx < nums.length) {
- nums[idx++] = 0;
- }
-}
-```
-
-**改变矩阵维度**
-
-[566. Reshape the Matrix (Easy)](https://leetcode.com/problems/reshape-the-matrix/description/)
-
-```html
-Input:
-nums =
-[[1,2],
- [3,4]]
-r = 1, c = 4
-
-Output:
-[[1,2,3,4]]
-
-Explanation:
-The row-traversing of nums is [1,2,3,4]. The new reshaped matrix is a 1 * 4 matrix, fill it row by row by using the previous list.
-```
-
-```java
-public int[][] matrixReshape(int[][] nums, int r, int c) {
- int m = nums.length, n = nums[0].length;
- if (m * n != r * c) {
- return nums;
- }
- int[][] reshapedNums = new int[r][c];
- int index = 0;
- for (int i = 0; i < r; i++) {
- for (int j = 0; j < c; j++) {
- reshapedNums[i][j] = nums[index / n][index % n];
- index++;
- }
- }
- return reshapedNums;
-}
-```
-
-**找出数组中最长的连续 1**
-
-[485. Max Consecutive Ones (Easy)](https://leetcode.com/problems/max-consecutive-ones/description/)
-
-```java
-public int findMaxConsecutiveOnes(int[] nums) {
- int max = 0, cur = 0;
- for (int x : nums) {
- cur = x == 0 ? 0 : cur + 1;
- max = Math.max(max, cur);
- }
- return max;
-}
-```
-
-**一个数组元素在 [1, n] 之间，其中一个数被替换为另一个数，找出重复的数和丢失的数**
-
-[645. Set Mismatch (Easy)](https://leetcode.com/problems/set-mismatch/description/)
-
-```html
-Input: nums = [1,2,2,4]
-Output: [2,3]
-```
-
-```html
-Input: nums = [1,2,2,4]
-Output: [2,3]
-```
-
-最直接的方法是先对数组进行排序，这种方法时间复杂度为 O(NlogN)。本题可以以 O(N) 的时间复杂度、O(1) 空间复杂度来求解。
-
-主要思想是通过交换数组元素，使得数组上的元素在正确的位置上。遍历数组，如果第 i 位上的元素不是 i + 1，那么一直交换第 i 位和 nums[i] - 1 位置上的元素。
-
-```java
-public int[] findErrorNums(int[] nums) {
- for (int i = 0; i < nums.length; i++) {
- while (nums[i] != i + 1 && nums[nums[i] - 1] != nums[i]) {
- swap(nums, i, nums[i] - 1);
- }
- }
- for (int i = 0; i < nums.length; i++) {
- if (nums[i] != i + 1) {
- return new int[]{nums[i], i + 1};
- }
- }
- return null;
-}
-
-private void swap(int[] nums, int i, int j) {
- int tmp = nums[i];
- nums[i] = nums[j];
- nums[j] = tmp;
-}
-```
-
-类似题目：
-
-- [448. Find All Numbers Disappeared in an Array (Easy)](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/description/)，寻找所有丢失的元素
-- [442. Find All Duplicates in an Array (Medium)](https://leetcode.com/problems/find-all-duplicates-in-an-array/description/)，寻找所有重复的元素。
-
-**找出数组中重复的数，数组值在 [1, n] 之间**
-
-[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;
-}
-```
-
-双指针解法，类似于有环链表中找出环的入口：
-
-```java
-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;
-}
-```
-
-**有序矩阵查找**
-
-[240. Search a 2D Matrix II (Medium)](https://leetcode.com/problems/search-a-2d-matrix-ii/description/)
-
-```html
-[
- [ 1, 5, 9],
- [10, 11, 13],
- [12, 13, 15]
-]
-```
-
-```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;
-}
-```
-
-**有序矩阵的 Kth Element**
-
-[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]
-],
-k = 8,
-
-return 13.
-```
-
-解题参考：[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;
-}
-```
-
-堆解法：
-
-```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;
-}
-
-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;
- }
-}
-```
-
-**数组相邻差值的个数**
-
-[667. Beautiful Arrangement II (Medium)](https://leetcode.com/problems/beautiful-arrangement-ii/description/)
-
-```html
-Input: n = 3, k = 2
-Output: [1, 3, 2]
-Explanation: The [1, 3, 2] has three different positive integers ranging from 1 to 3, and the [2, 1] has exactly 2 distinct integers: 1 and 2.
-```
-
-题目描述：数组元素为 1\~n 的整数，要求构建数组，使得相邻元素的差值不相同的个数为 k。
-
-让前 k+1 个元素构建出 k 个不相同的差值，序列为：1 k+1 2 k 3 k-1 ... k/2 k/2+1.
-
-```java
-public int[] constructArray(int n, int k) {
- int[] ret = new int[n];
- ret[0] = 1;
- for (int i = 1, interval = k; i <= k; i++, interval--) {
- ret[i] = i % 2 == 1 ? ret[i - 1] + interval : ret[i - 1] - interval;
- }
- for (int i = k + 1; i < n; i++) {
- ret[i] = i + 1;
- }
- return ret;
-}
-```
-
-**数组的度**
-
-[697. Degree of an Array (Easy)](https://leetcode.com/problems/degree-of-an-array/description/)
-
-```html
-Input: [1,2,2,3,1,4,2]
-Output: 6
-```
-
-题目描述：数组的度定义为元素出现的最高频率，例如上面的数组度为 3。要求找到一个最小的子数组，这个子数组的度和原数组一样。
-
-```java
-public int findShortestSubArray(int[] nums) {
- Map numsCnt = new HashMap<>();
- Map numsLastIndex = new HashMap<>();
- Map numsFirstIndex = new HashMap<>();
- for (int i = 0; i < nums.length; i++) {
- int num = nums[i];
- numsCnt.put(num, numsCnt.getOrDefault(num, 0) + 1);
- numsLastIndex.put(num, i);
- if (!numsFirstIndex.containsKey(num)) {
- numsFirstIndex.put(num, i);
- }
- }
- int maxCnt = 0;
- for (int num : nums) {
- maxCnt = Math.max(maxCnt, numsCnt.get(num));
- }
- int ret = nums.length;
- for (int i = 0; i < nums.length; i++) {
- int num = nums[i];
- int cnt = numsCnt.get(num);
- if (cnt != maxCnt) continue;
- ret = Math.min(ret, numsLastIndex.get(num) - numsFirstIndex.get(num) + 1);
- }
- return ret;
-}
-```
-
-**对角元素相等的矩阵**
-
-[766. Toeplitz Matrix (Easy)](https://leetcode.com/problems/toeplitz-matrix/description/)
-
-```html
-1234
-5123
-9512
-
-In the above grid, the diagonals are "[9]", "[5, 5]", "[1, 1, 1]", "[2, 2, 2]", "[3, 3]", "[4]", and in each diagonal all elements are the same, so the answer is True.
-```
-
-```java
-public boolean isToeplitzMatrix(int[][] matrix) {
- for (int i = 0; i < matrix[0].length; i++) {
- if (!check(matrix, matrix[0][i], 0, i)) {
- return false;
- }
- }
- for (int i = 0; i < matrix.length; i++) {
- if (!check(matrix, matrix[i][0], i, 0)) {
- return false;
- }
- }
- return true;
-}
-
-private boolean check(int[][] matrix, int expectValue, int row, int col) {
- if (row >= matrix.length || col >= matrix[0].length) {
- return true;
- }
- if (matrix[row][col] != expectValue) {
- return false;
- }
- return check(matrix, expectValue, row + 1, col + 1);
-}
-```
-
-**嵌套数组**
-
-[565. Array Nesting (Medium)](https://leetcode.com/problems/array-nesting/description/)
-
-```html
-Input: A = [5,4,0,3,1,6,2]
-Output: 4
-Explanation:
-A[0] = 5, A[1] = 4, A[2] = 0, A[3] = 3, A[4] = 1, A[5] = 6, A[6] = 2.
-
-One of the longest S[K]:
-S[0] = {A[0], A[5], A[6], A[2]} = {5, 6, 2, 0}
-```
-
-题目描述：S[i] 表示一个集合，集合的第一个元素是 A[i]，第二个元素是 A[A[i]]，如此嵌套下去。求最大的 S[i]。
-
-```java
-public int arrayNesting(int[] nums) {
- int max = 0;
- for (int i = 0; i < nums.length; i++) {
- int cnt = 0;
- for (int j = i; nums[j] != -1; ) {
- cnt++;
- int t = nums[j];
- nums[j] = -1; // 标记该位置已经被访问
- j = t;
-
- }
- max = Math.max(max, cnt);
- }
- return max;
-}
-```
-
-**分隔数组**
-
-[769. Max Chunks To Make Sorted (Medium)](https://leetcode.com/problems/max-chunks-to-make-sorted/description/)
-
-```html
-Input: arr = [1,0,2,3,4]
-Output: 4
-Explanation:
-We can split into two chunks, such as [1, 0], [2, 3, 4].
-However, splitting into [1, 0], [2], [3], [4] is the highest number of chunks possible.
-```
-
-题目描述：分隔数组，使得对每部分排序后数组就为有序。
-
-```java
-public int maxChunksToSorted(int[] arr) {
- if (arr == null) return 0;
- int ret = 0;
- int right = arr[0];
- for (int i = 0; i < arr.length; i++) {
- right = Math.max(right, arr[i]);
- if (right == i) ret++;
- }
- return ret;
-}
-```
-
## 链表
链表是空节点，或者有一个值和一个指向下一个链表的指针，因此很多链表问题可以用递归来处理。
@@ -5036,7 +4081,10 @@ public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
}
```
-如果只是判断是否存在交点，那么就是另一个问题，即 [编程之美：3.6]() 的问题。有两种解法：把第一个链表的结尾连接到第二个链表的开头，看第二个链表是否存在环；或者直接比较两个链表的最后一个节点是否相同。
+如果只是判断是否存在交点，那么就是另一个问题，即 [编程之美 3.6]() 的问题。有两种解法：
+
+- 把第一个链表的结尾连接到第二个链表的开头，看第二个链表是否存在环；
+- 或者直接比较两个链表的最后一个节点是否相同。
**链表反转**
@@ -5101,7 +4149,7 @@ Given 1->1->2->3->3, return 1->2->3.
```java
public ListNode deleteDuplicates(ListNode head) {
- if(head == null || head.next == null) return head;
+ if (head == null || head.next == null) return head;
head.next = deleteDuplicates(head.next);
return head.val == head.next.val ? head.next : head;
}
@@ -5423,8 +4471,8 @@ Input:
3 2 1 3
/ \ \
5 4 7
+
Output:
-Merged tree:
3
/ \
4 5
@@ -5450,6 +4498,7 @@ public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
```html
Given the below binary tree and sum = 22,
+
5
/ \
4 8
@@ -5457,10 +4506,11 @@ Given the below binary tree and sum = 22,
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) {
@@ -5852,7 +4902,7 @@ public List preorderTraversal(TreeNode root) {
[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) {
@@ -6110,7 +5160,7 @@ public TreeNode sortedListToBST(ListNode head) {
if (head == null) return null;
if (head.next == null) return new TreeNode(head.val);
ListNode preMid = preMid(head);
- ListNode mid = preMid.next;
+ ListNode mid = preMid.next;
preMid.next = null; // 断开链表
TreeNode t = new TreeNode(mid.val);
t.left = sortedListToBST(head);
@@ -6226,7 +5276,7 @@ private void inOrder(TreeNode node) {
return [2].
```
-答案可能不止一个，也就是有多个值出现的次数一样多，并且是最大的。
+答案可能不止一个，也就是有多个值出现的次数一样多。
```java
private int curCnt = 1;
@@ -6396,6 +5446,974 @@ class MapSum {
}
```
+
+## 栈和队列
+
+**用栈实现队列**
+
+[232. Implement Queue using Stacks (Easy)](https://leetcode.com/problems/implement-queue-using-stacks/description/)
+
+栈的顺序为后进先出，而队列的顺序为先进先出。使用两个栈实现队列，一个元素需要经过两个栈才能出队列，在经过第一个栈时元素顺序被反转，经过第二个栈时再次被反转，此时就是先进先出顺序。
+
+```java
+class MyQueue {
+
+ private Stack in = new Stack<>();
+ private Stack out = new Stack<>();
+
+ public void push(int x) {
+ in.push(x);
+ }
+
+ public int pop() {
+ in2out();
+ return out.pop();
+ }
+
+ public int peek() {
+ in2out();
+ return out.peek();
+ }
+
+ private void in2out() {
+ if (out.isEmpty()) {
+ while (!in.isEmpty()) {
+ out.push(in.pop());
+ }
+ }
+ }
+
+ public boolean empty() {
+ return in.isEmpty() && out.isEmpty();
+ }
+}
+```
+
+**用队列实现栈**
+
+[225. Implement Stack using Queues (Easy)](https://leetcode.com/problems/implement-stack-using-queues/description/)
+
+在将一个元素 x 插入队列时，为了维护原来的后进先出顺序，需要让 x 插入队列首部。而队列的默认插入顺序是队列尾部，因此在将 x 插入队列尾部之后，需要让除了 x 之外的所有元素出队列，再入队列。
+
+```java
+class MyStack {
+
+ private Queue queue;
+
+ public MyStack() {
+ queue = new LinkedList<>();
+ }
+
+ public void push(int x) {
+ queue.add(x);
+ int cnt = queue.size();
+ while (cnt-- > 1) {
+ queue.add(queue.poll());
+ }
+ }
+
+ public int pop() {
+ return queue.remove();
+ }
+
+ public int top() {
+ return queue.peek();
+ }
+
+ public boolean empty() {
+ return queue.isEmpty();
+ }
+}
+```
+
+**最小值栈**
+
+[155. Min Stack (Easy)](https://leetcode.com/problems/min-stack/description/)
+
+```java
+class MinStack {
+
+ private Stack dataStack;
+ private Stack minStack;
+ private int min;
+
+ public MinStack() {
+ dataStack = new Stack<>();
+ minStack = new Stack<>();
+ min = Integer.MAX_VALUE;
+ }
+
+ public void push(int x) {
+ dataStack.add(x);
+ min = Math.min(min, x);
+ minStack.add(min);
+ }
+
+ public void pop() {
+ dataStack.pop();
+ minStack.pop();
+ min = minStack.isEmpty() ? Integer.MAX_VALUE : minStack.peek();
+ }
+
+ public int top() {
+ return dataStack.peek();
+ }
+
+ public int getMin() {
+ return minStack.peek();
+ }
+}
+```
+
+对于实现最小值队列问题，可以先将队列使用栈来实现，然后就将问题转换为最小值栈，这个问题出现在 编程之美：3.7。
+
+**用栈实现括号匹配**
+
+[20. Valid Parentheses (Easy)](https://leetcode.com/problems/valid-parentheses/description/)
+
+```html
+"()[]{}"
+
+Output : true
+```
+
+```java
+public boolean isValid(String s) {
+ Stack stack = new Stack<>();
+ for (char c : s.toCharArray()) {
+ if (c == '(' || c == '{' || c == '[') {
+ stack.push(c);
+ } else {
+ if (stack.isEmpty()) {
+ return false;
+ }
+ char cStack = stack.pop();
+ boolean b1 = c == ')' && cStack != '(';
+ boolean b2 = c == ']' && cStack != '[';
+ boolean b3 = c == '}' && cStack != '{';
+ if (b1 || b2 || b3) {
+ return false;
+ }
+ }
+ }
+ return stack.isEmpty();
+}
+```
+
+**数组中元素与下一个比它大的元素之间的距离**
+
+[739. Daily Temperatures (Medium)](https://leetcode.com/problems/daily-temperatures/description/)
+
+```html
+Input: [73, 74, 75, 71, 69, 72, 76, 73]
+Output: [1, 1, 4, 2, 1, 1, 0, 0]
+```
+
+在遍历数组时用栈把数组中的数存起来，如果当前遍历的数比栈顶元素来的大，说明栈顶元素的下一个比它大的数就是当前元素。
+
+```java
+public int[] dailyTemperatures(int[] temperatures) {
+ int n = temperatures.length;
+ int[] dist = new int[n];
+ Stack indexs = new Stack<>();
+ for (int curIndex = 0; curIndex < n; curIndex++) {
+ while (!indexs.isEmpty() && temperatures[curIndex] > temperatures[indexs.peek()]) {
+ int preIndex = indexs.pop();
+ dist[preIndex] = curIndex - preIndex;
+ }
+ indexs.add(curIndex);
+ }
+ return dist;
+}
+```
+
+**循环数组中比当前元素大的下一个元素**
+
+[503. Next Greater Element II (Medium)](https://leetcode.com/problems/next-greater-element-ii/description/)
+
+```text
+Input: [1,2,1]
+Output: [2,-1,2]
+Explanation: The first 1's next greater number is 2;
+The number 2 can't find next greater number;
+The second 1's next greater number needs to search circularly, which is also 2.
+```
+
+与 739. Daily Temperatures (Medium) 不同的是，数组是循环数组，并且最后要求的不是距离而是下一个元素。
+
+```java
+public int[] nextGreaterElements(int[] nums) {
+ int n = nums.length;
+ int[] next = new int[n];
+ Arrays.fill(next, -1);
+ Stack pre = new Stack<>();
+ for (int i = 0; i < n * 2; i++) {
+ int num = nums[i % n];
+ while (!pre.isEmpty() && nums[pre.peek()] < num) {
+ next[pre.pop()] = num;
+ }
+ if (i < n){
+ pre.push(i);
+ }
+ }
+ return next;
+}
+```
+
+## 哈希表
+
+哈希表使用 O(N) 空间复杂度存储数据，并且以 O(1) 时间复杂度求解问题。
+
+- Java 中的 **HashSet** 用于存储一个集合，可以查找元素是否在集合中。如果元素有穷，并且范围不大，那么可以用一个布尔数组来存储一个元素是否存在。例如对于只有小写字符的元素，就可以用一个长度为 26 的布尔数组来存储一个字符集合，使得空间复杂度降低为 O(1)。
+
+- Java 中的 **HashMap** 主要用于映射关系，从而把两个元素联系起来。HashMap 也可以用来对元素进行计数统计，此时键为元素，值为计数。和 HashSet 类似，如果元素有穷并且范围不大，可以用整型数组来进行统计。在对一个内容进行压缩或者其它转换时，利用 HashMap 可以把原始内容和转换后的内容联系起来。例如在一个简化 url 的系统中 [Leetcdoe : 535. Encode and Decode TinyURL (Medium)](https://leetcode.com/problems/encode-and-decode-tinyurl/description/)，利用 HashMap 就可以存储精简后的 url 到原始 url 的映射，使得不仅可以显示简化的 url，也可以根据简化的 url 得到原始 url 从而定位到正确的资源。
+
+
+**数组中两个数的和为给定值**
+
+[1. Two Sum (Easy)](https://leetcode.com/problems/two-sum/description/)
+
+可以先对数组进行排序，然后使用双指针方法或者二分查找方法。这样做的时间复杂度为 O(NlogN)，空间复杂度为 O(1)。
+
+用 HashMap 存储数组元素和索引的映射，在访问到 nums[i] 时，判断 HashMap 中是否存在 target - nums[i]，如果存在说明 target - nums[i] 所在的索引和 i 就是要找的两个数。该方法的时间复杂度为 O(N)，空间复杂度为 O(N)，使用空间来换取时间。
+
+```java
+public int[] twoSum(int[] nums, int target) {
+ HashMap indexForNum = new HashMap<>();
+ for (int i = 0; i < nums.length; i++) {
+ if (indexForNum.containsKey(target - nums[i])) {
+ return new int[]{indexForNum.get(target - nums[i]), i};
+ } else {
+ indexForNum.put(nums[i], i);
+ }
+ }
+ return null;
+}
+```
+
+**判断数组是否含有重复元素**
+
+[217. Contains Duplicate (Easy)](https://leetcode.com/problems/contains-duplicate/description/)
+
+```java
+public boolean containsDuplicate(int[] nums) {
+ Set set = new HashSet<>();
+ for (int num : nums) {
+ set.add(num);
+ }
+ return set.size() < nums.length;
+}
+```
+
+**最长和谐序列**
+
+[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].
+```
+
+和谐序列中最大数和最小数只差正好为 1，应该注意的是序列的元素不一定是数组的连续元素。
+
+```java
+public int findLHS(int[] nums) {
+ Map countForNum = new HashMap<>();
+ for (int num : nums) {
+ countForNum.put(num, countForNum.getOrDefault(num, 0) + 1);
+ }
+ int longest = 0;
+ for (int num : countForNum.keySet()) {
+ if (countForNum.containsKey(num + 1)) {
+ longest = Math.max(longest, countForNum.get(num + 1) + countForNum.get(num));
+ }
+ }
+ return longest;
+}
+```
+
+**最长连续序列**
+
+[128. Longest Consecutive Sequence (Hard)](https://leetcode.com/problems/longest-consecutive-sequence/description/)
+
+```html
+Given [100, 4, 200, 1, 3, 2],
+The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.
+```
+
+要求以 O(N) 的时间复杂度求解。
+
+```java
+public int longestConsecutive(int[] nums) {
+ Map countForNum = new HashMap<>();
+ for (int num : nums) {
+ countForNum.put(num, 1);
+ }
+ for (int num : nums) {
+ forward(countForNum, num);
+ }
+ return maxCount(countForNum);
+}
+
+private int forward(Map countForNum, int num) {
+ if (!countForNum.containsKey(num)) {
+ return 0;
+ }
+ int cnt = countForNum.get(num);
+ if (cnt > 1) {
+ return cnt;
+ }
+ cnt = forward(countForNum, num + 1) + 1;
+ countForNum.put(num, cnt);
+ return cnt;
+}
+
+private int maxCount(Map countForNum) {
+ int max = 0;
+ for (int num : countForNum.keySet()) {
+ max = Math.max(max, countForNum.get(num));
+ }
+ return max;
+}
+```
+
+## 字符串
+
+**字符串循环移位包含**
+
+[编程之美 3.1](#)
+
+```html
+s1 = AABCD, s2 = CDAA
+Return : true
+```
+
+给定两个字符串 s1 和 s2，要求判定 s2 是否能够被 s1 做循环移位得到的字符串包含。
+
+s1 进行循环移位的结果是 s1s1 的子字符串，因此只要判断 s2 是否是 s1s1 的子字符串即可。
+
+**字符串循环移位**
+
+[编程之美 2.17](#)
+
+```html
+s = "abcd123" k = 3
+Return "123abcd"
+```
+
+将字符串向右循环移动 k 位。
+
+将 abcd123 中的 abcd 和 123 单独翻转，得到 dcba321，然后对整个字符串进行翻转，得到 123abcd。
+
+**字符串中单词的翻转**
+
+[程序员代码面试指南](#)
+
+```html
+s = "I am a student"
+Return "student a am I"
+```
+
+将每个单词翻转，然后将整个字符串翻转。
+
+**两个字符串包含的字符是否完全相同**
+
+[242. Valid Anagram (Easy)](https://leetcode.com/problems/valid-anagram/description/)
+
+```html
+s = "anagram", t = "nagaram", return true.
+s = "rat", t = "car", return false.
+```
+
+可以用 HashMap 来映射字符与出现次数，然后比较两个字符串出现的字符数量是否相同。
+
+由于本题的字符串只包含 26 个小写字符，因此可以使用长度为 26 的整型数组对字符串出现的字符进行统计，不再使用 HashMap。
+
+```java
+public boolean isAnagram(String s, String t) {
+ int[] cnts = new int[26];
+ for (char c : s.toCharArray()) {
+ cnts[c - 'a']++;
+ }
+ for (char c : t.toCharArray()) {
+ cnts[c - 'a']--;
+ }
+ for (int cnt : cnts) {
+ if (cnt != 0) {
+ return false;
+ }
+ }
+ return true;
+}
+```
+
+**计算一组字符集合可以组成的回文字符串的最大长度**
+
+[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.
+```
+
+使用长度为 256 的整型数组来统计每个字符出现的个数，每个字符有偶数个可以用来构成回文字符串。
+
+因为回文字符串最中间的那个字符可以单独出现，所以如果有单独的字符就把它放到最中间。
+
+```java
+public int longestPalindrome(String s) {
+ int[] cnts = new int[256];
+ for (char c : s.toCharArray()) {
+ cnts[c]++;
+ }
+ int palindrome = 0;
+ for (int cnt : cnts) {
+ palindrome += (cnt / 2) * 2;
+ }
+ if (palindrome < s.length()) {
+ palindrome++; // 这个条件下 s 中一定有单个未使用的字符存在，可以把这个字符放到回文的最中间
+ }
+ return palindrome;
+}
+```
+
+**字符串同构**
+
+[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.
+```
+
+记录一个字符上次出现的位置，如果两个字符串中的字符上次出现的位置一样，那么就属于同构。
+
+```java
+public boolean isIsomorphic(String s, String t) {
+ int[] preIndexOfS = new int[256];
+ int[] preIndexOfT = new int[256];
+ for (int i = 0; i < s.length(); i++) {
+ char sc = s.charAt(i), tc = t.charAt(i);
+ if (preIndexOfS[sc] != preIndexOfT[tc]) {
+ return false;
+ }
+ preIndexOfS[sc] = i + 1;
+ preIndexOfT[tc] = i + 1;
+ }
+ return true;
+}
+```
+
+**回文子字符串个数**
+
+[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".
+```
+
+从字符串的某一位开始，尝试着去扩展子字符串。
+
+```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 void extendSubstrings(String s, int start, int end) {
+ while (start >= 0 && end < s.length() && s.charAt(start) == s.charAt(end)) {
+ start--;
+ end++;
+ cnt++;
+ }
+}
+```
+
+**判断一个整数是否是回文数**
+
+[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 || x % 10 == 0) {
+ return false;
+ }
+ int right = 0;
+ while (x > right) {
+ right = right * 10 + x % 10;
+ x /= 10;
+ }
+ return x == right || x == right / 10;
+}
+```
+
+**统计二进制字符串中连续 1 和连续 0 数量相同的子字符串个数**
+
+[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".
+```
+
+```java
+public int countBinarySubstrings(String s) {
+ int preLen = 0, curLen = 1, count = 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) {
+ count++;
+ }
+ }
+ return count;
+}
+```
+
+## 数组与矩阵
+
+**把数组中的 0 移到末尾**
+
+[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].
+```
+
+```java
+public void moveZeroes(int[] nums) {
+ int idx = 0;
+ for (int num : nums) {
+ if (num != 0) {
+ nums[idx++] = num;
+ }
+ }
+ while (idx < nums.length) {
+ nums[idx++] = 0;
+ }
+}
+```
+
+**改变矩阵维度**
+
+[566. Reshape the Matrix (Easy)](https://leetcode.com/problems/reshape-the-matrix/description/)
+
+```html
+Input:
+nums =
+[[1,2],
+ [3,4]]
+r = 1, c = 4
+
+Output:
+[[1,2,3,4]]
+
+Explanation:
+The row-traversing of nums is [1,2,3,4]. The new reshaped matrix is a 1 * 4 matrix, fill it row by row by using the previous list.
+```
+
+```java
+public int[][] matrixReshape(int[][] nums, int r, int c) {
+ int m = nums.length, n = nums[0].length;
+ if (m * n != r * c) {
+ return nums;
+ }
+ int[][] reshapedNums = new int[r][c];
+ int index = 0;
+ for (int i = 0; i < r; i++) {
+ for (int j = 0; j < c; j++) {
+ reshapedNums[i][j] = nums[index / n][index % n];
+ index++;
+ }
+ }
+ return reshapedNums;
+}
+```
+
+**找出数组中最长的连续 1**
+
+[485. Max Consecutive Ones (Easy)](https://leetcode.com/problems/max-consecutive-ones/description/)
+
+```java
+public int findMaxConsecutiveOnes(int[] nums) {
+ int max = 0, cur = 0;
+ for (int x : nums) {
+ cur = x == 0 ? 0 : cur + 1;
+ max = Math.max(max, cur);
+ }
+ return max;
+}
+```
+
+**有序矩阵查找**
+
+[240. Search a 2D Matrix II (Medium)](https://leetcode.com/problems/search-a-2d-matrix-ii/description/)
+
+```html
+[
+ [ 1, 5, 9],
+ [10, 11, 13],
+ [12, 13, 15]
+]
+```
+
+```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;
+}
+```
+
+**有序矩阵的 Kth Element**
+
+[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]
+],
+k = 8,
+
+return 13.
+```
+
+解题参考：[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;
+}
+```
+
+堆解法：
+
+```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;
+}
+
+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;
+ }
+}
+```
+
+**一个数组元素在 [1, n] 之间，其中一个数被替换为另一个数，找出重复的数和丢失的数**
+
+[645. Set Mismatch (Easy)](https://leetcode.com/problems/set-mismatch/description/)
+
+```html
+Input: nums = [1,2,2,4]
+Output: [2,3]
+```
+
+```html
+Input: nums = [1,2,2,4]
+Output: [2,3]
+```
+
+最直接的方法是先对数组进行排序，这种方法时间复杂度为 O(NlogN)。本题可以以 O(N) 的时间复杂度、O(1) 空间复杂度来求解。
+
+主要思想是通过交换数组元素，使得数组上的元素在正确的位置上。
+
+```java
+public int[] findErrorNums(int[] nums) {
+ for (int i = 0; i < nums.length; i++) {
+ while (nums[i] != i + 1 && nums[nums[i] - 1] != nums[i]) {
+ swap(nums, i, nums[i] - 1);
+ }
+ }
+ for (int i = 0; i < nums.length; i++) {
+ if (nums[i] != i + 1) {
+ return new int[]{nums[i], i + 1};
+ }
+ }
+ return null;
+}
+
+private void swap(int[] nums, int i, int j) {
+ int tmp = nums[i];
+ nums[i] = nums[j];
+ nums[j] = tmp;
+}
+```
+
+类似题目：
+
+- [448. Find All Numbers Disappeared in an Array (Easy)](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/description/)，寻找所有丢失的元素
+- [442. Find All Duplicates in an Array (Medium)](https://leetcode.com/problems/find-all-duplicates-in-an-array/description/)，寻找所有重复的元素。
+
+**找出数组中重复的数，数组值在 [1, n] 之间**
+
+[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;
+}
+```
+
+双指针解法，类似于有环链表中找出环的入口：
+
+```java
+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;
+}
+```
+
+**数组相邻差值的个数**
+
+[667. Beautiful Arrangement II (Medium)](https://leetcode.com/problems/beautiful-arrangement-ii/description/)
+
+```html
+Input: n = 3, k = 2
+Output: [1, 3, 2]
+Explanation: The [1, 3, 2] has three different positive integers ranging from 1 to 3, and the [2, 1] has exactly 2 distinct integers: 1 and 2.
+```
+
+题目描述：数组元素为 1\~n 的整数，要求构建数组，使得相邻元素的差值不相同的个数为 k。
+
+让前 k+1 个元素构建出 k 个不相同的差值，序列为：1 k+1 2 k 3 k-1 ... k/2 k/2+1.
+
+```java
+public int[] constructArray(int n, int k) {
+ int[] ret = new int[n];
+ ret[0] = 1;
+ for (int i = 1, interval = k; i <= k; i++, interval--) {
+ ret[i] = i % 2 == 1 ? ret[i - 1] + interval : ret[i - 1] - interval;
+ }
+ for (int i = k + 1; i < n; i++) {
+ ret[i] = i + 1;
+ }
+ return ret;
+}
+```
+
+**数组的度**
+
+[697. Degree of an Array (Easy)](https://leetcode.com/problems/degree-of-an-array/description/)
+
+```html
+Input: [1,2,2,3,1,4,2]
+Output: 6
+```
+
+题目描述：数组的度定义为元素出现的最高频率，例如上面的数组度为 3。要求找到一个最小的子数组，这个子数组的度和原数组一样。
+
+```java
+public int findShortestSubArray(int[] nums) {
+ Map numsCnt = new HashMap<>();
+ Map numsLastIndex = new HashMap<>();
+ Map numsFirstIndex = new HashMap<>();
+ for (int i = 0; i < nums.length; i++) {
+ int num = nums[i];
+ numsCnt.put(num, numsCnt.getOrDefault(num, 0) + 1);
+ numsLastIndex.put(num, i);
+ if (!numsFirstIndex.containsKey(num)) {
+ numsFirstIndex.put(num, i);
+ }
+ }
+ int maxCnt = 0;
+ for (int num : nums) {
+ maxCnt = Math.max(maxCnt, numsCnt.get(num));
+ }
+ int ret = nums.length;
+ for (int i = 0; i < nums.length; i++) {
+ int num = nums[i];
+ int cnt = numsCnt.get(num);
+ if (cnt != maxCnt) continue;
+ ret = Math.min(ret, numsLastIndex.get(num) - numsFirstIndex.get(num) + 1);
+ }
+ return ret;
+}
+```
+
+**对角元素相等的矩阵**
+
+[766. Toeplitz Matrix (Easy)](https://leetcode.com/problems/toeplitz-matrix/description/)
+
+```html
+1234
+5123
+9512
+
+In the above grid, the diagonals are "[9]", "[5, 5]", "[1, 1, 1]", "[2, 2, 2]", "[3, 3]", "[4]", and in each diagonal all elements are the same, so the answer is True.
+```
+
+```java
+public boolean isToeplitzMatrix(int[][] matrix) {
+ for (int i = 0; i < matrix[0].length; i++) {
+ if (!check(matrix, matrix[0][i], 0, i)) {
+ return false;
+ }
+ }
+ for (int i = 0; i < matrix.length; i++) {
+ if (!check(matrix, matrix[i][0], i, 0)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+private boolean check(int[][] matrix, int expectValue, int row, int col) {
+ if (row >= matrix.length || col >= matrix[0].length) {
+ return true;
+ }
+ if (matrix[row][col] != expectValue) {
+ return false;
+ }
+ return check(matrix, expectValue, row + 1, col + 1);
+}
+```
+
+**嵌套数组**
+
+[565. Array Nesting (Medium)](https://leetcode.com/problems/array-nesting/description/)
+
+```html
+Input: A = [5,4,0,3,1,6,2]
+Output: 4
+Explanation:
+A[0] = 5, A[1] = 4, A[2] = 0, A[3] = 3, A[4] = 1, A[5] = 6, A[6] = 2.
+
+One of the longest S[K]:
+S[0] = {A[0], A[5], A[6], A[2]} = {5, 6, 2, 0}
+```
+
+题目描述：S[i] 表示一个集合，集合的第一个元素是 A[i]，第二个元素是 A[A[i]]，如此嵌套下去。求最大的 S[i]。
+
+```java
+public int arrayNesting(int[] nums) {
+ int max = 0;
+ for (int i = 0; i < nums.length; i++) {
+ int cnt = 0;
+ for (int j = i; nums[j] != -1; ) {
+ cnt++;
+ int t = nums[j];
+ nums[j] = -1; // 标记该位置已经被访问
+ j = t;
+
+ }
+ max = Math.max(max, cnt);
+ }
+ return max;
+}
+```
+
+**分隔数组**
+
+[769. Max Chunks To Make Sorted (Medium)](https://leetcode.com/problems/max-chunks-to-make-sorted/description/)
+
+```html
+Input: arr = [1,0,2,3,4]
+Output: 4
+Explanation:
+We can split into two chunks, such as [1, 0], [2, 3, 4].
+However, splitting into [1, 0], [2], [3], [4] is the highest number of chunks possible.
+```
+
+题目描述：分隔数组，使得对每部分排序后数组就为有序。
+
+```java
+public int maxChunksToSorted(int[] arr) {
+ if (arr == null) return 0;
+ int ret = 0;
+ int right = arr[0];
+ for (int i = 0; i < arr.length; i++) {
+ right = Math.max(right, arr[i]);
+ if (right == i) ret++;
+ }
+ return ret;
+}
+```
+
+
## 图
### 二分图
@@ -7056,3 +7074,4 @@ public int[] countBits(int num) {
- 何海涛, 软件工程师. 剑指 Offer: 名企面试官精讲典型编程题[M]. 电子工业出版社, 2014.
- 《编程之美》小组. 编程之美[M]. 电子工业出版社, 2008.
- 左程云. 程序员代码面试指南[M]. 电子工业出版社, 2015.
+
diff --git a/notes/Leetcode-Database 题解.md b/notes/Leetcode-Database 题解.md
index 5ab726c5..5b4a3d00 100644
--- a/notes/Leetcode-Database 题解.md
+++ b/notes/Leetcode-Database 题解.md
@@ -461,7 +461,7 @@ Employee 表：
+----+-------+--------+-----------+
```
-查找所有员工，他们的薪资大于其经理薪资。
+查找薪资大于其经理薪资的员工信息。
## SQL Schema
@@ -924,27 +924,27 @@ VALUES
```sql
SELECT
s1.id - 1 AS id,
- s1.student
+ s1.student
FROM
- seat s1
+ seat s1
WHERE
s1.id MOD 2 = 0 UNION
SELECT
s2.id + 1 AS id,
- s2.student
+ s2.student
FROM
- seat s2
+ seat s2
WHERE
- s2.id MOD 2 = 1
+ s2.id MOD 2 = 1
AND s2.id != ( SELECT max( s3.id ) FROM seat s3 ) UNION
SELECT
s4.id AS id,
- s4.student
+ s4.student
FROM
- seat s4
+ seat s4
WHERE
- s4.id MOD 2 = 1
- AND s4.id = ( SELECT max( s5.id ) FROM seat s5 )
+ s4.id MOD 2 = 1
+ AND s4.id = ( SELECT max( s5.id ) FROM seat s5 )
ORDER BY
id;
```
diff --git a/notes/剑指 offer 题解.md b/notes/剑指 offer 题解.md
index 47d5d94e..0c9bd1f9 100644
--- a/notes/剑指 offer 题解.md
+++ b/notes/剑指 offer 题解.md
@@ -633,11 +633,12 @@ public int RectCover(int n) {
## 解题思路
-当 nums[m] <= nums[h] 的情况下，说明解在 [l, m] 之间，此时令 h = m；否则解在 [m + 1, h] 之间，令 l = m + 1。
+- 当 nums[m] <= nums[h] 的情况下，说明解在 [l, m] 之间，此时令 h = m；
+- 否则解在 [m + 1, h] 之间，令 l = m + 1。
-因为 h 的赋值表达式为 h = m，因此循环体的循环条件应该为 l < h，详细解释请见 [Leetcode 题解](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/Leetcode%20%E9%A2%98%E8%A7%A3.md#%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE) 二分查找部分。
+因为 h 的赋值表达式为 h = m，因此循环体的循环条件应该为 l < h，详细解释请见 [Leetcode 题解](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/Leetcode%20%E9%A2%98%E8%A7%A3.md) 二分查找部分。
-但是如果出现 nums[l] == nums[m] == nums[h]，那么此时无法确定解在哪个区间，因此需要切换到顺序查找。
+但是如果出现 nums[l] == nums[m] == nums[h]，那么此时无法确定解在哪个区间，需要切换到顺序查找。
复杂度：O(logN) + O(1)
@@ -1217,8 +1218,7 @@ public ListNode ReverseList(ListNode head) {
### 递归
```java
-public ListNode Merge(ListNode list1, ListNode list2)
-{
+public ListNode Merge(ListNode list1, ListNode list2) {
if (list1 == null)
return list2;
if (list2 == null)
@@ -1236,8 +1236,7 @@ public ListNode Merge(ListNode list1, ListNode list2)
### 迭代
```java
-public ListNode Merge(ListNode list1, ListNode list2)
-{
+public ListNode Merge(ListNode list1, ListNode list2) {
ListNode head = new ListNode(-1);
ListNode cur = head;
while (list1 != null && list2 != null) {
@@ -1269,15 +1268,13 @@ public ListNode Merge(ListNode list1, ListNode list2)
## 解题思路
```java
-public boolean HasSubtree(TreeNode root1, TreeNode root2)
-{
+public boolean HasSubtree(TreeNode root1, TreeNode root2) {
if (root1 == null || root2 == null)
return false;
return isSubtreeWithRoot(root1, root2) || HasSubtree(root1.left, root2) || HasSubtree(root1.right, root2);
}
-private boolean isSubtreeWithRoot(TreeNode root1, TreeNode root2)
-{
+private boolean isSubtreeWithRoot(TreeNode root1, TreeNode root2) {
if (root2 == null)
return true;
if (root1 == null)
@@ -1298,9 +1295,10 @@ private boolean isSubtreeWithRoot(TreeNode root1, TreeNode root2)
## 解题思路
+### 递归
+
```java
-public void Mirror(TreeNode root)
-{
+public void Mirror(TreeNode root) {
if (root == null)
return;
swap(root);
@@ -1308,14 +1306,36 @@ public void Mirror(TreeNode root)
Mirror(root.right);
}
-private void swap(TreeNode root)
-{
+private void swap(TreeNode root) {
TreeNode t = root.left;
root.left = root.right;
root.right = t;
}
```
+### 迭代
+
+```java
+public void Mirror(TreeNode root) {
+ Stack stack = new Stack<>();
+ stack.push(root);
+ while (!stack.isEmpty()) {
+ TreeNode node = stack.pop();
+ if (node == null)
+ continue;
+ swap(node);
+ stack.push(node.left);
+ stack.push(node.right);
+ }
+}
+
+private void swap(TreeNode node) {
+ TreeNode t = node.left;
+ node.left = node.right;
+ node.right = t;
+}
+```
+
# 28 对称的二叉树
[NowCder](https://www.nowcoder.com/practice/ff05d44dfdb04e1d83bdbdab320efbcb?tpId=13&tqId=11211&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
@@ -1327,15 +1347,13 @@ private void swap(TreeNode root)
## 解题思路
```java
-boolean isSymmetrical(TreeNode pRoot)
-{
+boolean isSymmetrical(TreeNode pRoot) {
if (pRoot == null)
return true;
return isSymmetrical(pRoot.left, pRoot.right);
}
-boolean isSymmetrical(TreeNode t1, TreeNode t2)
-{
+boolean isSymmetrical(TreeNode t1, TreeNode t2) {
if (t1 == null && t2 == null)
return true;
if (t1 == null || t2 == null)
@@ -1359,8 +1377,7 @@ boolean isSymmetrical(TreeNode t1, TreeNode t2)
## 解题思路
```java
-public ArrayList printMatrix(int[][] matrix)
-{
+public ArrayList printMatrix(int[][] matrix) {
ArrayList ret = new ArrayList<>();
int r1 = 0, r2 = matrix.length - 1, c1 = 0, c2 = matrix[0].length - 1;
while (r1 <= r2 && c1 <= c2) {
@@ -1394,25 +1411,21 @@ public ArrayList printMatrix(int[][] matrix)
private Stack dataStack = new Stack<>();
private Stack minStack = new Stack<>();
-public void push(int node)
-{
+public void push(int node) {
dataStack.push(node);
minStack.push(minStack.isEmpty() ? node : Math.min(minStack.peek(), node));
}
-public void pop()
-{
+public void pop() {
dataStack.pop();
minStack.pop();
}
-public int top()
-{
+public int top() {
return dataStack.peek();
}
-public int min()
-{
+public int min() {
return minStack.peek();
}
```
@@ -1430,8 +1443,7 @@ public int min()
使用一个栈来模拟压入弹出操作。
```java
-public boolean IsPopOrder(int[] pushSequence, int[] popSequence)
-{
+public boolean IsPopOrder(int[] pushSequence, int[] popSequence) {
int n = pushSequence.length;
Stack stack = new Stack<>();
for (int pushIndex = 0, popIndex = 0; pushIndex < n; pushIndex++) {
@@ -1464,8 +1476,7 @@ public boolean IsPopOrder(int[] pushSequence, int[] popSequence)
不需要使用两个队列分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。
```java
-public ArrayList PrintFromTopToBottom(TreeNode root)
-{
+public ArrayList PrintFromTopToBottom(TreeNode root) {
Queue queue = new LinkedList<>();
ArrayList ret = new ArrayList<>();
queue.add(root);
@@ -1495,8 +1506,7 @@ public ArrayList PrintFromTopToBottom(TreeNode root)
## 解题思路
```java
-ArrayList> Print(TreeNode pRoot)
-{
+ArrayList> Print(TreeNode pRoot) {
ArrayList> ret = new ArrayList<>();
Queue queue = new LinkedList<>();
queue.add(pRoot);
@@ -1529,8 +1539,7 @@ ArrayList> Print(TreeNode pRoot)
## 解题思路
```java
-public ArrayList> Print(TreeNode pRoot)
-{
+public ArrayList> Print(TreeNode pRoot) {
ArrayList> ret = new ArrayList<>();
Queue queue = new LinkedList<>();
queue.add(pRoot);
@@ -1571,15 +1580,13 @@ public ArrayList> Print(TreeNode pRoot)
## 解题思路
```java
-public boolean VerifySquenceOfBST(int[] sequence)
-{
+public boolean VerifySquenceOfBST(int[] sequence) {
if (sequence == null || sequence.length == 0)
return false;
return verify(sequence, 0, sequence.length - 1);
}
-private boolean verify(int[] sequence, int first, int last)
-{
+private boolean verify(int[] sequence, int first, int last) {
if (last - first <= 1)
return true;
int rootVal = sequence[last];
@@ -1610,14 +1617,12 @@ private boolean verify(int[] sequence, int first, int last)
```java
private ArrayList> ret = new ArrayList<>();
-public ArrayList> FindPath(TreeNode root, int target)
-{
+public ArrayList> FindPath(TreeNode root, int target) {
backtracking(root, target, new ArrayList<>());
return ret;
}
-private void backtracking(TreeNode node, int target, ArrayList path)
-{
+private void backtracking(TreeNode node, int target, ArrayList path) {
if (node == null)
return;
path.add(node.val);
@@ -1641,8 +1646,7 @@ private void backtracking(TreeNode node, int target, ArrayList path)
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的 head。
```java
-public class RandomListNode
-{
+public class RandomListNode {
int label;
RandomListNode next = null;
RandomListNode random = null;
@@ -1670,8 +1674,7 @@ public class RandomListNode
```java
-public RandomListNode Clone(RandomListNode pHead)
-{
+public RandomListNode Clone(RandomListNode pHead) {
if (pHead == null)
return null;
// 插入新节点
@@ -1718,14 +1721,12 @@ public RandomListNode Clone(RandomListNode pHead)
private TreeNode pre = null;
private TreeNode head = null;
-public TreeNode Convert(TreeNode root)
-{
+public TreeNode Convert(TreeNode root) {
inOrder(root);
return head;
}
-private void inOrder(TreeNode node)
-{
+private void inOrder(TreeNode node) {
if (node == null)
return;
inOrder(node.left);
@@ -1752,21 +1753,18 @@ private void inOrder(TreeNode node)
```java
private String deserializeStr;
-public String Serialize(TreeNode root)
-{
+public String Serialize(TreeNode root) {
if (root == null)
return "#";
return root.val + " " + Serialize(root.left) + " " + Serialize(root.right);
}
-public TreeNode Deserialize(String str)
-{
+public TreeNode Deserialize(String str) {
deserializeStr = str;
return Deserialize();
}
-private TreeNode Deserialize()
-{
+private TreeNode Deserialize() {
if (deserializeStr.length() == 0)
return null;
int index = deserializeStr.indexOf(" ");
@@ -1795,8 +1793,7 @@ private TreeNode Deserialize()
```java
private ArrayList ret = new ArrayList<>();
-public ArrayList Permutation(String str)
-{
+public ArrayList Permutation(String str) {
if (str.length() == 0)
return ret;
char[] chars = str.toCharArray();
@@ -1805,8 +1802,7 @@ public ArrayList Permutation(String str)
return ret;
}
-private void backtracking(char[] chars, boolean[] hasUsed, StringBuilder s)
-{
+private void backtracking(char[] chars, boolean[] hasUsed, StringBuilder s) {
if (s.length() == chars.length) {
ret.add(s.toString());
return;
@@ -1836,8 +1832,7 @@ private void backtracking(char[] chars, boolean[] hasUsed, StringBuilder s)
使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素不相等时，令 cnt--。如果前面查找了 i 个元素，且 cnt == 0，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2 ，因为如果多于 i / 2 的话 cnt 就一定不会为 0 。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
```java
-public int MoreThanHalfNum_Solution(int[] nums)
-{
+public int MoreThanHalfNum_Solution(int[] nums) {
int majority = nums[0];
for (int i = 1, cnt = 1; i < nums.length; i++) {
cnt = nums[i] == majority ? cnt + 1 : cnt - 1;
@@ -1868,8 +1863,7 @@ public int MoreThanHalfNum_Solution(int[] nums)
快速排序的 partition() 方法，会返回一个整数 j 使得 a[l..j-1] 小于等于 a[j]，且 a[j+1..h] 大于等于 a[j]，此时 a[j] 就是数组的第 j 大元素。可以利用这个特性找出数组的第 K 个元素，这种找第 K 个元素的算法称为快速选择算法。
```java
-public ArrayList GetLeastNumbers_Solution(int[] nums, int k)
-{
+public ArrayList GetLeastNumbers_Solution(int[] nums, int k) {
ArrayList ret = new ArrayList<>();
if (k > nums.length || k <= 0)
return ret;
@@ -1880,8 +1874,7 @@ public ArrayList GetLeastNumbers_Solution(int[] nums, int k)
return ret;
}
-public void findKthSmallest(int[] nums, int k)
-{
+public void findKthSmallest(int[] nums, int k) {
int l = 0, h = nums.length - 1;
while (l < h) {
int j = partition(nums, l, h);
@@ -1894,8 +1887,7 @@ public void findKthSmallest(int[] nums, int k)
}
}
-private int partition(int[] nums, int l, int h)
-{
+private int partition(int[] nums, int l, int h) {
int p = nums[l]; /* 切分元素 */
int i = l, j = h + 1;
while (true) {
@@ -1909,8 +1901,7 @@ private int partition(int[] nums, int l, int h)
return j;
}
-private void swap(int[] nums, int i, int j)
-{
+private void swap(int[] nums, int i, int j) {
int t = nums[i];
nums[i] = nums[j];
nums[j] = t;
@@ -1927,8 +1918,7 @@ private void swap(int[] nums, int i, int j)
维护一个大小为 K 的最小堆过程如下：在添加一个元素之后，如果大顶堆的大小大于 K，那么需要将大顶堆的堆顶元素去除。
```java
-public ArrayList GetLeastNumbers_Solution(int[] nums, int k)
-{
+public ArrayList GetLeastNumbers_Solution(int[] nums, int k) {
if (k > nums.length || k <= 0)
return new ArrayList<>();
PriorityQueue maxHeap = new PriorityQueue<>((o1, o2) -> o2 - o1);
@@ -1959,8 +1949,7 @@ private PriorityQueue right = new PriorityQueue<>();
/* 当前数据流读入的元素个数 */
private int N = 0;
-public void Insert(Integer val)
-{
+public void Insert(Integer val) {
/* 插入要保证两个堆存于平衡状态 */
if (N % 2 == 0) {
/* N 为偶数的情况下插入到右半边。
@@ -1975,8 +1964,7 @@ public void Insert(Integer val)
N++;
}
-public Double GetMedian()
-{
+public Double GetMedian() {
if (N % 2 == 0)
return (left.peek() + right.peek()) / 2.0;
else
@@ -1998,16 +1986,14 @@ public Double GetMedian()
private int[] cnts = new int[256];
private Queue queue = new LinkedList<>();
-public void Insert(char ch)
-{
+public void Insert(char ch) {
cnts[ch]++;
queue.add(ch);
while (!queue.isEmpty() && cnts[queue.peek()] > 1)
queue.poll();
}
-public char FirstAppearingOnce()
-{
+public char FirstAppearingOnce() {
return queue.isEmpty() ? '#' : queue.peek();
}
```
@@ -2023,8 +2009,7 @@ public char FirstAppearingOnce()
## 解题思路
```java
-public int FindGreatestSumOfSubArray(int[] nums)
-{
+public int FindGreatestSumOfSubArray(int[] nums) {
if (nums == null || nums.length == 0)
return 0;
int greatestSum = Integer.MIN_VALUE;
@@ -2044,8 +2029,7 @@ public int FindGreatestSumOfSubArray(int[] nums)
## 解题思路
```java
-public int NumberOf1Between1AndN_Solution(int n)
-{
+public int NumberOf1Between1AndN_Solution(int n) {
int cnt = 0;
for (int m = 1; m <= n; m *= 10) {
int a = n / m, b = n % m;
@@ -2066,8 +2050,7 @@ public int NumberOf1Between1AndN_Solution(int n)
## 解题思路
```java
-public int getDigitAtIndex(int index)
-{
+public int getDigitAtIndex(int index) {
if (index < 0)
return -1;
int place = 1; // 1 表示个位，2 表示 十位...
@@ -2085,8 +2068,7 @@ public int getDigitAtIndex(int index)
* place 位数的数字组成的字符串长度
* 10, 90, 900, ...
*/
-private int getAmountOfPlace(int place)
-{
+private int getAmountOfPlace(int place) {
if (place == 1)
return 10;
return (int) Math.pow(10, place - 1) * 9;
@@ -2096,8 +2078,7 @@ private int getAmountOfPlace(int place)
* place 位数的起始数字
* 0, 10, 100, ...
*/
-private int getBeginNumberOfPlace(int place)
-{
+private int getBeginNumberOfPlace(int place) {
if (place == 1)
return 0;
return (int) Math.pow(10, place - 1);
@@ -2106,8 +2087,7 @@ private int getBeginNumberOfPlace(int place)
/**
* 在 place 位数组成的字符串中，第 index 个数
*/
-private int getDigitAtIndex(int index, int place)
-{
+private int getDigitAtIndex(int index, int place) {
int beginNumber = getBeginNumberOfPlace(place);
int shiftNumber = index / place;
String number = (beginNumber + shiftNumber) + "";
@@ -2129,8 +2109,7 @@ private int getDigitAtIndex(int index, int place)
可以看成是一个排序问题，在比较两个字符串 S1 和 S2 的大小时，应该比较的是 S1+S2 和 S2+S1 的大小，如果 S1+S2 < S2+S1，那么应该把 S1 排在前面，否则应该把 S2 排在前面。
```java
-public String PrintMinNumber(int[] numbers)
-{
+public String PrintMinNumber(int[] numbers) {
if (numbers == null || numbers.length == 0)
return "";
int n = numbers.length;
@@ -2156,8 +2135,7 @@ public String PrintMinNumber(int[] numbers)
## 解题思路
```java
-public int numDecodings(String s)
-{
+public int numDecodings(String s) {
if (s == null || s.length() == 0)
return 0;
int n = s.length();
@@ -2200,8 +2178,7 @@ public int numDecodings(String s)
应该用动态规划求解，而不是深度优先搜索，深度优先搜索过于复杂，不是最优解。
```java
-public int getMost(int[][] values)
-{
+public int getMost(int[][] values) {
if (values == null || values.length == 0 || values[0].length == 0)
return 0;
int n = values[0].length;
@@ -2224,8 +2201,7 @@ public int getMost(int[][] values)
## 解题思路
```java
-public int longestSubStringWithoutDuplication(String str)
-{
+public int longestSubStringWithoutDuplication(String str) {
int curLen = 0;
int maxLen = 0;
int[] preIndexs = new int[26];
@@ -2257,8 +2233,7 @@ public int longestSubStringWithoutDuplication(String str)
## 解题思路
```java
-public int GetUglyNumber_Solution(int N)
-{
+public int GetUglyNumber_Solution(int N) {
if (N <= 6)
return N;
int i2 = 0, i3 = 0, i5 = 0;
@@ -2291,8 +2266,7 @@ public int GetUglyNumber_Solution(int N)
最直观的解法是使用 HashMap 对出现次数进行统计，但是考虑到要统计的字符范围有限，因此可以使用整型数组代替 HashMap。
```java
-public int FirstNotRepeatingChar(String str)
-{
+public int FirstNotRepeatingChar(String str) {
int[] cnts = new int[256];
for (int i = 0; i < str.length(); i++)
cnts[str.charAt(i)]++;
@@ -2306,8 +2280,7 @@ public int FirstNotRepeatingChar(String str)
以上实现的空间复杂度还不是最优的。考虑到只需要找到只出现一次的字符，那么我们只需要统计的次数信息只有 0,1,更大，使用两个比特位就能存储这些信息。
```java
-public int FirstNotRepeatingChar2(String str)
-{
+public int FirstNotRepeatingChar2(String str) {
BitSet bs1 = new BitSet(256);
BitSet bs2 = new BitSet(256);
for (char c : str.toCharArray()) {
@@ -2339,15 +2312,13 @@ public int FirstNotRepeatingChar2(String str)
private long cnt = 0;
private int[] tmp; // 在这里创建辅助数组，而不是在 merge() 递归函数中创建
-public int InversePairs(int[] nums)
-{
+public int InversePairs(int[] nums) {
tmp = new int[nums.length];
mergeSort(nums, 0, nums.length - 1);
return (int) (cnt % 1000000007);
}
-private void mergeSort(int[] nums, int l, int h)
-{
+private void mergeSort(int[] nums, int l, int h) {
if (h - l < 1)
return;
int m = l + (h - l) / 2;
@@ -2356,8 +2327,7 @@ private void mergeSort(int[] nums, int l, int h)
merge(nums, l, m, h);
}
-private void merge(int[] nums, int l, int m, int h)
-{
+private void merge(int[] nums, int l, int m, int h) {
int i = l, j = m + 1, k = l;
while (i <= m || j <= h) {
if (i > m)
@@ -2392,8 +2362,7 @@ private void merge(int[] nums, int l, int m, int h)
当访问 A 链表的指针访问到链表尾部时，令它从链表 B 的头部重新开始访问链表 B；同样地，当访问 B 链表的指针访问到链表尾部时，令它从链表 A 的头部重新开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。
```java
-public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2)
-{
+public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
ListNode l1 = pHead1, l2 = pHead2;
while (l1 != l2) {
l1 = (l1 == null) ? pHead2 : l1.next;
@@ -2420,15 +2389,13 @@ Output:
## 解题思路
```java
-public int GetNumberOfK(int[] nums, int K)
-{
+public int GetNumberOfK(int[] nums, int K) {
int first = binarySearch(nums, K);
int last = binarySearch(nums, K + 1);
return (first == nums.length || nums[first] != K) ? 0 : last - first;
}
-private int binarySearch(int[] nums, int K)
-{
+private int binarySearch(int[] nums, int K) {
int l = 0, h = nums.length;
while (l < h) {
int m = l + (h - l) / 2;
@@ -2453,14 +2420,12 @@ private int binarySearch(int[] nums, int K)
private TreeNode ret;
private int cnt = 0;
-public TreeNode KthNode(TreeNode pRoot, int k)
-{
+public TreeNode KthNode(TreeNode pRoot, int k) {
inOrder(pRoot, k);
return ret;
}
-private void inOrder(TreeNode root, int k)
-{
+private void inOrder(TreeNode root, int k) {
if (root == null || cnt >= k)
return;
inOrder(root.left, k);
@@ -2484,8 +2449,7 @@ private void inOrder(TreeNode root, int k)
## 解题思路
```java
-public int TreeDepth(TreeNode root)
-{
+public int TreeDepth(TreeNode root) {
return root == null ? 0 : 1 + Math.max(TreeDepth(root.left), TreeDepth(root.right));
}
```
@@ -2505,14 +2469,12 @@ public int TreeDepth(TreeNode root)
```java
private boolean isBalanced = true;
-public boolean IsBalanced_Solution(TreeNode root)
-{
+public boolean IsBalanced_Solution(TreeNode root) {
height(root);
return isBalanced;
}
-private int height(TreeNode root)
-{
+private int height(TreeNode root) {
if (root == null || !isBalanced)
return 0;
int left = height(root.left);
@@ -2538,8 +2500,7 @@ private int height(TreeNode root)
diff &= -diff 得到出 diff 最右侧不为 0 的位，也就是不存在重复的两个元素在位级表示上最右侧不同的那一位，利用这一位就可以将两个元素区分开来。
```java
-public void FindNumsAppearOnce(int[] nums, int num1[], int num2[])
-{
+public void FindNumsAppearOnce(int[] nums, int num1[], int num2[]) {
int diff = 0;
for (int num : nums)
diff ^= num;
@@ -2570,8 +2531,7 @@ public void FindNumsAppearOnce(int[] nums, int num1[], int num2[])
- 如果 sum < target，移动较小的元素，使 sum 变大一些。
```java
-public ArrayList FindNumbersWithSum(int[] array, int sum)
-{
+public ArrayList FindNumbersWithSum(int[] array, int sum) {
int i = 0, j = array.length - 1;
while (i < j) {
int cur = array[i] + array[j];
@@ -2604,8 +2564,7 @@ public ArrayList FindNumbersWithSum(int[] array, int sum)
## 解题思路
```java
-public ArrayList> FindContinuousSequence(int sum)
-{
+public ArrayList> FindContinuousSequence(int sum) {
ArrayList> ret = new ArrayList<>();
int start = 1, end = 2;
int curSum = 3;
@@ -2648,8 +2607,7 @@ public ArrayList> FindContinuousSequence(int sum)
正确的解法应该是和书上一样，先旋转每个单词，再旋转整个字符串。
```java
-public String ReverseSentence(String str)
-{
+public String ReverseSentence(String str) {
int n = str.length();
char[] chars = str.toCharArray();
int i = 0, j = 0;
@@ -2664,14 +2622,12 @@ public String ReverseSentence(String str)
return new String(chars);
}
-private void reverse(char[] c, int i, int j)
-{
+private void reverse(char[] c, int i, int j) {
while (i < j)
swap(c, i++, j--);
}
-private void swap(char[] c, int i, int j)
-{
+private void swap(char[] c, int i, int j) {
char t = c[i];
c[i] = c[j];
c[j] = t;
@@ -2691,8 +2647,7 @@ private void swap(char[] c, int i, int j)
先将 "abc" 和 "XYZdef" 分别翻转，得到 "cbafedZYX"，然后再把整个字符串翻转得到 "XYZdefabc"。
```java
-public String LeftRotateString(String str, int n)
-{
+public String LeftRotateString(String str, int n) {
if (n >= str.length())
return str;
char[] chars = str.toCharArray();
@@ -2702,14 +2657,12 @@ public String LeftRotateString(String str, int n)
return new String(chars);
}
-private void reverse(char[] chars, int i, int j)
-{
+private void reverse(char[] chars, int i, int j) {
while (i < j)
swap(chars, i++, j--);
}
-private void swap(char[] chars, int i, int j)
-{
+private void swap(char[] chars, int i, int j) {
char t = chars[i];
chars[i] = chars[j];
chars[j] = t;
@@ -2727,8 +2680,7 @@ private void swap(char[] chars, int i, int j)
## 解题思路
```java
-public ArrayList maxInWindows(int[] num, int size)
-{
+public ArrayList maxInWindows(int[] num, int size) {
ArrayList ret = new ArrayList<>();
if (size > num.length || size < 1)
return ret;
@@ -2762,8 +2714,7 @@ public ArrayList maxInWindows(int[] num, int size)
空间复杂度：O(N2)
```java
-public List> dicesSum(int n)
-{
+public List> dicesSum(int n) {
final int face = 6;
final int pointNum = face * n;
long[][] dp = new long[n + 1][pointNum + 1];
@@ -2790,8 +2741,7 @@ public List> dicesSum(int n)
空间复杂度：O(N)
```java
-public List> dicesSum(int n)
-{
+public List> dicesSum(int n) {
final int face = 6;
final int pointNum = face * n;
long[][] dp = new long[2][pointNum + 1];
@@ -2829,8 +2779,7 @@ public List> dicesSum(int n)
## 解题思路
```java
-public boolean isContinuous(int[] nums)
-{
+public boolean isContinuous(int[] nums) {
if (nums.length < 5)
return false;
Arrays.sort(nums);
@@ -2861,8 +2810,7 @@ public boolean isContinuous(int[] nums)
约瑟夫环，圆圈长度为 n 的解可以看成长度为 n-1 的解再加上报数的长度 m。因为是圆圈，所以最后需要对 n 取余。
```java
-public int LastRemaining_Solution(int n, int m)
-{
+public int LastRemaining_Solution(int n, int m) {
if (n == 0) /* 特殊输入的处理 */
return -1;
if (n == 1) /* 返回条件 */
@@ -2884,8 +2832,7 @@ public int LastRemaining_Solution(int n, int m)
使用贪心策略，假设第 i 轮进行卖出操作，买入操作价格应该在 i 之前并且价格最低。
```java
-public int maxProfit(int[] prices)
-{
+public int maxProfit(int[] prices) {
if (prices == null || prices.length == 0)
return 0;
int soFarMin = prices[0];
@@ -2915,8 +2862,7 @@ public int maxProfit(int[] prices)
以下实现中，递归的返回条件为 n <= 0，取非后就是 n > 0，递归的主体部分为 sum += Sum_Solution(n - 1)，转换为条件语句后就是 (sum += Sum_Solution(n - 1)) > 0。
```java
-public int Sum_Solution(int n)
-{
+public int Sum_Solution(int n) {
int sum = n;
boolean b = (n > 0) && ((sum += Sum_Solution(n - 1)) > 0);
return sum;
@@ -2938,8 +2884,7 @@ a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进
递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。
```java
-public int Add(int a, int b)
-{
+public int Add(int a, int b) {
return b == 0 ? a : Add(a ^ b, (a & b) << 1);
}
```
@@ -2955,8 +2900,7 @@ public int Add(int a, int b)
## 解题思路
```java
-public int[] multiply(int[] A)
-{
+public int[] multiply(int[] A) {
int n = A.length;
int[] B = new int[n];
for (int i = 0, product = 1; i < n; product *= A[i], i++) /* 从左往右累乘 */
@@ -2988,8 +2932,7 @@ Output:
## 解题思路
```java
-public int StrToInt(String str)
-{
+public int StrToInt(String str) {
if (str == null || str.length() == 0)
return 0;
boolean isNegative = str.charAt(0) == '-';
diff --git a/notes/攻击技术.md b/notes/攻击技术.md
index c99071a0..d5a735ba 100644
--- a/notes/攻击技术.md
+++ b/notes/攻击技术.md
@@ -29,7 +29,7 @@
## 危害
-- 窃取用户的 Cookie 值
+- 窃取用户的 Cookie
- 伪造虚假的输入表单骗取个人信息
- 显示伪造的文章或者图片
@@ -47,7 +47,7 @@
富文本编辑器允许用户输入 HTML 代码，就不能简单地将 `<` 等字符进行过滤了，极大地提高了 XSS 攻击的可能性。
-富文本编辑器通常采用 XSS filter 来防范 XSS 攻击，可以定义一些标签白名单或者黑名单，从而不允许有攻击性的 HTML 代码的输入。
+富文本编辑器通常采用 XSS filter 来防范 XSS 攻击，通过定义一些标签白名单或者黑名单，从而不允许有攻击性的 HTML 代码的输入。
以下例子中，form 和 script 等标签都被转义，而 h 和 p 等标签将会保留。
@@ -131,7 +131,7 @@ http://www.examplebank.com/withdraw?account=AccoutName&amount=1000&for=PayeeName
。
```
-如果有账户名为 Alice 的用户访问了恶意站点，而她之前刚访问过银行不久，登录信息尚未过期，那么她就会损失 1000 资金。
+如果有账户名为 Alice 的用户访问了恶意站点，而她之前刚访问过银行不久，登录信息尚未过期，那么她就会损失 1000 美元。
这种恶意的网址可以有很多种形式，藏身于网页中的许多地方。此外，攻击者也不需要控制放置恶意网址的网站。例如他可以将这种地址藏在论坛，博客等任何用户生成内容的网站中。这意味着如果服务器端没有合适的防御措施的话，用户即使访问熟悉的可信网站也有受攻击的危险。
@@ -153,8 +153,6 @@ Referer 首部字段位于 HTTP 报文中，用于标识请求来源的地址。
因为 CSRF 攻击是在用户无意识的情况下发生的，所以要求用户输入验证码可以让用户知道自己正在做的操作。
-也可以要求用户输入验证码来进行校验。
-
# 三、SQL 注入攻击
## 概念
diff --git a/notes/数据库系统原理.md b/notes/数据库系统原理.md
index 151ffc0f..e7ef804b 100644
--- a/notes/数据库系统原理.md
+++ b/notes/数据库系统原理.md
@@ -383,13 +383,13 @@ MVCC 不能解决幻读的问题，Next-Key Locks 就是为了解决这个问题
## Record Locks
-锁定的对象是记录的索引，而不是记录本身。
+锁定一个记录上的索引，而不是记录本身。
如果表没有设置索引，InnoDB 会自动在主键上创建隐藏的聚集索引，因此 Record Locks 依然可以使用。
## Gap Locks
-锁定一个范围内的索引，例如当一个事务执行以下语句，其它事务就不能在 t.c 中插入 15。
+锁定索引之间的间隙，但是不包含索引本身。例如当一个事务执行以下语句，其它事务就不能在 t.c 中插入 15。
```sql
SELECT c FROM t WHERE c BETWEEN 10 and 20 FOR UPDATE;
@@ -397,28 +397,14 @@ SELECT c FROM t WHERE c BETWEEN 10 and 20 FOR UPDATE;
## Next-Key Locks
-它是 Record Locks 和 Gap Locks 的结合，不仅锁定一个记录，也锁定范围内的索引。在 user 中有以下记录：
+它是 Record Locks 和 Gap Locks 的结合，不仅锁定一个记录上的索引，也锁定范围内的索引。例如一个索引包含以下值：10, 11, 13, and 20，那么就需要锁定以下区间：
```sql
-| id | last_name | first_name | age |
-|------|-------------|--------------|-------|
-| 4 | stark | tony | 21 |
-| 1 | tom | hiddleston | 30 |
-| 3 | morgan | freeman | 40 |
-| 5 | jeff | dean | 50 |
-| 2 | donald | trump | 80 |
-+------|-------------|--------------|-------+
-```
-
-那么就需要锁定以下范围：
-
-```sql
-(-∞, 21]
-(21, 30]
-(30, 40]
-(40, 50]
-(50, 80]
-(80, ∞)
+(negative infinity, 10]
+(10, 11]
+(11, 13]
+(13, 20]
+(20, positive infinity)
```
# 七、关系数据库设计理论
diff --git a/notes/算法.md b/notes/算法.md
index fb878742..cb5d4dbe 100644
--- a/notes/算法.md
+++ b/notes/算法.md
@@ -1623,10 +1623,10 @@ private List keys(Node x, Key l, Key h) {
## 2-3 查找树
-
-
2-3 查找树引入了 2- 节点和 3- 节点，目的是为了让树平衡。一颗完美平衡的 2-3 查找树的所有空链接到根节点的距离应该是相同的。
+
+
### 1. 插入操作
插入操作和 BST 的插入操作有很大区别，BST 的插入操作是先进行一次未命中的查找，然后再将节点插入到对应的空链接上。但是 2-3 查找树如果也这么做的话，那么就会破坏了平衡性。它是将新节点插入到叶子节点上。
@@ -2042,24 +2042,26 @@ public class SparseVector {
## 汉诺塔
+
+
这是一个经典的递归问题，分为三步求解：
-1. 将 n-1 个圆盘从 from -> buffer
-2. 将 1 个圆盘从 from -> to
-3. 将 n-1 个圆盘从 buffer -> to
+- 将 n-1 个圆盘从 from -> buffer
+
+
+
+- 将 1 个圆盘从 from -> to
+
+
+
+- 将 n-1 个圆盘从 buffer -> to
+
+
如果只有一个圆盘，那么只需要进行一次移动操作。
从上面的讨论可以知道，an = 2 * an-1 + 1，显然 an = 2n - 1，n 个圆盘需要移动 2n - 1 次。
- 
-
- 
-
- 
-
- 
-
```java
public class Hanoi {
public static void move(int n, String from, String buffer, String to) {
@@ -2105,7 +2107,7 @@ from H1 to H3
生成编码时，从根节点出发，向左遍历则添加二进制位 0，向右则添加二进制位 1，直到遍历到根节点，根节点代表的字符的编码就是这个路径编码。
- 
+
```java
public class Huffman {
diff --git a/notes/系统设计基础.md b/notes/系统设计基础.md
index 40f0ca9d..805764a9 100644
--- a/notes/系统设计基础.md
+++ b/notes/系统设计基础.md
@@ -79,7 +79,7 @@
实现可扩展主要有两种方式：
- 使用消息队列进行解耦，应用之间通过消息传递的方式进行通信；
-- 使用分布式服务将业务和可复用的服务分离开来，业务使用分布式服务框架调用可复用的服务。新增的产品可以用过调用可复用的服务来实现业务逻辑，对其它产品没有影响。
+- 使用分布式服务将业务和可复用的服务分离开来，业务使用分布式服务框架调用可复用的服务。新增的产品可以通过调用可复用的服务来实现业务逻辑，对其它产品没有影响。
# 四、可用性
diff --git a/notes/设计模式.md b/notes/设计模式.md
index ae44213e..b8f4dc9b 100644
--- a/notes/设计模式.md
+++ b/notes/设计模式.md
@@ -98,7 +98,9 @@ public static synchronized Singleton getUniqueInstance() {
（三）饿汉式-线程安全
-线程不安全问题主要是由于 uniqueInstance 被实例化了多次，如果 uniqueInstance 采用直接实例化的话，就不会被实例化多次，也就不会产生线程不安全问题。但是直接实例化的方式也丢失了延迟实例化带来的节约资源的优势。
+线程不安全问题主要是由于 uniqueInstance 被实例化了多次，如果 uniqueInstance 采用直接实例化的话，就不会被实例化多次，也就不会产生线程不安全问题。
+
+但是直接实例化的方式也丢失了延迟实例化带来的节约资源的好处。
```java
private static Singleton uniqueInstance = new Singleton();
@@ -106,7 +108,7 @@ private static Singleton uniqueInstance = new Singleton();
（四）双重校验锁-线程安全
-uniqueInstance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行。也就是说，只有当 uniqueInstance 没有被实例化时，才需要进行加锁。
+uniqueInstance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行，只有当 uniqueInstance 没有被实例化时，才需要进行加锁。
双重校验锁先判断 uniqueInstance 是否已经被实例化，如果没有被实例化，那么才对实例化语句进行加锁。
@@ -131,7 +133,7 @@ public class Singleton {
}
```
-考虑下面的实现，也就是只使用了一个 if 语句。在 uniqueInstance == null 的情况下，如果两个线程同时执行 if 语句，那么两个线程就会同时进入 if 语句块内。虽然在 if 语句块内有加锁操作，但是两个线程都会执行 `uniqueInstance = new Singleton();` 这条语句，只是先后的问题，也就是说会进行两次实例化，从而产生了两个实例。因此必须使用双重校验锁，也就是需要使用两个 if 语句。
+考虑下面的实现，也就是只使用了一个 if 语句。在 uniqueInstance == null 的情况下，如果两个线程同时执行 if 语句，那么两个线程就会同时进入 if 语句块内。虽然在 if 语句块内有加锁操作，但是两个线程都会执行 `uniqueInstance = new Singleton();` 这条语句，只是先后的问题，那么就会进行两次实例化，从而产生了两个实例。因此必须使用双重校验锁，也就是需要使用两个 if 语句。
```java
if (uniqueInstance == null) {
@@ -157,7 +159,7 @@ uniqueInstance 采用 volatile 关键字修饰也是很有必要的。`uniqueIns
这种方式不仅具有延迟初始化的好处，而且由虚拟机提供了对线程安全的支持。
-```source-java
+```java
public class Singleton {
private Singleton() {
@@ -299,7 +301,7 @@ public class Client {
### 意图
-定义了一个创建对象的接口，但由子类决定要实例化哪个类。工厂方法把实例化推迟到子类。
+定义了一个创建对象的接口，但由子类决定要实例化哪个类。工厂方法把实例化操作推迟到子类。
### 类图
@@ -1851,11 +1853,7 @@ No gumball dispensed
### 与状态模式的比较
-状态模式的类图和策略模式类似，并且都是能够动态改变对象的行为。
-
-但是状态模式是通过状态转移来改变 Context 所组合的 State 对象，而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。
-
-所谓的状态转移，是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变，注意必须要是在运行过程中。
+状态模式的类图和策略模式类似，并且都是能够动态改变对象的行为。但是状态模式是通过状态转移来改变 Context 所组合的 State 对象，而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。所谓的状态转移，是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变，注意必须要是在运行过程中。
状态模式主要是用来解决状态转移的问题，当状态发生转移了，那么 Context 对象就会改变它的行为；而策略模式主要是用来封装一组可以互相替代的算法族，并且可以根据需要动态地去替换 Context 使用的算法。
@@ -1969,7 +1967,7 @@ public abstract class CaffeineBeverage {
```
```java
-public class Coffee extends CaffeineBeverage{
+public class Coffee extends CaffeineBeverage {
@Override
void brew() {
System.out.println("Coffee.brew");
@@ -1983,7 +1981,7 @@ public class Coffee extends CaffeineBeverage{
```
```java
-public class Tea extends CaffeineBeverage{
+public class Tea extends CaffeineBeverage {
@Override
void brew() {
System.out.println("Tea.brew");
@@ -2238,7 +2236,7 @@ Number of items: 6
### 意图
-使用什么都不做的空对象来替代 NULL。
+使用什么都不做的空对象来代替 NULL。
一个方法返回 NULL，意味着方法的调用端需要去检查返回值是否是 NULL，这么做会导致非常多的冗余的检查代码。并且如果某一个调用端忘记了做这个检查返回值，而直接使用返回的对象，那么就有可能抛出空指针异常。
@@ -2393,7 +2391,7 @@ public abstract class TV {
```
```java
-public class Sony extends TV{
+public class Sony extends TV {
@Override
public void on() {
System.out.println("Sony.on()");
@@ -2412,7 +2410,7 @@ public class Sony extends TV{
```
```java
-public class RCA extends TV{
+public class RCA extends TV {
@Override
public void on() {
System.out.println("RCA.on()");
@@ -2551,9 +2549,6 @@ public abstract class Component {
```
```java
-import java.util.ArrayList;
-import java.util.List;
-
public class Composite extends Component {
private List child;
@@ -2659,7 +2654,7 @@ Composite:root
### 类图
-装饰者（Decorator）和具体组件（ConcreteComponent）都继承自组件（Component），具体组件的方法实现不需要依赖于其它对象，而装饰者组合了一个组件，这样它可以装饰其它装饰者或者具体组件。所谓装饰，就是把这个装饰者套在被装饰上，从而动态扩展被装饰者的功能。装饰者的方法有一部分是自己的，这属于它的功能，然后调用被装饰者的方法实现，从而也保留了被装饰者的功能。可以看到，具体组件应当是装饰层次的最低层，因为只有具体组件的方法实现不需要依赖于其它对象。
+装饰者（Decorator）和具体组件（ConcreteComponent）都继承自组件（Component），具体组件的方法实现不需要依赖于其它对象，而装饰者组合了一个组件，这样它可以装饰其它装饰者或者具体组件。所谓装饰，就是把这个装饰者套在被装饰者之上，从而动态扩展被装饰者的功能。装饰者的方法有一部分是自己的，这属于它的功能，然后调用被装饰者的方法实现，从而也保留了被装饰者的功能。可以看到，具体组件应当是装饰层次的最低层，因为只有具体组件的方法实现不需要依赖于其它对象。
@@ -2770,7 +2765,7 @@ public class Client {
### 实现
-观看电影需要操作很多电器，使用外观模式可以实现一键看电影功能。
+观看电影需要操作很多电器，使用外观模式实现一键看电影功能。
```java
public class SubSystem {
@@ -2811,7 +2806,7 @@ public class Client {
### 设计原则
-最少知识原则：只和你的密友谈话。也就是客户对象所需要交互的对象应当尽可能少。
+最少知识原则：只和你的密友谈话。也就是说客户对象所需要交互的对象应当尽可能少。
## 6. 享元（Flyweight）
@@ -2822,8 +2817,8 @@ public class Client {
### 类图
- Flyweight：享元对象
-- IntrinsicState：内部状态，相同的项元对象共享
-- ExtrinsicState：外部状态
+- IntrinsicState：内部状态，享元对象共享内部状态
+- ExtrinsicState：外部状态，每个享元对象的外部状态不同
@@ -2854,8 +2849,6 @@ public class ConcreteFlyweight implements Flyweight {
```
```java
-import java.util.HashMap;
-
public class FlyweightFactory {
private HashMap flyweights = new HashMap<>();
diff --git a/pics/VP4n3i8m34Ntd28NQ4_0KCJ2q044Oez.png b/pics/VP4n3i8m34Ntd28NQ4_0KCJ2q044Oez.png
new file mode 100644
index 0000000000000000000000000000000000000000..c77f4ff840062457f3f722a72d6b7e05eb2e32f3
GIT binary patch
literal 21504
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