From 9e1c1c51c301c95c2cda81bfbe23289cc883281a Mon Sep 17 00:00:00 2001 From: CyC2018 <1029579233@qq.com> Date: Wed, 15 Aug 2018 19:39:49 +0800 Subject: [PATCH 01/24] auto commit --- notes/剑指 offer 题解.md | 212 +++++++++++++++++---------------------- 1 file changed, 94 insertions(+), 118 deletions(-) diff --git a/notes/剑指 offer 题解.md b/notes/剑指 offer 题解.md index 0ac7d7e4..1bac6bbb 100644 --- a/notes/剑指 offer 题解.md +++ b/notes/剑指 offer 题解.md @@ -10,8 +10,8 @@ * [9. 用两个栈实现队列](#9-用两个栈实现队列) * [10.1 斐波那契数列](#101-斐波那契数列) * [10.2 跳台阶](#102-跳台阶) -* [10.3 变态跳台阶](#103-变态跳台阶) -* [10.4 矩形覆盖](#104-矩形覆盖) +* [10.3 矩形覆盖](#103-矩形覆盖) +* [10.4 变态跳台阶](#104-变态跳台阶) * [11. 旋转数组的最小数字](#11-旋转数组的最小数字) * [12. 矩阵中的路径](#12-矩阵中的路径) * [13. 机器人的运动范围](#13-机器人的运动范围) @@ -465,7 +465,7 @@ public int pop() throws Exception { ## 题目描述 -求菲波那契数列的第 n 项，n <= 39。 +求斐波那契数列的第 n 项，n <= 39。

@@ -535,23 +535,6 @@ public class Solution { ## 解题思路 -复杂度：O(N) + O(N) - -```java -public int JumpFloor(int n) { - if (n == 1) - return 1; - int[] dp = new int[n]; - dp[0] = 1; - dp[1] = 2; - for (int i = 2; i < n; i++) - dp[i] = dp[i - 1] + dp[i - 2]; - return dp[n - 1]; -} -``` - -复杂度：O(N) + O(1) - ```java public int JumpFloor(int n) { if (n <= 2) @@ -567,7 +550,32 @@ public int JumpFloor(int n) { } ``` -# 10.3 变态跳台阶 +# 10.3 矩形覆盖 + +[NowCoder](https://www.nowcoder.com/practice/72a5a919508a4251859fb2cfb987a0e6?tpId=13&tqId=11163&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking) + +## 题目描述 + +我们可以用 2\*1 的小矩形横着或者竖着去覆盖更大的矩形。请问用 n 个 2\*1 的小矩形无重叠地覆盖一个 2\*n 的大矩形，总共有多少种方法？ + +## 解题思路 + +```java +public int RectCover(int n) { + if (n <= 2) + return n; + int pre2 = 1, pre1 = 2; + int result = 0; + for (int i = 3; i <= n; i++) { + result = pre2 + pre1; + pre2 = pre1; + pre1 = result; + } + return result; +} +``` + +# 10.4 变态跳台阶 [NowCoder](https://www.nowcoder.com/practice/22243d016f6b47f2a6928b4313c85387?tpId=13&tqId=11162&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking) @@ -588,47 +596,6 @@ public int JumpFloorII(int target) { } ``` -# 10.4 矩形覆盖 - -[NowCoder](https://www.nowcoder.com/practice/72a5a919508a4251859fb2cfb987a0e6?tpId=13&tqId=11163&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking) - -## 题目描述 - -我们可以用 2\*1 的小矩形横着或者竖着去覆盖更大的矩形。请问用 n 个 2\*1 的小矩形无重叠地覆盖一个 2\*n 的大矩形，总共有多少种方法？ - -## 解题思路 - -复杂度：O(N) + O(N) - -```java -public int RectCover(int n) { - if (n <= 2) - return n; - int[] dp = new int[n]; - dp[0] = 1; - dp[1] = 2; - for (int i = 2; i < n; i++) - dp[i] = dp[i - 1] + dp[i - 2]; - return dp[n - 1]; -} -``` - -复杂度：O(N) + O(1) - -```java -public int RectCover(int n) { - if (n <= 2) - return n; - int pre2 = 1, pre1 = 2; - int result = 0; - for (int i = 3; i <= n; i++) { - result = pre2 + pre1; - pre2 = pre1; - pre1 = result; - } - return result; -} -``` # 11. 旋转数组的最小数字 @@ -638,18 +605,34 @@ public int RectCover(int n) { 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 -例如数组 {3, 4, 5, 1, 2} 为 {1, 2, 3, 4, 5} 的一个旋转，该数组的最小值为 1。NOTE：给出的所有元素都大于 0，若数组大小为 0，请返回 0。 +例如数组 {3, 4, 5, 1, 2} 为 {1, 2, 3, 4, 5} 的一个旋转，该数组的最小值为 1。 ## 解题思路 +在一个有序数组中查找一个元素可以用二分查找，二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度都为 O(logN)。 + +本题可以修改二分查找算法进行求解： + - 当 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) 二分查找部分。 +```java +public int minNumberInRotateArray(int[] nums) { + if (nums.length == 0) + return 0; + int l = 0, h = nums.length - 1; + while (l < h) { + int m = l + (h - l) / 2; + if (nums[m] <= nums[h]) + h = m; + else + l = m + 1; + } + return nums[l]; +} +``` -但是如果出现 nums[l] == nums[m] == nums[h]，那么此时无法确定解在哪个区间，需要切换到顺序查找。 - -复杂度：O(logN) + O(1) +如果数组元素允许重复的话，那么就会出现一个特殊的情况：nums[l] == nums[m] == nums[h]，那么此时无法确定解在哪个区间，需要切换到顺序查找。例如对于数组 {1,1,1,0,1}，l、m 和 h 指向的数都为 1，此时无法知道最小数字 0 在哪个区间。 ```java public int minNumberInRotateArray(int[] nums) { @@ -737,7 +720,9 @@ private char[][] buildMatrix(char[] array) { ## 题目描述 -地上有一个 m 行和 n 列的方格。一个机器人从坐标 (0, 0) 的格子开始移动，每一次只能向左右上下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于 k 的格子。例如，当 k 为 18 时，机器人能够进入方格（35, 37），因为 3+5+3+7=18。但是，它不能进入方格（35, 38），因为 3+5+3+8=19。请问该机器人能够达到多少个格子？ +地上有一个 m 行和 n 列的方格。一个机器人从坐标 (0, 0) 的格子开始移动，每一次只能向左右上下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于 k 的格子。 + +例如，当 k 为 18 时，机器人能够进入方格 (35,37)，因为 3+5+3+7=18。但是，它不能进入方格 (35,37)，因为 3+5+3+8=19。请问该机器人能够达到多少个格子？ ## 解题思路 @@ -806,7 +791,7 @@ return 36 (10 = 3 + 3 + 4) ### 贪心 -尽可能多剪长度为 3 的绳子，并且不允许有长度为 1 的绳子出现，如果出现了，就从已经切好长度为 3 的绳子中拿出一段与长度为 1 的绳子重新组合，把它们切成两段长度为 2 的绳子。 +尽可能多剪长度为 3 的绳子，并且不允许有长度为 1 的绳子出现。如果出现了，就从已经切好长度为 3 的绳子中拿出一段与长度为 1 的绳子重新组合，把它们切成两段长度为 2 的绳子。 证明：当 n >= 5 时，3(n - 3) - 2(n - 2) = n - 5 >= 0。因此把长度大于 5 的绳子切成两段，令其中一段长度为 3 可以使得两段的乘积最大。 @@ -847,19 +832,9 @@ public int integerBreak(int n) { 输入一个整数，输出该数二进制表示中 1 的个数。 -### Integer.bitCount() - -```java -public int NumberOf1(int n) { - return Integer.bitCount(n); -} -``` - ### n&(n-1) -O(M) 时间复杂度解法，其中 M 表示 1 的个数。 - -该位运算是去除 n 的位级表示中最低的那一位。 +该位运算去除 n 的位级表示中最低的那一位。 ``` n : 10110100 @@ -867,6 +842,9 @@ n-1 : 10110011 n&(n-1) : 10110000 ``` +时间复杂度：O(M)，其中 M 表示 1 的个数。 + + ```java public int NumberOf1(int n) { int cnt = 0; @@ -878,13 +856,22 @@ public int NumberOf1(int n) { } ``` + +### Integer.bitCount() + +```java +public int NumberOf1(int n) { + return Integer.bitCount(n); +} +``` + # 16. 数值的整数次方 [NowCoder](https://www.nowcoder.com/practice/1a834e5e3e1a4b7ba251417554e07c00?tpId=13&tqId=11165&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking) ## 题目描述 -给定一个 double 类型的浮点数 base 和 int 类型的整数 exponent。求 base 的 exponent 次方。 +给定一个 double 类型的浮点数 base 和 int 类型的整数 exponent，求 base 的 exponent 次方。 ## 解题思路 @@ -892,7 +879,7 @@ public int NumberOf1(int n) {

-因为 (x\*x)n/2 可以通过递归求解，并且每递归一次，n 都减小一半，因此整个算法的时间复杂度为 O(logN)。 +因为 (x\*x)n/2 可以通过递归求解，并且每次递归 n 都减小一半，因此整个算法的时间复杂度为 O(logN)。 ```java public double Power(double base, int exponent) { @@ -1028,6 +1015,7 @@ public ListNode deleteDuplication(ListNode pHead) { ```java public boolean match(char[] str, char[] pattern) { + int m = str.length, n = pattern.length; boolean[][] dp = new boolean[m + 1][n + 1]; @@ -1058,9 +1046,24 @@ public boolean match(char[] str, char[] pattern) { ## 题目描述 -请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。 +```html +true + +"+100" +"5e2" +"-123" +"3.1416" +"-1E-16" + +false + +"12e" +"1a3.14" +"1.2.3" +"+-5" +"12e+4.3" +``` -例如，字符串 "+100","5e2","-123","3.1416" 和 "-1E-16" 都表示数值。但是 "12e","1a3.14","1.2.3","+-5" 和 "12e+4.3" 都不是。 ## 解题思路 @@ -1124,8 +1127,7 @@ public void reOrderArray(int[] nums) {

```java -public ListNode FindKthToTail(ListNode head, int k) -{ +public ListNode FindKthToTail(ListNode head, int k) { if (head == null) return null; ListNode P1 = head; @@ -1148,9 +1150,7 @@ public ListNode FindKthToTail(ListNode head, int k) ## 题目描述 -一个链表中包含环，请找出该链表的环的入口结点。 - -要求不能使用额外的空间。 +一个链表中包含环，请找出该链表的环的入口结点。要求不能使用额外的空间。 ## 解题思路 @@ -1161,8 +1161,7 @@ public ListNode FindKthToTail(ListNode head, int k)

```java -public ListNode EntryNodeOfLoop(ListNode pHead) -{ +public ListNode EntryNodeOfLoop(ListNode pHead) { if (pHead == null || pHead.next == null) return null; ListNode slow = pHead, fast = pHead; @@ -1304,8 +1303,6 @@ private boolean isSubtreeWithRoot(TreeNode root1, TreeNode root2) { ## 解题思路 -### 递归 - ```java public void Mirror(TreeNode root) { if (root == null) @@ -1322,29 +1319,6 @@ private void swap(TreeNode root) { } ``` -### 迭代 - -```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) @@ -1445,7 +1419,9 @@ public int min() { ## 题目描述 -输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列 1,2,3,4,5 是某栈的压入顺序，序列 4,5,3,2,1 是该压栈序列对应的一个弹出序列，但 4,3,5,1,2 就不可能是该压栈序列的弹出序列。 +输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。 + +例如序列 1,2,3,4,5 是某栈的压入顺序，序列 4,5,3,2,1 是该压栈序列对应的一个弹出序列，但 4,3,5,1,2 就不可能是该压栈序列的弹出序列。 ## 解题思路 @@ -1838,7 +1814,7 @@ private void backtracking(char[] chars, boolean[] hasUsed, StringBuilder s) { 多数投票问题，可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(N)。 -使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素不相等时，令 cnt--。如果前面查找了 i 个元素，且 cnt == 0，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2 ，因为如果多于 i / 2 的话 cnt 就一定不会为 0 。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。 +使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素相等时，令 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) { From 0fb30502e019f03667dc240d110fe8b869c8b1a4 Mon Sep 17 00:00:00 2001 From: CyC2018 <1029579233@qq.com> Date: Wed, 15 Aug 2018 21:44:50 +0800 Subject: [PATCH 02/24] auto commit --- notes/算法.md | 1073 +++++++++-------- pics/1a2f2998-d0da-41c8-8222-1fd95083a66b.png | Bin 0 -> 8192 bytes pics/2a8e1442-2381-4439-a83f-0312c8678b1f.png | Bin 0 -> 5120 bytes pics/37e79a32-95a9-4503-bdb1-159527e628b8.png | Bin 0 -> 8192 bytes 4 files changed, 598 insertions(+), 475 deletions(-) create mode 100644 pics/1a2f2998-d0da-41c8-8222-1fd95083a66b.png create mode 100644 pics/2a8e1442-2381-4439-a83f-0312c8678b1f.png create mode 100644 pics/37e79a32-95a9-4503-bdb1-159527e628b8.png diff --git a/notes/算法.md b/notes/算法.md index cb5d4dbe..e404a3c8 100644 --- a/notes/算法.md +++ b/notes/算法.md @@ -2,19 +2,10 @@ * [一、前言](#一前言) * [二、算法分析](#二算法分析) * [数学模型](#数学模型) + * [注意事项](#注意事项) * [ThreeSum](#threesum) * [倍率实验](#倍率实验) - * [注意事项](#注意事项) -* [三、栈和队列](#三栈和队列) - * [栈](#栈) - * [队列](#队列) -* [四、并查集](#四并查集) - * [quick-find](#quick-find) - * [quick-union](#quick-union) - * [加权 quick-union](#加权-quick-union) - * [路径压缩的加权 quick-union](#路径压缩的加权-quick-union) - * [各种 union-find 算法的比较](#各种-union-find-算法的比较) -* [五、排序](#五排序) +* [三、排序](#三排序) * [选择排序](#选择排序) * [冒泡排序](#冒泡排序) * [插入排序](#插入排序) @@ -23,6 +14,15 @@ * [快速排序](#快速排序) * [堆排序](#堆排序) * [小结](#小结) +* [四、并查集](#四并查集) + * [Quick Find](#quick-find) + * [Quick Union](#quick-union) + * [加权 Quick Union](#加权-quick-union) + * [路径压缩的加权 Quick Union](#路径压缩的加权-quick-union) + * [比较](#比较) +* [五、栈和队列](#五栈和队列) + * [栈](#栈) + * [队列](#队列) * [六、查找](#六查找) * [初级实现](#初级实现) * [二叉查找树](#二叉查找树) @@ -39,7 +39,8 @@ # 一、前言 -本文实现代码以及测试代码放在 [Algorithm](https://github.com/CyC2018/Algorithm) +- 实现代码：[Algorithm](https://github.com/CyC2018/Algorithm) +- 绘图文件：[ProcessOn](https://www.processon.com/view/link/5a3e4c1ee4b0ce9ffea8c727) # 二、算法分析 @@ -61,6 +62,28 @@ N3/6-N2/2+N/3 的增长数量级为 O(N3)。增 使用成本模型来评估算法，例如数组的访问次数就是一种成本模型。 +## 注意事项 + +### 1. 大常数 + +在求近似时，如果低级项的常数系数很大，那么近似的结果就是错误的。 + +### 2. 缓存 + +计算机系统会使用缓存技术来组织内存，访问数组相邻的元素会比访问不相邻的元素快很多。 + +### 3. 对最坏情况下的性能的保证 + +在核反应堆、心脏起搏器或者刹车控制器中的软件，最坏情况下的性能是十分重要的。 + +### 4. 随机化算法 + +通过打乱输入，去除算法对输入的依赖。 + +### 5. 均摊分析 + +将所有操作的总成本除于操作总数来将成本均摊。例如对一个空栈进行 N 次连续的 push() 调用需要访问数组的元素为 N+4+8+16+...+2N=5N-4（N 是向数组写入元素，其余的都是调整数组大小时进行复制需要的访问数组操作），均摊后每次操作访问数组的平均次数为常数。 + ## ThreeSum ThreeSum 用于统计一个数组中和为 0 的三元组数量。 @@ -71,6 +94,10 @@ public interface ThreeSum { } ``` +### 1. ThreeSumSlow + +该算法的内循环为 `if (nums[i] + nums[j] + nums[k] == 0)` 语句，总共执行的次数为 N(N-1)(N-2) = N3/6-N2/2+N/3，因此它的近似执行次数为 \~N3/6，增长数量级为 O(N3)。 + ```java public class ThreeSumSlow implements ThreeSum { @Override @@ -87,9 +114,7 @@ public class ThreeSumSlow implements ThreeSum { } ``` -该算法的内循环为 `if (nums[i] + nums[j] + nums[k] == 0)` 语句，总共执行的次数为 N(N-1)(N-2) = N3/6-N2/2+N/3，因此它的近似执行次数为 \~N3/6，增长数量级为 O(N3)。 - - **改进**
+### 2. ThreeSumFast 通过将数组先排序，对两个元素求和，并用二分查找方法查找是否存在该和的相反数，如果存在，就说明存在三元组的和为 0。 @@ -153,21 +178,31 @@ public class BinarySearch { ```java public class RatioTest { + public static void main(String[] args) { + int N = 500; int loopTimes = 7; double preTime = -1; + while (loopTimes-- > 0) { + int[] nums = new int[N]; + StopWatch.start(); + ThreeSum threeSum = new ThreeSumSlow(); + int cnt = threeSum.count(nums); System.out.println(cnt); + double elapsedTime = StopWatch.elapsedTime(); double ratio = preTime == -1 ? 0 : elapsedTime / preTime; System.out.println(N + " " + elapsedTime + " " + ratio); + preTime = elapsedTime; N *= 2; + } } } @@ -175,12 +210,15 @@ public class RatioTest { ```java public class StopWatch { + private static long start; - - public static void start(){ + + + public static void start() { start = System.currentTimeMillis(); } - + + public static double elapsedTime() { long now = System.currentTimeMillis(); return (now - start) / 1000.0; @@ -188,438 +226,7 @@ public class StopWatch { } ``` -## 注意事项 - -### 1. 大常数 - -在求近似时，如果低级项的常数系数很大，那么近似的结果就是错误的。 - -### 2. 缓存 - -计算机系统会使用缓存技术来组织内存，访问数组相邻的元素会比访问不相邻的元素快很多。 - -### 3. 对最坏情况下的性能的保证 - -在核反应堆、心脏起搏器或者刹车控制器中的软件，最坏情况下的性能是十分重要的。 - -### 4. 随机化算法 - -通过打乱输入，去除算法对输入的依赖。 - -### 5. 均摊分析 - -将所有操作的总成本除于操作总数来将成本均摊。例如对一个空栈进行 N 次连续的 push() 调用需要访问数组的元素为 N+4+8+16+...+2N=5N-4（N 是向数组写入元素，其余的都是调整数组大小时进行复制需要的访问数组操作），均摊后每次操作访问数组的平均次数为常数。 - -# 三、栈和队列 - -## 栈 - -First-In-Last-Out - -```java -public interface MyStack extends Iterable { - MyStack push(Item item); - - Item pop() throws Exception; - - boolean isEmpty(); - - int size(); -} -``` - -### 1. 数组实现 - -```java -public class ArrayStack implements MyStack { - // 栈元素数组，只能通过转型来创建泛型数组 - private Item[] a = (Item[]) new Object[1]; - // 元素数量 - private int N = 0; - - @Override - public MyStack push(Item item) { - check(); - a[N++] = item; - return this; - } - - @Override - public Item pop() throws Exception { - if (isEmpty()) - throw new Exception("stack is empty"); - - Item item = a[--N]; - check(); - a[N] = null; // 避免对象游离 - return item; - } - - private void check() { - if (N >= a.length) - resize(2 * a.length); - else if (N > 0 && N <= a.length / 4) - resize(a.length / 2); - } - - /** - * 调整数组大小，使得栈具有伸缩性 - */ - private void resize(int size) { - Item[] tmp = (Item[]) new Object[size]; - for (int i = 0; i < N; i++) - tmp[i] = a[i]; - a = tmp; - } - - @Override - public boolean isEmpty() { - return N == 0; - } - - @Override - public int size() { - return N; - } - - @Override - public Iterator iterator() { - // 返回逆序遍历的迭代器 - return new Iterator() { - private int i = N; - - @Override - public boolean hasNext() { - return i > 0; - } - - @Override - public Item next() { - return a[--i]; - } - }; - } -} -``` - -### 2. 链表实现 - -需要使用链表的头插法来实现，因为头插法中最后压入栈的元素在链表的开头，它的 next 指针指向前一个压入栈的元素，在弹出元素时就可以通过 next 指针遍历到前一个压入栈的元素从而让这个元素称为新的栈顶元素。 - -```java -public class ListStack implements MyStack { - private Node top = null; - private int N = 0; - - private class Node { - Item item; - Node next; - } - - @Override - public MyStack push(Item item) { - Node newTop = new Node(); - newTop.item = item; - newTop.next = top; - top = newTop; - N++; - return this; - } - - @Override - public Item pop() throws Exception { - if (isEmpty()) - throw new Exception("stack is empty"); - Item item = top.item; - top = top.next; - N--; - return item; - } - - @Override - public boolean isEmpty() { - return N == 0; - } - - @Override - public int size() { - return N; - } - - @Override - public Iterator iterator() { - return new Iterator() { - private Node cur = top; - - @Override - public boolean hasNext() { - return cur != null; - } - - @Override - public Item next() { - Item item = cur.item; - cur = cur.next; - return item; - } - }; - } -} -``` - -## 队列 - -First-In-First-Out - -下面是队列的链表实现，需要维护 first 和 last 节点指针，分别指向队首和队尾。 - -这里需要考虑 first 和 last 指针哪个作为链表的开头。因为出队列操作需要让队首元素的下一个元素成为队首，所以需要容易获取下一个元素，而链表的头部节点的 next 指针指向下一个元素，因此可以让 first 指针链表的开头。 - -```java -public interface MyQueue extends Iterable { - int size(); - - boolean isEmpty(); - - MyQueue add(Item item); - - Item remove() throws Exception; -} -``` - -```java -public class ListQueue implements MyQueue { - private Node first; - private Node last; - int N = 0; - - private class Node { - Item item; - Node next; - } - - @Override - public boolean isEmpty() { - return N == 0; - } - - @Override - public int size() { - return N; - } - - @Override - public MyQueue add(Item item) { - Node newNode = new Node(); - newNode.item = item; - newNode.next = null; - if (isEmpty()) { - last = newNode; - first = newNode; - } else { - last.next = newNode; - last = newNode; - } - N++; - return this; - } - - @Override - public Item remove() throws Exception { - if (isEmpty()) - throw new Exception("queue is empty"); - Node node = first; - first = first.next; - N--; - if (isEmpty()) - last = null; - return node.item; - } - - @Override - public Iterator iterator() { - return new Iterator() { - Node cur = first; - - @Override - public boolean hasNext() { - return cur != null; - } - - @Override - public Item next() { - Item item = cur.item; - cur = cur.next; - return item; - } - }; - } -} -``` - -# 四、并查集 - -用于解决动态连通性问题，能动态连接两个点，并且判断两个点是否连通。 - -

- -| 方法 | 描述 | -| :---: | :---: | -| UF(int N) | 构造一个大小为 N 的并查集 | -| void union(int p, int q) | 连接 p 和 q 节点 | -| int find(int p) | 查找 p 所在的连通分量 | -| boolean connected(int p, int q) | 判断 p 和 q 节点是否连通 | - -```java -public abstract class UF { - protected int[] id; - - public UF(int N) { - id = new int[N]; - for (int i = 0; i < N; i++) - id[i] = i; - } - - public boolean connected(int p, int q) { - return find(p) == find(q); - } - - public abstract int find(int p); - - public abstract void union(int p, int q); -} -``` - -## quick-find - -可以快速进行 find 操作，即可以快速判断两个节点是否连通。 - -同一连通分量的所有节点的 id 值相等。 - -但是 union 操作代价却很高，需要将其中一个连通分量中的所有节点 id 值都修改为另一个节点的 id 值。 - -

- -```java -public class QuickFindUF extends UF { - public QuickFindUF(int N) { - super(N); - } - - @Override - public int find(int p) { - return id[p]; - } - - @Override - public void union(int p, int q) { - int pID = find(p); - int qID = find(q); - - if (pID == qID) - return; - - for (int i = 0; i < id.length; i++) - if (id[i] == pID) - id[i] = qID; - } -} - -``` - -## quick-union - -可以快速进行 union 操作，只需要修改一个节点的 id 值即可。 - -但是 find 操作开销很大，因为同一个连通分量的节点 id 值不同，id 值只是用来指向另一个节点。因此需要一直向上查找操作，直到找到最上层的节点。 - -

- -```java -public class QuickUnionUF extends UF { - public QuickUnionUF(int N) { - super(N); - } - - @Override - public int find(int p) { - while (p != id[p]) - p = id[p]; - return p; - } - - @Override - public void union(int p, int q) { - int pRoot = find(p); - int qRoot = find(q); - if (pRoot != qRoot) - id[pRoot] = qRoot; - } -} -``` - -这种方法可以快速进行 union 操作，但是 find 操作和树高成正比，最坏的情况下树的高度为触点的数目。 - -

- -## 加权 quick-union - -为了解决 quick-union 的树通常会很高的问题，加权 quick-union 在 union 操作时会让较小的树连接较大的树上面。 - -理论研究证明，加权 quick-union 算法构造的树深度最多不超过 logN。 - -

- -```java -public class WeightedQuickUnionUF extends UF { - - // 保存节点的数量信息 - private int[] sz; - - public WeightedQuickUnionUF(int N) { - super(N); - this.sz = new int[N]; - for (int i = 0; i < N; i++) - this.sz[i] = 1; - } - - @Override - public int find(int p) { - while (p != id[p]) - p = id[p]; - return p; - } - - @Override - public void union(int p, int q) { - int i = find(p); - int j = find(q); - if (i == j) return; - if (sz[i] < sz[j]) { - id[i] = j; - sz[j] += sz[i]; - } else { - id[j] = i; - sz[i] += sz[j]; - } - } -} -``` - -## 路径压缩的加权 quick-union - -在检查节点的同时将它们直接链接到根节点，只需要在 find 中添加一个循环即可。 - -## 各种 union-find 算法的比较 - -| 算法 | union | find | -| :---: | :---: | :---: | -| quick-find | N | 1 | -| quick-union | 树高 | 树高 | -| 加权 quick-union | logN | logN | -| 路径压缩的加权 quick-union | 非常接近 1 | 非常接近 1 | - -# 五、排序 +# 三、排序 待排序的元素需要实现 Java 的 Comparable 接口，该接口有 compareTo() 方法，可以用它来判断两个元素的大小关系。 @@ -648,41 +255,49 @@ public abstract class Sort> { 选择出数组中的最小元素，将它与数组的第一个元素交换位置。再从剩下的元素中选择出最小的元素，将它与数组的第二个元素交换位置。不断进行这样的操作，直到将整个数组排序。 -

+选择排序需要 \~N2/2 次比较和 \~N 次交换，它的运行时间与输入无关，这个特点使得它对一个已经排序的数组也需要这么多的比较和交换操作。 + +

```java public class Selection> extends Sort { + @Override public void sort(T[] nums) { int N = nums.length; for (int i = 0; i < N; i++) { int min = i; - for (int j = i + 1; j < N; j++) - if (less(nums[j], nums[min])) + for (int j = i + 1; j < N; j++) { + if (less(nums[j], nums[min])) { min = j; + } + } swap(nums, i, min); } } } ``` -选择排序需要 \~N2/2 次比较和 \~N 次交换，它的运行时间与输入无关，这个特点使得它对一个已经排序的数组也需要这么多的比较和交换操作。 - ## 冒泡排序 -通过从左到右不断交换相邻逆序的相邻元素，在一轮的交换之后，可以让未排序的元素上浮到右侧。 +从左到右不断交换相邻逆序的元素，在一轮的循环之后，可以让未排序的最大元素上浮到右侧。 在一轮循环中，如果没有发生交换，就说明数组已经是有序的，此时可以直接退出。 +以下演示了在一轮循环中，将最大的元素 5 上浮到最右侧。 + +

+ ```java public class Bubble> extends Sort { + @Override public void sort(T[] nums) { int N = nums.length; boolean hasSorted = false; - for (int i = 0; i < N && !hasSorted; i++) { + for (int i = N - 1; i > 0 && !hasSorted; i--) { hasSorted = true; - for (int j = 0; j < N - i - 1; j++) { + for (int j = 0; j < i; j++) { if (less(nums[j + 1], nums[j])) { hasSorted = false; swap(nums, j, j + 1); @@ -695,23 +310,7 @@ public class Bubble> extends Sort { ## 插入排序 -插入排序从左到右进行，每次都将当前元素插入到左侧已经排序的数组中，使得插入之后左部数组依然有序。 - -第 j 元素是通过不断向左比较并交换来实现插入过程：当第 j 元素小于第 j - 1 元素，就将它们的位置交换，然后令 j 指针向左移动一个位置，不断进行以上操作。 - -

- -```java -public class Insertion> extends Sort { - @Override - public void sort(T[] nums) { - int N = nums.length; - for (int i = 1; i < N; i++) - for (int j = i; j > 0 && less(nums[j], nums[j - 1]); j--) - swap(nums, j, j - 1); - } -} -``` +每次都将当前元素插入到左侧已经排序的数组中，使得插入之后左侧数组依然有序。 对于数组 {3, 5, 2, 4, 1}，它具有以下逆序：(3, 2), (3, 1), (5, 2), (5, 4), (5, 1), (2, 1), (4, 1)，插入排序每次只能交换相邻元素，令逆序数量减少 1，因此插入排序需要交换的次数为逆序数量。 @@ -721,6 +320,25 @@ public class Insertion> extends Sort { - 最坏的情况下需要 \~N2/2 比较以及 \~N2/2 次交换，最坏的情况是数组是倒序的； - 最好的情况下需要 N-1 次比较和 0 次交换，最好的情况就是数组已经有序了。 +以下演示了在一轮循环中，将元素 2 插入到左侧已经排序的数组中。 + +

+ +```java +public class Insertion> extends Sort { + + @Override + public void sort(T[] nums) { + int N = nums.length; + for (int i = 1; i < N; i++) { + for (int j = i; j > 0 && less(nums[j], nums[j - 1]); j--) { + swap(nums, j, j - 1); + } + } + } +} +``` + ## 希尔排序 对于大规模的数组，插入排序很慢，因为它只能交换相邻的元素，每次只能将逆序数量减少 1。 @@ -1137,6 +755,511 @@ public class HeapSort> extends Sort { Java 主要排序方法为 java.util.Arrays.sort()，对于原始数据类型使用三向切分的快速排序，对于引用类型使用归并排序。 +# 四、并查集 + +用于解决动态连通性问题，能动态连接两个点，并且判断两个点是否连通。 + +

+ +| 方法 | 描述 | +| :---: | :---: | +| UF(int N) | 构造一个大小为 N 的并查集 | +| void union(int p, int q) | 连接 p 和 q 节点 | +| int find(int p) | 查找 p 所在的连通分量 | +| boolean connected(int p, int q) | 判断 p 和 q 节点是否连通 | + +```java +public abstract class UF { + + protected int[] id; + + public UF(int N) { + id = new int[N]; + for (int i = 0; i < N; i++) { + id[i] = i; + } + } + + public boolean connected(int p, int q) { + return find(p) == find(q); + } + + public abstract int find(int p); + + public abstract void union(int p, int q); +} +``` + +## Quick Find + +可以快速进行 find 操作，即可以快速判断两个节点是否连通。 + +需要保证同一连通分量的所有节点的 id 值相等。 + +但是 union 操作代价却很高，需要将其中一个连通分量中的所有节点 id 值都修改为另一个节点的 id 值。 + +

+ +```java +public class QuickFindUF extends UF { + + public QuickFindUF(int N) { + super(N); + } + + + @Override + public int find(int p) { + return id[p]; + } + + + @Override + public void union(int p, int q) { + + int pID = find(p); + int qID = find(q); + + if (pID == qID) { + return; + } + + for (int i = 0; i < id.length; i++) { + if (id[i] == pID) { + id[i] = qID; + } + } + } +} +``` + +## Quick Union + +可以快速进行 union 操作，只需要修改一个节点的 id 值即可。 + +但是 find 操作开销很大，因为同一个连通分量的节点 id 值不同，id 值只是用来指向另一个节点。因此需要一直向上查找操作，直到找到最上层的节点。 + +

+ +```java +public class QuickUnionUF extends UF { + + public QuickUnionUF(int N) { + super(N); + } + + + @Override + public int find(int p) { + + while (p != id[p]) { + p = id[p]; + } + return p; + } + + + @Override + public void union(int p, int q) { + + int pRoot = find(p); + int qRoot = find(q); + + if (pRoot != qRoot) { + id[pRoot] = qRoot; + } + } +} +``` + +这种方法可以快速进行 union 操作，但是 find 操作和树高成正比，最坏的情况下树的高度为触点的数目。 + +

+ +## 加权 Quick Union + +为了解决 quick-union 的树通常会很高的问题，加权 quick-union 在 union 操作时会让较小的树连接较大的树上面。 + +理论研究证明，加权 quick-union 算法构造的树深度最多不超过 logN。 + +

+ +```java +public class WeightedQuickUnionUF extends UF { + + // 保存节点的数量信息 + private int[] sz; + + + public WeightedQuickUnionUF(int N) { + super(N); + this.sz = new int[N]; + for (int i = 0; i < N; i++) { + this.sz[i] = 1; + } + } + + + @Override + public int find(int p) { + while (p != id[p]) { + p = id[p]; + } + return p; + } + + + @Override + public void union(int p, int q) { + + int i = find(p); + int j = find(q); + + if (i == j) return; + + if (sz[i] < sz[j]) { + id[i] = j; + sz[j] += sz[i]; + } else { + id[j] = i; + sz[i] += sz[j]; + } + } +} +``` + +## 路径压缩的加权 Quick Union + +在检查节点的同时将它们直接链接到根节点，只需要在 find 中添加一个循环即可。 + +## 比较 + +| 算法 | union | find | +| :---: | :---: | :---: | +| Quick Find | N | 1 | +| Quick Union | 树高 | 树高 | +| 加权 Quick Union | logN | logN | +| 路径压缩的加权 Quick Union | 非常接近 1 | 非常接近 1 | + +# 五、栈和队列 + +## 栈 + +```java +public interface MyStack extends Iterable { + + MyStack push(Item item); + + Item pop() throws Exception; + + boolean isEmpty(); + + int size(); + +} +``` + +### 1. 数组实现 + +```java +public class ArrayStack implements MyStack { + + // 栈元素数组，只能通过转型来创建泛型数组 + private Item[] a = (Item[]) new Object[1]; + + // 元素数量 + private int N = 0; + + + @Override + public MyStack push(Item item) { + check(); + a[N++] = item; + return this; + } + + + @Override + public Item pop() throws Exception { + + if (isEmpty()) { + throw new Exception("stack is empty"); + } + + Item item = a[--N]; + + check(); + + // 避免对象游离 + a[N] = null; + + return item; + } + + + private void check() { + + if (N >= a.length) { + resize(2 * a.length); + + } else if (N > 0 && N <= a.length / 4) { + resize(a.length / 2); + } + } + + + /** + * 调整数组大小，使得栈具有伸缩性 + */ + private void resize(int size) { + + Item[] tmp = (Item[]) new Object[size]; + + for (int i = 0; i < N; i++) { + tmp[i] = a[i]; + } + + a = tmp; + } + + + @Override + public boolean isEmpty() { + return N == 0; + } + + + @Override + public int size() { + return N; + } + + + @Override + public Iterator iterator() { + + // 返回逆序遍历的迭代器 + return new Iterator() { + + private int i = N; + + @Override + public boolean hasNext() { + return i > 0; + } + + @Override + public Item next() { + return a[--i]; + } + }; + + } +} +``` + +### 2. 链表实现 + +需要使用链表的头插法来实现，因为头插法中最后压入栈的元素在链表的开头，它的 next 指针指向前一个压入栈的元素，在弹出元素时就可以通过 next 指针遍历到前一个压入栈的元素从而让这个元素称为新的栈顶元素。 + +```java +public class ListStack implements MyStack { + + private Node top = null; + private int N = 0; + + + private class Node { + Item item; + Node next; + } + + + @Override + public MyStack push(Item item) { + + Node newTop = new Node(); + + newTop.item = item; + newTop.next = top; + + top = newTop; + + N++; + + return this; + } + + + @Override + public Item pop() throws Exception { + + if (isEmpty()) { + throw new Exception("stack is empty"); + } + + Item item = top.item; + + top = top.next; + N--; + + return item; + } + + + @Override + public boolean isEmpty() { + return N == 0; + } + + + @Override + public int size() { + return N; + } + + + @Override + public Iterator iterator() { + + return new Iterator() { + + private Node cur = top; + + + @Override + public boolean hasNext() { + return cur != null; + } + + + @Override + public Item next() { + Item item = cur.item; + cur = cur.next; + return item; + } + }; + + } +} +``` + +## 队列 + +First-In-First-Out + +下面是队列的链表实现，需要维护 first 和 last 节点指针，分别指向队首和队尾。 + +这里需要考虑 first 和 last 指针哪个作为链表的开头。因为出队列操作需要让队首元素的下一个元素成为队首，所以需要容易获取下一个元素，而链表的头部节点的 next 指针指向下一个元素，因此可以让 first 指针链表的开头。 + +```java +public interface MyQueue extends Iterable { + + int size(); + + boolean isEmpty(); + + MyQueue add(Item item); + + Item remove() throws Exception; +} +``` + +```java +public class ListQueue implements MyQueue { + + private Node first; + private Node last; + int N = 0; + + + private class Node { + Item item; + Node next; + } + + + @Override + public boolean isEmpty() { + return N == 0; + } + + + @Override + public int size() { + return N; + } + + + @Override + public MyQueue add(Item item) { + + Node newNode = new Node(); + newNode.item = item; + newNode.next = null; + + if (isEmpty()) { + last = newNode; + first = newNode; + } else { + last.next = newNode; + last = newNode; + } + + N++; + return this; + } + + + @Override + public Item remove() throws Exception { + + if (isEmpty()) { + throw new Exception("queue is empty"); + } + + Node node = first; + first = first.next; + N--; + + if (isEmpty()) { + last = null; + } + + return node.item; + } + + + @Override + public Iterator iterator() { + + return new Iterator() { + + Node cur = first; + + + @Override + public boolean hasNext() { + return cur != null; + } + + + @Override + public Item next() { + Item item = cur.item; + cur = cur.next; + return item; + } + }; + } +} +``` + + + + + # 六、查找 符号表（Symbol Table）是一种存储键值对的数据结构，可以支持快速查找操作。 diff --git a/pics/1a2f2998-d0da-41c8-8222-1fd95083a66b.png b/pics/1a2f2998-d0da-41c8-8222-1fd95083a66b.png new file mode 100644 index 0000000000000000000000000000000000000000..c459230500a25dbeaa7389a7cc4b92f985833f45 GIT binary patch literal 8192 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 A^#A|> literal 0 HcmV?d00001 diff --git a/pics/2a8e1442-2381-4439-a83f-0312c8678b1f.png b/pics/2a8e1442-2381-4439-a83f-0312c8678b1f.png new file mode 100644 index 0000000000000000000000000000000000000000..a97e49a6b73574b2e583e3bde10f56bec9afda1f GIT binary patch literal 5120 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 R2ZAH8+@Pap{~PQ7e*xc4lfeK0 literal 0 HcmV?d00001 diff --git a/pics/37e79a32-95a9-4503-bdb1-159527e628b8.png b/pics/37e79a32-95a9-4503-bdb1-159527e628b8.png new file mode 100644 index 0000000000000000000000000000000000000000..3b05b25b963303548a15d6917283fccdf667e32d GIT binary patch literal 8192 zcmd^EeOS_0-?xok%*x8UtkhU`PuonLIWtos%CcrEmDALel~b2aC>2SJehXLDGFgwM zWhyu;$=B47d}XbY5?@xLq=u{vO%O;BNM4_V?Y^H~*RE%O+%N69?&l9Kub&(ahwnMx z&)YeR4)R|(f7N_5GqZ)ecKYo#Gn*A+X7*mnygA@M=w9&+@Ml)aUjMCT)!nw^-~kqo z3PhQi)lw{U2WNw4^CLUMQ_RekrkY-}hU4JJ%*^1HyZlfg$D$>C!MQ>L-#975T+IC7 zFUhHEFYKlGt@`MJ{k6ptyS|So+3)+wb=8){>-TqDytq1?e(gd-yJ5@P!Tm{2dIqE6 zuvKpE?eK@A`3G}z#iQ3WgJ>Fbzk>bTu7GB{mGh*g$nTMJ^ z&z^3Ef-U>t4DCJGl8|pcAkSayhn_{A_wkm+@8(VJLfr`5_-fH=pReL1IJ7^usx#lO9mM`na&brY$^(27bM$*FYcBrbwA(w;EVi;p9`XB;T zWyPJ3IyDVr1fiW^%SNrZoBy8cLW##VB zX54xw3Y4CnKE>XXHu>U#ND^~EReLe9^uSt3J0vJq`(yEVyrcssSeHpuO$MU(N3gyP4)mlTbgp@M>~8c>A(^3Nh0>W@M z8Q*G@V|^Vz64lz>VUBDkq{U=(io>=>WGvwvN1UFY;B^|Y zBW8X=I-=w1IYX`5ifdfV6@Q(5G~!zt_I78CjXhmomerb}4$6tCMDZDkyf4W_=b6b^ zhSGR37(Y~(8PQ#m>~blk+{aKmTlus$hHv58@^h=QKQfnElE-$T^OkbGoUCzP2isNk z58c}4J$tAj>T6mVzW_ENL0~>^nH;=_aAEY8_F@z55c%f_J&r&oeqmAiJ{BI zeXHJIZ+H-n#vLaYd`&0N_1iyDtx#Ia_6rz6te;~M*5OOaAME?}ZCajkPZu%lQ?6#@ zVbeGD{aNv6*u_gq3}ZLMn0YW|JJ{^g3lbnywzHp@`S=uHuCYE@XDCe`-C)l(+8T)G z5G5stm3{aMZTJ}spGT{%g2k6o zQ_hdaB&RzzrHpka2EDGe^H0wf)-KW?o2?vmpx49j3BAaAvFH6BsXY(6je%@qh*_jE2H(@?^HUTt=)Dn7gkFHh?;Rt2H)M#(} zukvXwx0d$4KX*|oQuo}lnWR;nPop3W$JAE^x;P1)7DaCQG5W-`Q2IOzE^RaFWx+pf z?&lK(B>wxBKDW|Bes)1ceeoe(Xg93rL9)^~oAgs<$YmirP-yGRw4ZLl@F&ebUJ&q~ z`LJUpHz3~y@8slEDv-;Q37V;K5ot+eM1&|B(krE)N>#(~+T;agK}7|+`ZVaiK{tjB zj}No`*^28o1KMeh^s_Ud zEeS$fy*;b{_(Z4Yi7u@5Z;}i#30aHm%7+E=j+o)PSWaihBnE@(L_-L*`)C zZRDPITdo^IRcDEKLu=Mbn`;nrdxx6viR$}S!KrKtyyk=~Zes|#tf$s(4#Q`3Jf#9z z{6A=4>OenRM~(=(Xt?%DfXa6JOjt`9=fBciGK%v6{_k!e$cCjqo_wEA0E%SSZcd6E zX;dKjRKrx6NR5r#HXEM0(|PrhtkqoVwAyb`f-X%Xg9vi(l^z^ zug6Ex=^?PHT|*v(i0fScBJ_&5NQR)44JG)@>5ZdR-m{?fDF>tr9t2@A6A_ zt7FsU_IgY2 z#K>(gBJ+v5Nwy<2fzb}qV_^&=rJDKb)*?HuLDxY%xfuKoqQYh$x(u4dNE&L84#ZOf zwHW_ES8e{@-pJboI$2{h7tM*}Qgq?)NA_W>6OH~l^>7A`@cNg#j|A6)WL=(uN^k}o z=tgxc6=N#5XLNemEznbsW)BJaF)cCEcLYWP61UR2nidTSiBDgR-MuoF588)&o(D~> zvfmPJ#qDxc*d-XTsl)-^S(?Ktd%8-%G;vA^QXU`t&v(kdtmRyynz%sqWuFjULy|P9 z%C_1{+j}?nl{pwI`N$iWtVM&8m}iYCV?f&BD=I1y!=RxZD?`3nZvM`!L&%PUhY#QM zKK7dC(I9Vm4JUu57>0~`sWt1(c4mA}vGkE6_4ba?Vv4+_1#Dzu&tJfZ=wr`MNiX=X z9zP+^rKSRiXxO28GeQY2&L5*fCnQ(4q7O%#C#3sNbvV^j^0!(FnZ{(KtWs@1+vwoH=g*Ql5%O?OG64A=}Ak0 za`;REV+4{n2mFUmQn_c2QZD51rxj!VER*^GY}E&ZNb&+8LvFGsc`O4XV_KNs%p4|G z5FxJ1fjj6{Qg-vP$wNxjL%m)GQGHy6(>M9>MyIgq$|!vja3w&d4;A^OKUtqjg$(IR zm78>Gycf_}ll+k99H7ZIqLSV@BmKV5Kr8#_*pAP*hs~*UBE&IKbK1ny$4LWqLQ$G* zm~ZDxysc3>SNrtKFPBkD1jW7?<%0Twg)6zh?v||%2t`xiNJOKu z)X!3S@YEBU!^#YMz%nyz#X81b&PDhM$r7CS{m7gOTfr2M*<{#s`uLg^AJcoso<1cv z88nxNfol4h1YogGHZ%eA*b|E8JmO=1)O()+90p6(OZ2C{$ItSwftIY0PcB-n{azytvN!y1H~;z75Ogu)WsBe}FZ z#m&O747D_nbdob)#4;#r9^JrYs0QL|+P3V5Hhc#h+fwdTDged-R1xCFMDT)bhP@)d zh+&zUPWPS=R$RSFIuI3N!OGay%rnvO!ZmPQ8aluy03ER3dJSF34qyR6*xW2_N=(M` zQ+j;)8M4+e{a}|#V2HY^SjV*I8dV-uRZyqU>vHs{;=)RVRX$MUM9aut=jJeD8hZ=aqP z-`ls^_&vn-y1#*%pG{Ly)Wma(#NV?n5ZG(^d8;Mn_%m^sL5qQ3l~dg*f#@2R!HX`* z@s_@d&X6!fe;;YQ;~CL-hV$Tnb~rE8J7)r^UCI^L=z@bd)Lnr{S0R6#q~`NlC);iM zWM?n`meD$?CB>VLz7XN2IU5i!YN&s{jQoAmMnpwPx~WK{rpPNLu5OSN6P~X7)i5PL z?#IGMT%ud{w~{KGlZ73FeS(HPbC%Jzzw?mn-(=F>#kAi8LU?jLfDat$D`rc}vmykk zi740~n)94{b6+mhFNODZ7yCv64)7*O4=7c&GZB&qH?%G@B1o6(7+i2lTHk}H7)G>T zvc3Z}2mh3Xb$_*?!MuE65XSg7`;Olqn7=!rPyNsoTdyZcg0@!g)K_SwA&+_cHdper zwsZ&>lRn9CYqK|T>MNx#YP)ipM`1%&n#TV1%CI=5EF+{gO*PV_Em-uCZ5)c zcu8?rP|m#jQ;iCi}-(;{~9f=P3G{8qK6F|xa#H|6;cL&l7fkFAj!}Yxk)x<7R z(CPW2lkd-Ms)}R=<$NeUg*`)Cl%6y%;fG3Eo<#%lZov2LtGG*lRx;JVD6HTKJo94V z_ZFi_vQ~9dhO{w08GGJ?E*xB;0qKp&b3h^vLuH)#%kw@R{QE9Bdtu(t7 zJ4abW7#^3lX{Ec+oE|jiXg2uX?TtRx47hV_;9CHP;ytIf-x^T5zNfFFo&&$&3zMG9 zjadhu=HRB;t3e#~p<LZ(Kb>1R5)6(RE6 z=HT_GkKJ8vB9$1iVAle@qPkMKrlaXdX=cPB4M-(}5Tp4NtuO{^Bs~V^f^{TbpB-&l zif-Z2yTj#|#y%9!w%<(e?YXC1Zudh;W`W)vYoZPXkLBJ)WFB#HqrZ`u_FA}WTO6(bsb>a zXoYzRw4`Tq-V8O_)IiT{lGd|m1vx>iPK$=!CU7p*Pbv21DZ6h29DVB=O30h61 zzuZ;-Gs!SLX3B5m_F>JWN+;K}m=EZ2iB{ZyX~^;iyZHyP&kt+J#Fq~*V6`d{rYt*JI8J&TF0uTeE#E7{|bx%h%g%Rv|J`^8078v`fVbUyc@vS&0&BfZ<`D!Bp@nR z(s%$Lpj3L-31tQ5a~94dNVgq-2~R|OMi^c2ov1Fv={4kt?y_WXQ`hXNe6Yre-ir+C zAbLhzol&;}dl&=CD!{LapNrRcJv_nm^+Q|QZbIt|z;%Wxu~5pgPah9k(rDP)trJF= z#4X3|V$8}!G{%(Rft-|D7!d3;>8I8ydI+vOo2+iX>t1nra}uI1DmZ3SFUT(e&qeO7op2>^om|pi;P^<5Z-}FN3`7!=#Y<;luGT zd@1~MfY{=hRJU=gSd49!G(2hyHM~dDeYi!E=;=NKjGlU|iy}UUc}ST4h)Kj1G z%ZUM`<#MiA2AnFM34)@;;(XWR&n@`sHg&5s(-J{H5eyja@nRIi*anQ-M66)}ru^uX1-(BeC9xef4j*lUEGDp9uqhoty^WO}3 st+eBk)1Q&#{PyDcOtlun!6vXJM`t|+_vL20wg>rDZ~cP&f205Z8~z7fb^rhX literal 0 HcmV?d00001 From 6478389db1ccb3cbab94c5478d3955ad6e4e7898 Mon Sep 17 00:00:00 2001 From: CyC2018 <1029579233@qq.com> Date: Wed, 15 Aug 2018 22:16:30 +0800 Subject: [PATCH 03/24] auto commit --- notes/算法.md | 92 ++++++++++++------ pics/0157d362-98dd-4e51-ac26-00ecb76beb3e.png | Bin 0 -> 14336 bytes pics/220790c6-4377-4a2e-8686-58398afc8a18.png | Bin 0 -> 6144 bytes pics/864bfa7d-1149-420c-a752-f9b3d4e782ec.png | Bin 0 -> 16384 bytes pics/f8047846-efd4-42be-b6b7-27a7c4998b51.png | Bin 0 -> 12288 bytes 5 files changed, 61 insertions(+), 31 deletions(-) create mode 100644 pics/0157d362-98dd-4e51-ac26-00ecb76beb3e.png create mode 100644 pics/220790c6-4377-4a2e-8686-58398afc8a18.png create mode 100644 pics/864bfa7d-1149-420c-a752-f9b3d4e782ec.png create mode 100644 pics/f8047846-efd4-42be-b6b7-27a7c4998b51.png diff --git a/notes/算法.md b/notes/算法.md index e404a3c8..f0e889db 100644 --- a/notes/算法.md +++ b/notes/算法.md @@ -347,25 +347,32 @@ public class Insertion> extends Sort { 希尔排序使用插入排序对间隔 h 的序列进行排序。通过不断减小 h，最后令 h=1，就可以使得整个数组是有序的。 -

+

```java public class Shell> extends Sort { + @Override public void sort(T[] nums) { + int N = nums.length; int h = 1; - while (h < N / 3) - h = 3 * h + 1; // 1, 4, 13, 40, ... + + while (h < N / 3) { + h = 3 * h + 1; // 1, 4, 13, 40, ... + } while (h >= 1) { - for (int i = h; i < N; i++) - for (int j = i; j >= h && less(nums[j], nums[j - h]); j -= h) + for (int i = h; i < N; i++) { + for (int j = i; j >= h && less(nums[j], nums[j - h]); j -= h) { swap(nums, j, j - h); + } + } h = h / 3; } } } + ``` 希尔排序的运行时间达不到平方级别，使用递增序列 1, 4, 13, 40, ... 的希尔排序所需要的比较次数不会超过 N 的若干倍乘于递增序列的长度。后面介绍的高级排序算法只会比希尔排序快两倍左右。 @@ -374,7 +381,7 @@ public class Shell> extends Sort { 归并排序的思想是将数组分成两部分，分别进行排序，然后归并起来。 -

+

### 1. 归并方法 @@ -385,21 +392,28 @@ public abstract class MergeSort> extends Sort { protected T[] aux; + protected void merge(T[] nums, int l, int m, int h) { + int i = l, j = m + 1; - for (int k = l; k <= h; k++) - aux[k] = nums[k]; // 将数据复制到辅助数组 + for (int k = l; k <= h; k++) { + aux[k] = nums[k]; // 将数据复制到辅助数组 + } for (int k = l; k <= h; k++) { - if (i > m) + if (i > m) { nums[k] = aux[j++]; - else if (j > h) + + } else if (j > h) { nums[k] = aux[i++]; - else if (aux[i].compareTo(nums[j]) <= 0) - nums[k] = aux[i++]; // 先进行这一步，保证稳定性 - else + + } else if (aux[i].compareTo(nums[j]) <= 0) { + nums[k] = aux[i++]; // 先进行这一步，保证稳定性 + + } else { nums[k] = aux[j++]; + } } } } @@ -407,10 +421,13 @@ public abstract class MergeSort> extends Sort { ### 2. 自顶向下归并排序 -

+将一个大数组分成两个小数组去求解。 + +因为每次都将问题对半分成两个子问题，而这种对半分的算法复杂度一般为 O(NlogN)，因此该归并排序方法的时间复杂度也为 O(NlogN)。 ```java public class Up2DownMergeSort> extends MergeSort { + @Override public void sort(T[] nums) { aux = (T[]) new Comparable[nums.length]; @@ -418,8 +435,9 @@ public class Up2DownMergeSort> extends MergeSort { } private void sort(T[] nums, int l, int h) { - if (h <= l) + if (h <= l) { return; + } int mid = l + (h - l) / 2; sort(nums, l, mid); sort(nums, mid + 1, h); @@ -428,23 +446,27 @@ public class Up2DownMergeSort> extends MergeSort { } ``` -因为每次都将问题对半分成两个子问题，而这种对半分的算法复杂度一般为 O(NlogN)，因此该归并排序方法的时间复杂度也为 O(NlogN)。 - ### 3. 自底向上归并排序 先归并那些微型数组，然后成对归并得到的微型数组。 ```java public class Down2UpMergeSort> extends MergeSort { + @Override public void sort(T[] nums) { + int N = nums.length; aux = (T[]) new Comparable[N]; - for (int sz = 1; sz < N; sz += sz) - for (int lo = 0; lo < N - sz; lo += sz + sz) + + for (int sz = 1; sz < N; sz += sz) { + for (int lo = 0; lo < N - sz; lo += sz + sz) { merge(nums, lo, lo + sz - 1, Math.min(lo + sz + sz - 1, N - 1)); + } + } } } + ``` ## 快速排序 @@ -454,10 +476,11 @@ public class Down2UpMergeSort> extends MergeSort { - 归并排序将数组分为两个子数组分别排序，并将有序的子数组归并使得整个数组排序； - 快速排序通过一个切分元素将数组分为两个子数组，左子数组小于等于切分元素，右子数组大于等于切分元素，将这两个子数组排序也就将整个数组排序了。 -

+

```java public class QuickSort> extends Sort { + @Override public void sort(T[] nums) { shuffle(nums); @@ -482,9 +505,9 @@ public class QuickSort> extends Sort { ### 2. 切分 -取 a[lo] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于等于它的元素，交换这两个元素，并不断进行这个过程，就可以保证左指针 i 的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。当两个指针相遇时，将切分元素 a[lo] 和 a[j] 交换位置。 +取 a[l] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于等于它的元素，交换这两个元素。不断进行这个过程，就可以保证左指针 i 的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。当两个指针相遇时，将切分元素 a[l] 和 a[j] 交换位置。 -

+

```java private int partition(T[] nums, int l, int h) { @@ -528,20 +551,23 @@ private int partition(T[] nums, int l, int h) { ```java public class ThreeWayQuickSort> extends QuickSort { + @Override protected void sort(T[] nums, int l, int h) { - if (h <= l) + if (h <= l) { return; + } int lt = l, i = l + 1, gt = h; T v = nums[l]; while (i <= gt) { int cmp = nums[i].compareTo(v); - if (cmp < 0) + if (cmp < 0) { swap(nums, lt++, i++); - else if (cmp > 0) + } else if (cmp > 0) { swap(nums, i, gt--); - else + } else { i++; + } } sort(nums, l, lt - 1); sort(nums, gt + 1, h); @@ -555,24 +581,28 @@ public class ThreeWayQuickSort> extends QuickSort { 可以利用这个特性找出数组的第 k 个元素。 +该算法是线性级别的，因为每次能将数组二分，那么比较的总次数为 (N+N/2+N/4+..)，直到找到第 k 个元素，这个和显然小于 2N。 + ```java public T select(T[] nums, int k) { int l = 0, h = nums.length - 1; while (h > l) { int j = partition(nums, l, h); - if (j == k) + + if (j == k) { return nums[k]; - else if (j > k) + + } else if (j > k) { h = j - 1; - else + + } else { l = j + 1; + } } return nums[k]; } ``` -该算法是线性级别的。因为每次能将数组二分，那么比较的总次数为 (N+N/2+N/4+..)，直到找到第 k 个元素，这个和显然小于 2N。 - ## 堆排序 ### 1. 堆 diff --git a/pics/0157d362-98dd-4e51-ac26-00ecb76beb3e.png b/pics/0157d362-98dd-4e51-ac26-00ecb76beb3e.png new file mode 100644 index 0000000000000000000000000000000000000000..fc0999f997288999ff38615db17d5ecc916d2d42 GIT binary patch literal 14336 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 MmF_+N|6=_AFI7~~0{{R3 literal 0 HcmV?d00001 diff --git a/pics/220790c6-4377-4a2e-8686-58398afc8a18.png b/pics/220790c6-4377-4a2e-8686-58398afc8a18.png new file mode 100644 index 0000000000000000000000000000000000000000..7910525710e724735de28351f6ac0c346eed7f96 GIT binary patch literal 6144 zcmeI0dpJ~U-^ZuDRZ7YsQ%*^Ra>&l1DMBWb$oYJ>J1}w#V=&B2F%h%T4%tpkLyp5p z3?e-3l9a>D4in=PF=H4L1{uS=OV{;0SJ(Ugy`SfOuj~C|4(qqpy6^A0f4}?we(sfG zXJanDS8gu|1QNHnV&(t>?cf3bUyAMmzSAqcOn{#qkq+ii5V==j7B~=rn_8QKK(!fS zf@?d0<2|>pxJQCOQi$!(jxm3w7!U}2*TT%yDaMCWIM*lcI^IcWe0jW32!w&Y7)GU?-MdlbZJ8N%+V}+R_TcTgNH_O#>(n%z2Fq8Ym$1pNvZYWwi z4pT?3VlG>>-QvDjeOkBL9ftO=cCX_K!vO_$u@VL#(8ZsQ0ut_sTx4yFxL~`*{zcU2@loE}qloL0xG@h2)Lm27q6iVPiztmh${S3eitU4DsEM|o z5iN8RAvS_>KEFz!E|{{?Oj&P^iMCSy{SqF1xrdn>)M|`m+R#a^+VncOZS=RVpC_29 z_p_-r-Yqi?!9$a!Hihh62aXi@@p-eMbh5Ym26W?1)@Vy~O9%eY?mGV-x#+34X%m>9 zH&9mo*^s>r%1ZcECu>%jO<{yDX1zrIe8f#;HJdOVzns<*F>U#E8TM3@$YnIvAjugD z=cNQz!S+hTHYhrYYtow4vCy9kW0sUV62eCk_o$14CVtE7K`kZ(QA3#pW4E`Ln^d8I57lzSvF5++elm zVClkWOH1PJ1H0DnDh57^K{=EsVSv+GiHf?tfjGH~k@}@jQ}XjOO=~ zYyCbvk}(c)P$ACER6Ca0EWAEo((SM3QtdIlYu{nJ4Gf}9EA-+A3H~r8h%r+2<}?D` zCkEDhm+suDRU1@li@s0(xVf>mdo4)S1q#STbK->GrZPrTq}4{&#<5(3=!Jrik1PIX zJ|+X>NufrWbGVfxb%cz+j}$-J`W9d8!fJX)MsW4zDPq>jK5ypbx)Xup|G4{e-RumN znP-uWBX?@Rdkb#WaeyE>h)y1gek$*nhFHdG9~*?yyAv)aw9RCFnhWiFY^48rR?<{f zH`WEZhQ2c1hStpu@@yk0>D;_;2;@U!Lth>@W}}HC8&VVvkxf9t{FjywU2?v6Bvomp z@>lHU3Vi~8Jw><$?|bZRSyq&#g6Oi`mXj)@u~(^3!&wS-vhw`EF@vq$vzY_qwP;5_3FtNP4!o~ZCXEauEMni(2A9Cd%##wqxG`Gr{9q?XmrOigKki7Gp!JtK^s^3R+YH#8_LHv7( zX7Frxp1wvzey>Fcq3kH;SGbxz~>bA63}NhS8_ zO9v6>dVUhlj|5IP*bd;x`HI$Dey=ON+y`Fwa#7QRmG^w`_%Vv9lfGkIWIm{m4AbwQ(>I} zS_rIw{k7U~Reg^)o#^7U5lM2FB}L;~5l>lCV>VG^E}! z>f+q`mlu)D1cHV-P}7(l1(%z^#ie!UqMz-@0~V97THPhh|1jTDpm(x&UzFgJXe96EYrR;Z zu?q#Rj2OND&2@LwyoVEMjkY;y+`&$clt38*9$DOR`|2ajTXi~KG~r;StxO28-WN&o zJ;PcDW7m3`>TM-!rJ458{j8^$TUmIVx{n!m< z1gx`i97N4GYEw)-B7bESTxYx&Sk(PQTdUlRFVRQKN=pZ1*#u`#kuo^S0NF9APvN_1 zr)uarOQJL!A5lqizF3qOTscBXgUFm>6k({(wYD4hZtLIO9nRMv4ENz5fRY z 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 T0%l`IhW?uH|MUNU&j0@c$L*Xz literal 0 HcmV?d00001 diff --git a/pics/864bfa7d-1149-420c-a752-f9b3d4e782ec.png b/pics/864bfa7d-1149-420c-a752-f9b3d4e782ec.png new file mode 100644 index 0000000000000000000000000000000000000000..72cc988f12ebb575ffabf9fee836aa7d23aad0ca GIT binary patch literal 16384 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 u!{>j;kBD!1i^O9ra$L^5+8YC3R-;bpnH literal 0 HcmV?d00001 diff --git a/pics/f8047846-efd4-42be-b6b7-27a7c4998b51.png b/pics/f8047846-efd4-42be-b6b7-27a7c4998b51.png new file mode 100644 index 0000000000000000000000000000000000000000..86e2294f478af16f2bc278d3e30012bb4a7205b3 GIT binary patch literal 12288 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 Xh1GdMIc$b{rk6@DUi-)Y`uYDahPHTa literal 0 HcmV?d00001 From d655c65eff7d1914e961d0e414edf7df735b979c Mon Sep 17 00:00:00 2001 From: CyC2018 <1029579233@qq.com> Date: Wed, 15 Aug 2018 22:23:46 +0800 Subject: [PATCH 04/24] auto commit --- notes/算法.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/notes/算法.md b/notes/算法.md index f0e889db..8ce9682d 100644 --- a/notes/算法.md +++ b/notes/算法.md @@ -770,14 +770,14 @@ public class HeapSort> extends Sort { | 算法 | 稳定 | 时间复杂度 | 空间复杂度 | 备注 | | :---: | :---: |:---: | :---: | :---: | -| 选择排序 | no | N2 | 1 | | -| 冒泡排序 | yes | N2 | 1 | | -| 插入排序 | yes | N \~ N2 | 1 | 时间复杂度和初始顺序有关 | -| 希尔排序 | no | N 的若干倍乘于递增序列的长度 | 1 | | -| 快速排序 | no | NlogN | logN | | -| 三向切分快速排序 | no | N \~ NlogN | logN | 适用于有大量重复主键| -| 归并排序 | yes | NlogN | N | | -| 堆排序 | no | NlogN | 1 | | | +| 选择排序 | :heavy_check_mark:| N2 | 1 | | +| 冒泡排序 | :heavy_check_mark: | N2 | 1 | | +| 插入排序 | :heavy_check_mark: | N \~ N2 | 1 | 时间复杂度和初始顺序有关 | +| 希尔排序 | :heavy_multiplication_x: | N 的若干倍乘于递增序列的长度 | 1 | | +| 快速排序 | :heavy_multiplication_x: | NlogN | logN | | +| 三向切分快速排序 | :heavy_multiplication_x: | N \~ NlogN | logN | 适用于有大量重复主键| +| 归并排序 | :heavy_check_mark: | NlogN | N | | +| 堆排序 | :heavy_multiplication_x: | NlogN | 1 | | | 快速排序是最快的通用排序算法，它的内循环的指令很少，而且它还能利用缓存，因为它总是顺序地访问数据。它的运行时间近似为 \~cNlogN，这里的 c 比其他线性对数级别的排序算法都要小。使用三向切分快速排序，实际应用中可能出现的某些分布的输入能够达到线性级别，而其它排序算法仍然需要线性对数时间。 From a14c6fd5fdf082be7b9307013b7b1ec7b9958003 Mon Sep 17 00:00:00 2001 From: CyC2018 <1029579233@qq.com> Date: Wed, 15 Aug 2018 22:27:28 +0800 Subject: [PATCH 05/24] auto commit --- notes/算法.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/notes/算法.md b/notes/算法.md index 8ce9682d..30467b42 100644 --- a/notes/算法.md +++ b/notes/算法.md @@ -770,14 +770,14 @@ public class HeapSort> extends Sort { | 算法 | 稳定 | 时间复杂度 | 空间复杂度 | 备注 | | :---: | :---: |:---: | :---: | :---: | -| 选择排序 | :heavy_check_mark:| N2 | 1 | | -| 冒泡排序 | :heavy_check_mark: | N2 | 1 | | -| 插入排序 | :heavy_check_mark: | N \~ N2 | 1 | 时间复杂度和初始顺序有关 | -| 希尔排序 | :heavy_multiplication_x: | N 的若干倍乘于递增序列的长度 | 1 | | -| 快速排序 | :heavy_multiplication_x: | NlogN | logN | | -| 三向切分快速排序 | :heavy_multiplication_x: | N \~ NlogN | logN | 适用于有大量重复主键| -| 归并排序 | :heavy_check_mark: | NlogN | N | | -| 堆排序 | :heavy_multiplication_x: | NlogN | 1 | | | +| 选择排序 | √| N2 | 1 | | +| 冒泡排序 | √ | N2 | 1 | | +| 插入排序 | √ | N \~ N2 | 1 | 时间复杂度和初始顺序有关 | +| 希尔排序 | × | N 的若干倍乘于递增序列的长度 | 1 | | +| 快速排序 | × | NlogN | logN | | +| 三向切分快速排序 | × | N \~ NlogN | logN | 适用于有大量重复主键| +| 归并排序 | √ | NlogN | N | | +| 堆排序 | × | NlogN | 1 | | | 快速排序是最快的通用排序算法，它的内循环的指令很少，而且它还能利用缓存，因为它总是顺序地访问数据。它的运行时间近似为 \~cNlogN，这里的 c 比其他线性对数级别的排序算法都要小。使用三向切分快速排序，实际应用中可能出现的某些分布的输入能够达到线性级别，而其它排序算法仍然需要线性对数时间。 From aa4dfe2ea77394aacbd002eaffb55c03cf2575f8 Mon Sep 17 00:00:00 2001 From: CyC2018 <1029579233@qq.com> Date: Wed, 15 Aug 2018 22:38:23 +0800 Subject: [PATCH 06/24] auto commit --- notes/Java 虚拟机.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/notes/Java 虚拟机.md b/notes/Java 虚拟机.md index 891211da..a4a4ba12 100644 --- a/notes/Java 虚拟机.md +++ b/notes/Java 虚拟机.md @@ -45,7 +45,7 @@ 可以通过 -Xss 这个虚拟机参数来指定每个线程的 Java 虚拟机栈内存大小： ```java -java -Xss=512M HackTheJava +java -Xss512M HackTheJava ``` 该区域可能抛出以下异常： @@ -81,7 +81,7 @@ java -Xss=512M HackTheJava 可以通过 -Xms 和 -Xmx 两个虚拟机参数来指定一个程序的堆内存大小，第一个参数设置初始值，第二个参数设置最大值。 ```java -java -Xms=1M -Xmx=2M HackTheJava +java -Xms1M -Xmx2M HackTheJava ``` ## 方法区 From 3da8d737e631103d1415590d223aa2b61a920a5a Mon Sep 17 00:00:00 2001 From: CyC2018 <1029579233@qq.com> Date: Wed, 15 Aug 2018 22:55:12 +0800 Subject: [PATCH 07/24] auto commit --- notes/Java 基础.md | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/notes/Java 基础.md b/notes/Java 基础.md index adf899fa..b329e0bc 100644 --- a/notes/Java 基础.md +++ b/notes/Java 基础.md @@ -576,9 +576,22 @@ SuperExtendExample.func() ## 重写与重载 -- 重写（Override）存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。子类的返回值类型要等于或者小于父类的返回值； +**1. 重写（Override）** -- 重载（Overload）存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。应该注意的是，返回值不同，其它都相同不算是重载。 +存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。 + +为了满足里式替换原则，重写有有以下两个限制： + +- 子类方法的访问权限必须大于等于父类方法； +- 子类方法的返回类型必须是父类方法返回类型或为其子类型。 + +使用 @Override 注解，可以让编译器帮忙检查是否满足上面的两个限制条件。 + +**2. 重载（Overload）** + +存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。 + +应该注意的是，返回值不同，其它都相同不算是重载。 # 五、Object 通用方法 From 56a271b4337ec2f25f46bc3d79267acb7d62946d Mon Sep 17 00:00:00 2001 From: wangxujian-laixuzhui <33362969+wangxujian-laixuzhui@users.noreply.github.com> Date: Thu, 16 Aug 2018 08:49:34 +0800 Subject: [PATCH 08/24] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E7=BA=BF=E7=A8=8B?= =?UTF-8?q?=E4=B8=89=E7=A7=8D=E5=AE=9E=E7=8E=B0=E6=96=B9=E5=BC=8F=E7=9A=84?= =?UTF-8?q?=E6=AF=94=E8=BE=83?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- notes/Java 并发.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/notes/Java 并发.md b/notes/Java 并发.md index 9cd5955b..1a1bacc0 100644 --- a/notes/Java 并发.md +++ b/notes/Java 并发.md @@ -182,7 +182,10 @@ public static void main(String[] args) { mt.start(); } ``` - +## 三种实现方式的比较 +- 实现Runnable接又可以避免Java单继承特性而带来的局限;增强程序的健壮性，代码能够被多个线程共享，代码与数据是独立的;适合多个相同程序代码的线程区处理同一资源的情况。 +- 继承Thread类和实现Runnable方法启动线 程都是使用start方法，然后JVM虚拟机将此线程放到就绪队列中，如果有处理机可用， 则执行run方法。 +- 实现Callable接又要实现call方法，并且线 程执行完毕后会有返回值。其他的两种都是 重写run方法，没有返回值。 ## 实现接口 VS 继承 Thread 实现接口会更好一些，因为： From 9f1e252e36d7f9a35222b72ecadcd25fbb73b917 Mon Sep 17 00:00:00 2001 From: CyC2018 <1029579233@qq.com> Date: Thu, 16 Aug 2018 22:34:21 +0800 Subject: [PATCH 09/24] auto commit --- notes/MySQL.md | 314 ++++++++++++++++++++-------------------- notes/Redis.md | 6 +- notes/数据库系统原理.md | 86 +++++------ 3 files changed, 201 insertions(+), 205 deletions(-) diff --git a/notes/MySQL.md b/notes/MySQL.md index 7ac9685f..54067977 100644 --- a/notes/MySQL.md +++ b/notes/MySQL.md @@ -1,22 +1,23 @@ -* [一、存储引擎](#一存储引擎) +* [一、索引](#一索引) + * [B+ Tree 原理](#b-tree-原理) + * [MySQL 索引](#mysql-索引) + * [索引优化](#索引优化) + * [索引的优点](#索引的优点) + * [索引的使用场景](#索引的使用场景) +* [二、查询性能优化](#二查询性能优化) + * [使用 Explain 进行分析](#使用-explain-进行分析) + * [优化数据访问](#优化数据访问) + * [重构查询方式](#重构查询方式) +* [三、存储引擎](#三存储引擎) * [InnoDB](#innodb) * [MyISAM](#myisam) * [比较](#比较) -* [二、数据类型](#二数据类型) +* [四、数据类型](#四数据类型) * [整型](#整型) * [浮点数](#浮点数) * [字符串](#字符串) * [时间和日期](#时间和日期) -* [三、索引](#三索引) - * [B+ Tree 原理](#b-tree-原理) - * [索引分类](#索引分类) - * [索引的优点](#索引的优点) - * [索引优化](#索引优化) -* [四、查询性能优化](#四查询性能优化) - * [使用 Explain 进行分析](#使用-explain-进行分析) - * [优化数据访问](#优化数据访问) - * [重构查询方式](#重构查询方式) * [五、切分](#五切分) * [水平切分](#水平切分) * [垂直切分](#垂直切分) @@ -29,101 +30,7 @@ -# 一、存储引擎 - -## InnoDB - -InnoDB 是 MySQL 默认的事务型存储引擎，只有在需要 InnoDB 不支持的特性时，才考虑使用其它存储引擎。 - -实现了四个标准的隔离级别，默认级别是可重复读（REPEATABLE READ）。在可重复读隔离级别下，通过多版本并发控制（MVCC）+ 间隙锁（next-key locking）防止幻影读。 - -主索引是聚簇索引，在索引中保存了数据，从而避免直接读取磁盘，因此对查询性能有很大的提升。 - -内部做了很多优化，包括从磁盘读取数据时采用的可预测性读、能够加快读操作并且自动创建的自适应哈希索引、能够加速插入操作的插入缓冲区等。 - -支持真正的在线热备份。其它存储引擎不支持在线热备份，要获取一致性视图需要停止对所有表的写入，而在读写混合场景中，停止写入可能也意味着停止读取。 - -## MyISAM - -MyISAM 设计简单，数据以紧密格式存储。对于只读数据，或者表比较小、可以容忍修复操作，则依然可以使用 MyISAM。 - -MyISAM 提供了大量的特性，包括压缩表、空间数据索引等。 - -不支持事务。 - -不支持行级锁，只能对整张表加锁，读取时会对需要读到的所有表加共享锁，写入时则对表加排它锁。但在表有读取操作的同时，也可以往表中插入新的记录，这被称为并发插入（CONCURRENT INSERT）。 - -可以手工或者自动执行检查和修复操作，但是和事务恢复以及崩溃恢复不同，可能导致一些数据丢失，而且修复操作是非常慢的。 - -如果指定了 DELAY_KEY_WRITE 选项，在每次修改执行完成时，不会立即将修改的索引数据写入磁盘，而是会写到内存中的键缓冲区，只有在清理键缓冲区或者关闭表的时候才会将对应的索引块写入磁盘。这种方式可以极大的提升写入性能，但是在数据库或者主机崩溃时会造成索引损坏，需要执行修复操作。 - -## 比较 - -- 事务：InnoDB 是事务型的，可以使用 Commit 和 Rollback 语句。 - -- 并发：MyISAM 只支持表级锁，而 InnoDB 还支持行级锁。 - -- 外键：InnoDB 支持外键。 - -- 备份：InnoDB 支持在线热备份。 - -- 崩溃恢复：MyISAM 崩溃后发生损坏的概率比 InnoDB 高很多，而且恢复的速度也更慢。 - -- 其它特性：MyISAM 支持压缩表和空间数据索引。 - -# 二、数据类型 - -## 整型 - -TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT 分别使用 8, 16, 24, 32, 64 位存储空间，一般情况下越小的列越好。 - -INT(11) 中的数字只是规定了交互工具显示字符的个数，对于存储和计算来说是没有意义的。 - -## 浮点数 - -FLOAT 和 DOUBLE 为浮点类型，DECIMAL 为高精度小数类型。CPU 原生支持浮点运算，但是不支持 DECIMAl 类型的计算，因此 DECIMAL 的计算比浮点类型需要更高的代价。 - -FLOAT、DOUBLE 和 DECIMAL 都可以指定列宽，例如 DECIMAL(18, 9) 表示总共 18 位，取 9 位存储小数部分，剩下 9 位存储整数部分。 - -## 字符串 - -主要有 CHAR 和 VARCHAR 两种类型，一种是定长的，一种是变长的。 - -VARCHAR 这种变长类型能够节省空间，因为只需要存储必要的内容。但是在执行 UPDATE 时可能会使行变得比原来长，当超出一个页所能容纳的大小时，就要执行额外的操作。MyISAM 会将行拆成不同的片段存储，而 InnoDB 则需要分裂页来使行放进页内。 - -VARCHAR 会保留字符串末尾的空格，而 CHAR 会删除。 - -## 时间和日期 - -MySQL 提供了两种相似的日期时间类型：DATETIME 和 TIMESTAMP。 - -### 1. DATETIME - -能够保存从 1001 年到 9999 年的日期和时间，精度为秒，使用 8 字节的存储空间。 - -它与时区无关。 - -默认情况下，MySQL 以一种可排序的、无歧义的格式显示 DATETIME 值，例如“2008-01-16 22:37:08”，这是 ANSI 标准定义的日期和时间表示方法。 - -### 2. TIMESTAMP - -和 UNIX 时间戳相同，保存从 1970 年 1 月 1 日午夜（格林威治时间）以来的秒数，使用 4 个字节，只能表示从 1970 年 到 2038 年。 - -它和时区有关，也就是说一个时间戳在不同的时区所代表的具体时间是不同的。 - -MySQL 提供了 FROM_UNIXTIME() 函数把 UNIX 时间戳转换为日期，并提供了 UNIX_TIMESTAMP() 函数把日期转换为 UNIX 时间戳。 - -默认情况下，如果插入时没有指定 TIMESTAMP 列的值，会将这个值设置为当前时间。 - -应该尽量使用 TIMESTAMP，因为它比 DATETIME 空间效率更高。 - -# 三、索引 - -索引能够轻易将查询性能提升几个数量级。 - -对于非常小的表、大部分情况下简单的全表扫描比建立索引更高效。对于中到大型的表，索引就非常有效。但是对于特大型的表，建立和维护索引的代价将会随之增长。这种情况下，需要用到一种技术可以直接区分出需要查询的一组数据，而不是一条记录一条记录地匹配，例如可以使用分区技术。 - -索引是在存储引擎层实现的，而不是在服务器层实现的，所以不同存储引擎具有不同的索引类型和实现。 +# 一、索引 ## B+ Tree 原理 @@ -141,37 +48,37 @@ B+ Tree 是基于 B Tree 和叶子节点顺序访问指针进行实现，它具 进行查找操作时，首先在根节点进行二分查找，找到一个 key 所在的指针，然后递归地在指针所指向的节点进行查找。直到查找到叶子节点，然后在叶子节点上进行二分查找，找出 key 所对应的 data。 -插入删除操作记录会破坏平衡树的平衡性，因此在插入删除时，需要对树进行一个分裂、合并、旋转等操作。 +插入删除操作记录会破坏平衡树的平衡性，因此在插入删除操作之后，需要对树进行一个分裂、合并、旋转等操作来维护平衡性。 ### 3. 与红黑树的比较 红黑树等平衡树也可以用来实现索引，但是文件系统及数据库系统普遍采用 B+ Tree 作为索引结构，主要有以下两个原因： -（一）更少的检索次数 +（一）更少的查找次数 -平衡树检索数据的时间复杂度等于树高 h，而树高大致为 O(h)=O(logdN)，其中 d 为每个节点的出度。 +平衡树查找操作的时间复杂度等于树高 h，而树高大致为 O(h)=O(logdN)，其中 d 为每个节点的出度。 -红黑树的出度为 2，而 B+ Tree 的出度一般都非常大。红黑树的树高 h 很明显比 B+ Tree 大非常多，因此检索的次数也就更多。 +红黑树的出度为 2，而 B+ Tree 的出度一般都非常大，所以红黑树的树高 h 很明显比 B+ Tree 大非常多，检索的次数也就更多。 （二）利用计算机预读特性 -为了减少磁盘 I/O，磁盘往往不是严格按需读取，而是每次都会预读。这样做的理论依据是计算机科学中著名的局部性原理：当一个数据被用到时，其附近的数据也通常会马上被使用。预读过程中，磁盘进行顺序读取，顺序读取不需要进行磁盘寻道，并且只需要很短的旋转时间，因此速度会非常快。 +为了减少磁盘 I/O，磁盘往往不是严格按需读取，而是每次都会预读。预读过程中，磁盘进行顺序读取，顺序读取不需要进行磁盘寻道，并且只需要很短的旋转时间，因此速度会非常快。 操作系统一般将内存和磁盘分割成固态大小的块，每一块称为一页，内存与磁盘以页为单位交换数据。数据库系统将索引的一个节点的大小设置为页的大小，使得一次 I/O 就能完全载入一个节点，并且可以利用预读特性，相邻的节点也能够被预先载入。 -## 索引分类 +## MySQL 索引 + +索引是在存储引擎层实现的，而不是在服务器层实现的，所以不同存储引擎具有不同的索引类型和实现。 ### 1. B+Tree 索引 -B+Tree 索引是大多数 MySQL 存储引擎的默认索引类型。 +是大多数 MySQL 存储引擎的默认索引类型。 因为不再需要进行全表扫描，只需要对树进行搜索即可，因此查找速度快很多。除了用于查找，还可以用于排序和分组。 可以指定多个列作为索引列，多个索引列共同组成键。 -B+Tree 索引适用于全键值、键值范围和键前缀查找，其中键前缀查找只适用于最左前缀查找。 - -如果不是按照索引列的顺序进行查找，则无法使用索引。 +适用于全键值、键值范围和键前缀查找，其中键前缀查找只适用于最左前缀查找。如果不是按照索引列的顺序进行查找，则无法使用索引。 InnoDB 的 B+Tree 索引分为主索引和辅助索引。 @@ -185,12 +92,12 @@ InnoDB 的 B+Tree 索引分为主索引和辅助索引。 ### 2. 哈希索引 -InnoDB 引擎有一个特殊的功能叫“自适应哈希索引”，当某个索引值被使用的非常频繁时，会在 B+Tree 索引之上再创建一个哈希索引，这样就让 B+Tree 索引具有哈希索引的一些优点，比如快速的哈希查找。 - 哈希索引能以 O(1) 时间进行查找，但是失去了有序性，它具有以下限制： - 无法用于排序与分组； -- 只支持精确查找，无法用于部分查找和范围查找； +- 只支持精确查找，无法用于部分查找和范围查找。 + +InnoDB 存储引擎有一个特殊的功能叫“自适应哈希索引”，当某个索引值被使用的非常频繁时，会在 B+Tree 索引之上再创建一个哈希索引，这样就让 B+Tree 索引具有哈希索引的一些优点，比如快速的哈希查找。 ### 3. 全文索引 @@ -200,20 +107,12 @@ MyISAM 存储引擎支持全文索引，用于查找文本中的关键词，而 InnoDB 存储引擎在 MySQL 5.6.4 版本中也开始支持全文索引。 -### 4. 空间数据索引（R-Tree） +### 4. 空间数据索引 -MyISAM 存储引擎支持空间数据索引，可以用于地理数据存储。空间数据索引会从所有维度来索引数据，可以有效地使用任意维度来进行组合查询。 +MyISAM 存储引擎支持空间数据索引（R-Tree），可以用于地理数据存储。空间数据索引会从所有维度来索引数据，可以有效地使用任意维度来进行组合查询。 必须使用 GIS 相关的函数来维护数据。 -## 索引的优点 - -- 大大减少了服务器需要扫描的数据行数。 - -- 帮助服务器避免进行排序和创建临时表（B+Tree 索引是有序的，可以用来做 ORDER BY 和 GROUP BY 操作）； - -- 将随机 I/O 变为顺序 I/O（B+Tree 索引是有序的，也就将相邻的数据都存储在一起）。 - ## 索引优化 ### 1. 独立的列 @@ -266,11 +165,25 @@ customer_id_selectivity: 0.0373 具有以下优点： -- 因为索引条目通常远小于数据行的大小，所以若只读取索引，能大大减少数据访问量。 +- 索引通常远小于数据行的大小，只读取索引能大大减少数据访问量。 - 一些存储引擎（例如 MyISAM）在内存中只缓存索引，而数据依赖于操作系统来缓存。因此，只访问索引可以不使用系统调用（通常比较费时）。 - 对于 InnoDB 引擎，若辅助索引能够覆盖查询，则无需访问主索引。 -# 四、查询性能优化 +## 索引的优点 + +- 大大减少了服务器需要扫描的数据行数。 + +- 帮助服务器避免进行排序和分组，也就不需要创建临时表（B+Tree 索引是有序的，可以用于 ORDER BY 和 GROUP BY 操作。临时表主要是在排序和分组过程中创建，因为不需要排序和分组，也就不需要创建临时表）。 + +- 将随机 I/O 变为顺序 I/O（B+Tree 索引是有序的，也就将相邻的数据都存储在一起）。 + +## 索引的使用场景 + +- 对于非常小的表、大部分情况下简单的全表扫描比建立索引更高效。 +- 对于中到大型的表，索引就非常有效。 +- 但是对于特大型的表，建立和维护索引的代价将会随之增长。这种情况下，需要用到一种技术可以直接区分出需要查询的一组数据，而不是一条记录一条记录地匹配，例如可以使用分区技术。 + +# 二、查询性能优化 ## 使用 Explain 进行分析 @@ -282,23 +195,13 @@ Explain 用来分析 SELECT 查询语句，开发人员可以通过分析 Explai - key : 使用的索引 - rows : 扫描的行数 -更多内容请参考：[MySQL 性能优化神器 Explain 使用分析](https://segmentfault.com/a/1190000008131735) - ## 优化数据访问 ### 1. 减少请求的数据量 -（一）只返回必要的列 - -最好不要使用 SELECT * 语句。 - -（二）只返回必要的行 - -使用 WHERE 语句进行查询过滤，有时候也需要使用 LIMIT 语句来限制返回的数据。 - -（三）缓存重复查询的数据 - -使用缓存可以避免在数据库中进行查询，特别要查询的数据经常被重复查询，缓存可以带来的查询性能提升将会是非常明显的。 +- 只返回必要的列：最好不要使用 SELECT * 语句。 +- 只返回必要的行：使用 LIMIT 语句来限制返回的数据。 +- 缓存重复查询的数据：使用缓存可以避免在数据库中进行查询，特别在要查询的数据经常被重复查询时，缓存带来的查询性能提升将会是非常明显的。 ### 2. 减少服务器端扫描的行数 @@ -324,12 +227,12 @@ do { ### 2. 分解大连接查询 -将一个大连接查询（JOIN）分解成对每一个表进行一次单表查询，然后将结果在应用程序中进行关联，这样做的好处有： +将一个大连接查询分解成对每一个表进行一次单表查询，然后将结果在应用程序中进行关联，这样做的好处有： - 让缓存更高效。对于连接查询，如果其中一个表发生变化，那么整个查询缓存就无法使用。而分解后的多个查询，即使其中一个表发生变化，对其它表的查询缓存依然可以使用。 - 分解成多个单表查询，这些单表查询的缓存结果更可能被其它查询使用到，从而减少冗余记录的查询。 - 减少锁竞争； -- 在应用层进行连接，可以更容易对数据库进行拆分，从而更容易做到高性能和可扩展。 +- 在应用层进行连接，可以更容易对数据库进行拆分，从而更容易做到高性能和可伸缩。 - 查询本身效率也可能会有所提升。例如下面的例子中，使用 IN() 代替连接查询，可以让 MySQL 按照 ID 顺序进行查询，这可能比随机的连接要更高效。 ```sql @@ -345,23 +248,111 @@ SELECT * FROM tag_post WHERE tag_id=1234; SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904); ``` +# 三、存储引擎 + +## InnoDB + +是 MySQL 默认的事务型存储引擎，只有在需要它不支持的特性时，才考虑使用其它存储引擎。 + +实现了四个标准的隔离级别，默认级别是可重复读（REPEATABLE READ）。在可重复读隔离级别下，通过多版本并发控制（MVCC）+ 间隙锁（Next-Key Locking）防止幻影读。 + +主索引是聚簇索引，在索引中保存了数据，从而避免直接读取磁盘，因此对查询性能有很大的提升。 + +内部做了很多优化，包括从磁盘读取数据时采用的可预测性读、能够加快读操作并且自动创建的自适应哈希索引、能够加速插入操作的插入缓冲区等。 + +支持真正的在线热备份。其它存储引擎不支持在线热备份，要获取一致性视图需要停止对所有表的写入，而在读写混合场景中，停止写入可能也意味着停止读取。 + +## MyISAM + +设计简单，数据以紧密格式存储。对于只读数据，或者表比较小、可以容忍修复操作，则依然可以使用它。 + +提供了大量的特性，包括压缩表、空间数据索引等。 + +不支持事务。 + +不支持行级锁，只能对整张表加锁，读取时会对需要读到的所有表加共享锁，写入时则对表加排它锁。但在表有读取操作的同时，也可以往表中插入新的记录，这被称为并发插入（CONCURRENT INSERT）。 + +可以手工或者自动执行检查和修复操作，但是和事务恢复以及崩溃恢复不同，可能导致一些数据丢失，而且修复操作是非常慢的。 + +如果指定了 DELAY_KEY_WRITE 选项，在每次修改执行完成时，不会立即将修改的索引数据写入磁盘，而是会写到内存中的键缓冲区，只有在清理键缓冲区或者关闭表的时候才会将对应的索引块写入磁盘。这种方式可以极大的提升写入性能，但是在数据库或者主机崩溃时会造成索引损坏，需要执行修复操作。 + +## 比较 + +- 事务：InnoDB 是事务型的，可以使用 Commit 和 Rollback 语句。 + +- 并发：MyISAM 只支持表级锁，而 InnoDB 还支持行级锁。 + +- 外键：InnoDB 支持外键。 + +- 备份：InnoDB 支持在线热备份。 + +- 崩溃恢复：MyISAM 崩溃后发生损坏的概率比 InnoDB 高很多，而且恢复的速度也更慢。 + +- 其它特性：MyISAM 支持压缩表和空间数据索引。 + +# 四、数据类型 + +## 整型 + +TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT 分别使用 8, 16, 24, 32, 64 位存储空间，一般情况下越小的列越好。 + +INT(11) 中的数字只是规定了交互工具显示字符的个数，对于存储和计算来说是没有意义的。 + +## 浮点数 + +FLOAT 和 DOUBLE 为浮点类型，DECIMAL 为高精度小数类型。CPU 原生支持浮点运算，但是不支持 DECIMAl 类型的计算，因此 DECIMAL 的计算比浮点类型需要更高的代价。 + +FLOAT、DOUBLE 和 DECIMAL 都可以指定列宽，例如 DECIMAL(18, 9) 表示总共 18 位，取 9 位存储小数部分，剩下 9 位存储整数部分。 + +## 字符串 + +主要有 CHAR 和 VARCHAR 两种类型，一种是定长的，一种是变长的。 + +VARCHAR 这种变长类型能够节省空间，因为只需要存储必要的内容。但是在执行 UPDATE 时可能会使行变得比原来长，当超出一个页所能容纳的大小时，就要执行额外的操作。MyISAM 会将行拆成不同的片段存储，而 InnoDB 则需要分裂页来使行放进页内。 + +VARCHAR 会保留字符串末尾的空格，而 CHAR 会删除。 + +## 时间和日期 + +MySQL 提供了两种相似的日期时间类型：DATETIME 和 TIMESTAMP。 + +### 1. DATETIME + +能够保存从 1001 年到 9999 年的日期和时间，精度为秒，使用 8 字节的存储空间。 + +它与时区无关。 + +默认情况下，MySQL 以一种可排序的、无歧义的格式显示 DATETIME 值，例如“2008-01-16 22:37:08”，这是 ANSI 标准定义的日期和时间表示方法。 + +### 2. TIMESTAMP + +和 UNIX 时间戳相同，保存从 1970 年 1 月 1 日午夜（格林威治时间）以来的秒数，使用 4 个字节，只能表示从 1970 年 到 2038 年。 + +它和时区有关，也就是说一个时间戳在不同的时区所代表的具体时间是不同的。 + +MySQL 提供了 FROM_UNIXTIME() 函数把 UNIX 时间戳转换为日期，并提供了 UNIX_TIMESTAMP() 函数把日期转换为 UNIX 时间戳。 + +默认情况下，如果插入时没有指定 TIMESTAMP 列的值，会将这个值设置为当前时间。 + +应该尽量使用 TIMESTAMP，因为它比 DATETIME 空间效率更高。 + # 五、切分 ## 水平切分 -

- 水平切分又称为 Sharding，它是将同一个表中的记录拆分到多个结构相同的表中。 当一个表的数据不断增多时，Sharding 是必然的选择，它可以将数据分布到集群的不同节点上，从而缓存单个数据库的压力。 +

+ ## 垂直切分

垂直切分是将一张表按列切分成多个表，通常是按照列的关系密集程度进行切分，也可以利用垂直切分将经常被使用的列和不经常被使用的列切分到不同的表中。 -在数据库的层面使用垂直切分将按数据库中表的密集程度部署到不同的库中，例如将原来的电商数据库垂直切分成商品数据库 payDB、用户数据库 userDB 等。 +在数据库的层面使用垂直切分将按数据库中表的密集程度部署到不同的库中，例如将原来的电商数据库垂直切分成商品数据库、用户数据库等。 ## Sharding 策略 @@ -375,15 +366,15 @@ SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904); 使用分布式事务来解决，比如 XA 接口。 -### 2. JOIN +### 2. 链接 -可以将原来的 JOIN 查询分解成多个单表查询，然后在用户程序中进行 JOIN。 +可以将原来的 JOIN 分解成多个单表查询，然后在用户程序中进行 JOIN。 ### 3. ID 唯一性 -- 使用全局唯一 ID：GUID。 -- 为每个分片指定一个 ID 范围。 -- 分布式 ID 生成器 (如 Twitter 的 Snowflake 算法)。 +- 使用全局唯一 ID：GUID +- 为每个分片指定一个 ID 范围 +- 分布式 ID 生成器 (如 Twitter 的 Snowflake 算法) 更多内容请参考： @@ -396,24 +387,24 @@ SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904); 主要涉及三个线程：binlog 线程、I/O 线程和 SQL 线程。 -- **binlog 线程** ：负责将主服务器上的数据更改写入二进制文件（binlog）中。 -- **I/O 线程** ：负责从主服务器上读取二进制日志文件，并写入从服务器的中继日志中。 +- **binlog 线程** ：负责将主服务器上的数据更改写入二进制日志中。 +- **I/O 线程** ：负责从主服务器上读取二进制日志，并写入从服务器的中继日志中。 - **SQL 线程** ：负责读取中继日志并重放其中的 SQL 语句。

## 读写分离 -主服务器用来处理写操作以及实时性要求比较高的读操作，而从服务器用来处理读操作。 +主服务器处理写操作以及实时性要求比较高的读操作，而从服务器处理读操作。 -读写分离常用代理方式来实现，代理服务器接收应用层传来的读写请求，然后决定转发到哪个服务器。 - -MySQL 读写分离能提高性能的原因在于： +读写分离能提高性能的原因在于： - 主从服务器负责各自的读和写，极大程度缓解了锁的争用； -- 从服务器可以配置 MyISAM 引擎，提升查询性能以及节约系统开销； +- 从服务器可以使用 MyISAM，提升查询性能以及节约系统开销； - 增加冗余，提高可用性。 +读写分离常用代理方式来实现，代理服务器接收应用层传来的读写请求，然后决定转发到哪个服务器。 +

# 参考资料 @@ -425,3 +416,4 @@ MySQL 读写分离能提高性能的原因在于： - [How to create unique row ID in sharded databases?](https://stackoverflow.com/questions/788829/how-to-create-unique-row-id-in-sharded-databases) - [SQL Azure Federation – Introduction](http://geekswithblogs.net/shaunxu/archive/2012/01/07/sql-azure-federation-ndash-introduction.aspx "Title of this entry.") - [MySQL 索引背后的数据结构及算法原理](http://blog.codinglabs.org/articles/theory-of-mysql-index.html) +- [MySQL 性能优化神器 Explain 使用分析](https://segmentfault.com/a/1190000008131735) diff --git a/notes/Redis.md b/notes/Redis.md index 0981abf0..8f231382 100644 --- a/notes/Redis.md +++ b/notes/Redis.md @@ -49,7 +49,7 @@ Redis 是速度非常快的非关系型（NoSQL）内存键值数据库，可以存储键和五种不同类型的值之间的映射。 -键的类型只能为字符串，值支持的五种类型数据类型为：字符串、列表、集合、有序集合、散列表。 +键的类型只能为字符串，值支持的五种类型数据类型为：字符串、列表、集合、散列表、有序集合。 Redis 支持很多特性，例如将内存中的数据持久化到硬盘中，使用复制来扩展读性能，使用分片来扩展写性能。 @@ -58,7 +58,7 @@ Redis 支持很多特性，例如将内存中的数据持久化到硬盘中， | 数据类型 | 可以存储的值 | 操作 | | :--: | :--: | :--: | | STRING | 字符串、整数或者浮点数 | 对整个字符串或者字符串的其中一部分执行操作
对整数和浮点数执行自增或者自减操作 | -| LIST | 列表 | 从两端压入或者弹出元素
读取单个或者多个元素
进行修剪，只保留一个范围内的元素 | +| LIST | 列表 | 从两端压入或者弹出元素
对单个或者多个元素
进行修剪，只保留一个范围内的元素 | | SET | 无序集合 | 添加、获取、移除单个元素
检查一个元素是否存在于集合中
计算交集、并集、差集
从集合里面随机获取元素 | | HASH | 包含键值对的无序散列表 | 添加、获取、移除单个键值对
获取所有键值对
检查某个键是否存在| | ZSET | 有序集合 | 添加、获取、删除元素
根据分值范围或者成员来获取元素
计算一个键的排名 | @@ -555,7 +555,7 @@ Sentinel（哨兵）可以监听主服务器，并在主服务器进入下线状 分片是将数据划分为多个部分的方法，可以将数据存储到多台机器里面，这种方法在解决某些问题时可以获得线性级别的性能提升。 -假设有 4 个 Reids 实例 R0，R1，R2，R3，还有很多表示用户的键 user:1，user:2，... 等等，有不同的方式来选择一个指定的键存储在哪个实例中。 +假设有 4 个 Reids 实例 R0，R1，R2，R3，还有很多表示用户的键 user:1，user:2，... ，有不同的方式来选择一个指定的键存储在哪个实例中。 - 最简单的方式是范围分片，例如用户 id 从 0\~1000 的存储到实例 R0 中，用户 id 从 1001\~2000 的存储到实例 R1 中，等等。但是这样需要维护一张映射范围表，维护操作代价很高。 - 还有一种方式是哈希分片，使用 CRC32 哈希函数将键转换为一个数字，再对实例数量求模就能知道应该存储的实例。 diff --git a/notes/数据库系统原理.md b/notes/数据库系统原理.md index e7ef804b..1bcd2533 100644 --- a/notes/数据库系统原理.md +++ b/notes/数据库系统原理.md @@ -20,6 +20,7 @@ * [可串行化（SERIALIZABLE）](#可串行化serializable) * [五、多版本并发控制](#五多版本并发控制) * [版本号](#版本号) + * [隐藏的列](#隐藏的列) * [Undo 日志](#undo-日志) * [实现过程](#实现过程) * [快照读与当前读](#快照读与当前读) @@ -58,9 +59,7 @@ ### 2. 一致性（Consistency） -数据库在事务执行前后都保持一致性状态。 - -在一致性状态下，所有事务对一个数据的读取结果都是相同的。 +数据库在事务执行前后都保持一致性状态。在一致性状态下，所有事务对一个数据的读取结果都是相同的。 ### 3. 隔离性（Isolation） @@ -78,10 +77,10 @@ - 只有满足一致性，事务的执行结果才是正确的。 - 在无并发的情况下，事务串行执行，隔离性一定能够满足。此时只要能满足原子性，就一定能满足一致性。 -- 在并发的情况下，多个事务并发执行，事务不仅要满足原子性，还需要满足隔离性，才能满足一致性。 +- 在并发的情况下，多个事务并行执行，事务不仅要满足原子性，还需要满足隔离性，才能满足一致性。 - 事务满足持久化是为了能应对数据库崩溃的情况。 -

+

## AUTOCOMMIT @@ -95,25 +94,25 @@ MySQL 默认采用自动提交模式。也就是说，如果不显式使用`STAR T1 和 T2 两个事务都对一个数据进行修改，T1 先修改，T2 随后修改，T2 的修改覆盖了 T1 的修改。 -

+

## 读脏数据 T1 修改一个数据，T2 随后读取这个数据。如果 T1 撤销了这次修改，那么 T2 读取的数据是脏数据。 -

+

## 不可重复读 T2 读取一个数据，T1 对该数据做了修改。如果 T2 再次读取这个数据，此时读取的结果和第一次读取的结果不同。 -

+

## 幻影读 T1 读取某个范围的数据，T2 在这个范围内插入新的数据，T1 再次读取这个范围的数据，此时读取的结果和和第一次读取的结果不同。 -

+

---- @@ -123,7 +122,6 @@ T1 读取某个范围的数据，T2 在这个范围内插 ## 封锁粒度 - MySQL 中提供了两种封锁粒度：行级锁以及表级锁。 应该尽量只锁定需要修改的那部分数据，而不是所有的资源。锁定的数据量越少，发生锁争用的可能就越小，系统的并发程度就越高。 @@ -150,8 +148,8 @@ MySQL 中提供了两种封锁粒度：行级锁以及表级锁。 | - | X | S | | :--: | :--: | :--: | -|X|NO|NO| -|S|NO|YES| +|X|×|×| +|S|×|√| ### 2. 意向锁 @@ -170,10 +168,10 @@ MySQL 中提供了两种封锁粒度：行级锁以及表级锁。 | - | X | IX | S | IS | | :--: | :--: | :--: | :--: | :--: | -|X |NO |NO |NO | NO| -|IX |NO |YES |NO | YES| -|S |NO |NO |YES | YES| -|IS |NO |YES |YES | YES| +|X |× |× |× | ×| +|IX |× |√ |× | √| +|S |× |× |√ | √| +|IS |× |√ |√ | √| 解释如下： @@ -298,32 +296,30 @@ SELECT ... FOR UPDATE; | 隔离级别 | 脏读 | 不可重复读 | 幻影读 | | :---: | :---: | :---:| :---: | -| 未提交读 | YES | YES | YES | -| 提交读 | NO | YES | YES | -| 可重复读 | NO | NO | YES | -| 可串行化 | NO | NO | NO | +| 未提交读 | √ | √ | √ | +| 提交读 | × | √ | √ | +| 可重复读 | × | × | √ | +| 可串行化 | × | × | × | # 五、多版本并发控制 -多版本并发控制（Multi-Version Concurrency Control, MVCC）是 MySQL 的 InnoDB 存储引擎实现隔离级别的一种具体方式，用于实现提交读和可重复读这两种隔离级别。 - -而未提交读隔离级别总是读取最新的数据行，无需使用 MVCC。 - -可串行化隔离级别需要对所有读取的行都加锁，单纯使用 MVCC 无法实现。 +多版本并发控制（Multi-Version Concurrency Control, MVCC）是 MySQL 的 InnoDB 存储引擎实现隔离级别的一种具体方式，用于实现提交读和可重复读这两种隔离级别。而未提交读隔离级别总是读取最新的数据行，无需使用 MVCC。可串行化隔离级别需要对所有读取的行都加锁，单纯使用 MVCC 无法实现。 ## 版本号 - 系统版本号：是一个递增的数字，每开始一个新的事务，系统版本号就会自动递增。 - 事务版本号：事务开始时的系统版本号。 -InooDB 的 MVCC 在每行记录后面都保存着两个隐藏的列，用来存储两个版本号： +## 隐藏的列 + +MVCC 在每行记录后面都保存着两个隐藏的列，用来存储两个版本号： - 创建版本号：指示创建一个数据行的快照时的系统版本号； - 删除版本号：如果该快照的删除版本号大于当前事务版本号表示该快照有效，否则表示该快照已经被删除了。 ## Undo 日志 -InnoDB 的 MVCC 使用到的快照存储在 Undo 日志中，该日志通过回滚指针把一个数据行（Record）的所有快照连接起来。 +MVCC 使用到的快照存储在 Undo 日志中，该日志通过回滚指针把一个数据行（Record）的所有快照连接起来。

@@ -331,15 +327,13 @@ InnoDB 的 MVCC 使用到的快照存储在 Undo 日志中，该日志通过回 以下实现过程针对可重复读隔离级别。 -### 1. SELECT - 当开始新一个事务时，该事务的版本号肯定会大于当前所有数据行快照的创建版本号，理解这一点很关键。 +### 1. SELECT + 多个事务必须读取到同一个数据行的快照，并且这个快照是距离现在最近的一个有效快照。但是也有例外，如果有一个事务正在修改该数据行，那么它可以读取事务本身所做的修改，而不用和其它事务的读取结果一致。 -把没有对一个数据行做修改的事务称为 T，T 所要读取的数据行快照的创建版本号必须小于 T 的版本号，因为如果大于或者等于 T 的版本号，那么表示该数据行快照是其它事务的最新修改，因此不能去读取它。 - -除了上面的要求，T 所要读取的数据行快照的删除版本号必须大于 T 的版本号，因为如果小于等于 T 的版本号，那么表示该数据行快照是已经被删除的，不应该去读取它。 +把没有对一个数据行做修改的事务称为 T，T 所要读取的数据行快照的创建版本号必须小于 T 的版本号，因为如果大于或者等于 T 的版本号，那么表示该数据行快照是其它事务的最新修改，因此不能去读取它。除此之外，T 所要读取的数据行快照的删除版本号必须大于 T 的版本号，因为如果小于等于 T 的版本号，那么表示该数据行快照是已经被删除的，不应该去读取它。 ### 2. INSERT @@ -385,7 +379,7 @@ MVCC 不能解决幻读的问题，Next-Key Locks 就是为了解决这个问题 锁定一个记录上的索引，而不是记录本身。 -如果表没有设置索引，InnoDB 会自动在主键上创建隐藏的聚集索引，因此 Record Locks 依然可以使用。 +如果表没有设置索引，InnoDB 会自动在主键上创建隐藏的聚簇索引，因此 Record Locks 依然可以使用。 ## Gap Locks @@ -397,7 +391,7 @@ SELECT c FROM t WHERE c BETWEEN 10 and 20 FOR UPDATE; ## Next-Key Locks -它是 Record Locks 和 Gap Locks 的结合，不仅锁定一个记录上的索引，也锁定范围内的索引。例如一个索引包含以下值：10, 11, 13, and 20，那么就需要锁定以下区间： +它是 Record Locks 和 Gap Locks 的结合，不仅锁定一个记录上的索引，也锁定索引之间的间隙。例如一个索引包含以下值：10, 11, 13, and 20，那么就需要锁定以下区间： ```sql (negative infinity, 10] @@ -432,10 +426,10 @@ SELECT c FROM t WHERE c BETWEEN 10 and 20 FOR UPDATE; 不符合范式的关系，会产生很多异常，主要有以下四种异常： -- 冗余数据：例如 学生-2 出现了两次。 +- 冗余数据：例如 `学生-2` 出现了两次。 - 修改异常：修改了一个记录中的信息，但是另一个记录中相同的信息却没有被修改。 -- 删除异常：删除一个信息，那么也会丢失其它信息。例如如果删除了 课程-1，需要删除第一行和第三行，那么 学生-1 的信息就会丢失。 -- 插入异常，例如想要插入一个学生的信息，如果这个学生还没选课，那么就无法插入。 +- 删除异常：删除一个信息，那么也会丢失其它信息。例如删除了 `课程-1` 需要删除第一行和第三行，那么 `学生-1` 的信息就会丢失。 +- 插入异常：例如想要插入一个学生的信息，如果这个学生还没选课，那么就无法插入。 ## 范式 @@ -506,7 +500,11 @@ Sname, Sdept 和 Mname 都部分依赖于键码，当一个学生选修了多门 非主属性不传递函数依赖于键码。 -上面的 关系-1 中存在以下传递函数依赖：Sno -> Sdept -> Mname，可以进行以下分解： +上面的 关系-1 中存在以下传递函数依赖： + +- Sno -> Sdept -> Mname + +可以进行以下分解： 关系-11 @@ -533,13 +531,19 @@ Entity-Relationship，有三个组成部分：实体、属性、联系。 包含一对一，一对多，多对多三种。 -如果 A 到 B 是一对多关系，那么画个带箭头的线段指向 B；如果是一对一，画两个带箭头的线段；如果是多对多，画两个不带箭头的线段。下图的 Course 和 Student 是一对多的关系。 +- 如果 A 到 B 是一对多关系，那么画个带箭头的线段指向 B； +- 如果是一对一，画两个带箭头的线段； +- 如果是多对多，画两个不带箭头的线段。 + +下图的 Course 和 Student 是一对多的关系。

## 表示出现多次的关系 -一个实体在联系出现几次，就要用几条线连接。下图表示一个课程的先修关系，先修关系出现两个 Course 实体，第一个是先修课程，后一个是后修课程，因此需要用两条线来表示这种关系。 +一个实体在联系出现几次，就要用几条线连接。 + +下图表示一个课程的先修关系，先修关系出现两个 Course 实体，第一个是先修课程，后一个是后修课程，因此需要用两条线来表示这种关系。

@@ -549,7 +553,7 @@ Entity-Relationship，有三个组成部分：实体、属性、联系。

-一般只使用二元联系，可以把多元关系转换为二元关系。 +一般只使用二元联系，可以把多元联系转换为二元联系。

From c6b517553a562ecec4505f453bff14fd818e3b59 Mon Sep 17 00:00:00 2001 From: CyC2018 <1029579233@qq.com> Date: Fri, 17 Aug 2018 21:19:16 +0800 Subject: [PATCH 10/24] auto commit --- notes/Java 容器.md | 2 +- notes/Java 并发.md | 2 + notes/Leetcode 题解.md | 180 +++++++++++------------ notes/Linux.md | 20 +-- notes/MySQL.md | 314 ++++++++++++++++++++-------------------- notes/Redis.md | 6 +- notes/数据库系统原理.md | 86 +++++------ notes/设计模式.md | 76 +++++----- notes/面向对象思想.md | 15 +- 9 files changed, 349 insertions(+), 352 deletions(-) diff --git a/notes/Java 容器.md b/notes/Java 容器.md index 9959e2ca..001f864c 100644 --- a/notes/Java 容器.md +++ b/notes/Java 容器.md @@ -742,7 +742,7 @@ new capacity : 00100000 对于一个 Key， -- 它的哈希值如果在第 6 位上为 0，那么取模得到的结果和之前一样； +- 它的哈希值如果在第 5 位上为 0，那么取模得到的结果和之前一样； - 如果为 1，那么得到的结果为原来的结果 +16。 ### 7. 扩容-计算数组容量 diff --git a/notes/Java 并发.md b/notes/Java 并发.md index 9cd5955b..d3682d33 100644 --- a/notes/Java 并发.md +++ b/notes/Java 并发.md @@ -168,6 +168,8 @@ public static void main(String[] args) throws ExecutionException, InterruptedExc 同样也是需要实现 run() 方法，因为 Thread 类也实现了 Runable 接口。 +当调用 start() 方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的 run() 方法。 + ```java public class MyThread extends Thread { public void run() { diff --git a/notes/Leetcode 题解.md b/notes/Leetcode 题解.md index 44f3d9dc..68af3cb7 100644 --- a/notes/Leetcode 题解.md +++ b/notes/Leetcode 题解.md @@ -2389,8 +2389,6 @@ private void backtracking(int row) {

-dp[N] 即为所求。 - 考虑到 dp[i] 只与 dp[i - 1] 和 dp[i - 2] 有关，因此可以只用两个变量来存储 dp[i - 1] 和 dp[i - 2]，使得原来的 O(N) 空间复杂度优化为 O(1) 复杂度。 ```java @@ -2468,16 +2466,6 @@ private int rob(int[] nums, int first, int last) { } ``` -**母牛生产** - -[程序员代码面试指南-P181](#) - -题目描述：假设农场中成熟的母牛每年都会生 1 头小母牛，并且永远不会死。第一年有 1 只小母牛，从第二年开始，母牛开始生小母牛。每只小母牛 3 年之后成熟又可以生小母牛。给定整数 N，求 N 年后牛的数量。 - -第 i 年成熟的牛的数量为： - -

- **信件错排** 题目描述：有 N 个 信 和 信封，它们被打乱，求错误装信方式的数量。 @@ -2491,7 +2479,15 @@ private int rob(int[] nums, int first, int last) {

-dp[N] 即为所求。 +**母牛生产** + +[程序员代码面试指南-P181](#) + +题目描述：假设农场中成熟的母牛每年都会生 1 头小母牛，并且永远不会死。第一年有 1 只小母牛，从第二年开始，母牛开始生小母牛。每只小母牛 3 年之后成熟又可以生小母牛。给定整数 N，求 N 年后牛的数量。 + +第 i 年成熟的牛的数量为： + +

### 矩阵路径 @@ -2517,10 +2513,8 @@ public int minPathSum(int[][] grid) { int[] dp = new int[n]; for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { - if (j == 0) { - dp[j] = dp[j]; // 只能从上侧走到该位置 - } else if (i == 0) { - dp[j] = dp[j - 1]; // 只能从左侧走到该位置 + if (i == 0) { + dp[j] = dp[j - 1]; } else { dp[j] = Math.min(dp[j - 1], dp[j]); } @@ -2584,17 +2578,18 @@ sumRange(0, 5) -> -3 ```java class NumArray { + private int[] sums; public NumArray(int[] nums) { - sums = new int[nums.length]; - for (int i = 0; i < nums.length; i++) { - sums[i] = i == 0 ? nums[0] : sums[i - 1] + nums[i]; + sums = new int[nums.length + 1]; + for (int i = 1; i <= nums.length; i++) { + sums[i] = sums[i - 1] + nums[i - 1]; } } public int sumRange(int i, int j) { - return i == 0 ? sums[j] : sums[j] - sums[i - 1]; + return sums[j + 1] - sums[i]; } } ``` @@ -2634,7 +2629,7 @@ return: 3, for 3 arithmetic slices in A: [1, 2, 3], [2, 3, 4] and [1, 2, 3, 4] i dp[i] 表示以 A[i] 为结尾的等差递增子区间的个数。 -如果 A[i] - A[i - 1] == A[i - 1] - A[i - 2]，表示 [A[i - 2], A[i - 1], A[i]] 是一个等差递增子区间。如果 [A[i - 3], A[i - 2], A[i - 1]] 是一个等差递增子区间，那么 [A[i - 3], A[i - 2], A[i - 1], A[i]] 也是。因此在这个条件下，dp[i] = dp[i-1] + 1。 +在 A[i] - A[i - 1] == A[i - 1] - A[i - 2] 的条件下，{A[i - 2], A[i - 1], A[i]} 是一个等差递增子区间。如果 {A[i - 3], A[i - 2], A[i - 1]} 是一个等差递增子区间，那么 {A[i - 3], A[i - 2], A[i - 1], A[i]} 也是等差递增子区间，dp[i] = dp[i-1] + 1。 ```java public int numberOfArithmeticSlices(int[] A) { @@ -2747,17 +2742,17 @@ public int numDecodings(String s) { ### 最长递增子序列 -已知一个序列 {S1, S2,...,Sn} ，取出若干数组成新的序列 {Si1, Si2,..., Sim}，其中 i1、i2 ... im 保持递增，即新序列中各个数仍然保持原数列中的先后顺序，称新序列为原序列的一个 **子序列** 。 +已知一个序列 {S1, S2,...,Sn}，取出若干数组成新的序列 {Si1, Si2,..., Sim}，其中 i1、i2 ... im 保持递增，即新序列中各个数仍然保持原数列中的先后顺序，称新序列为原序列的一个 **子序列** 。 如果在子序列中，当下标 ix > iy 时，Six > Siy，称子序列为原序列的一个 **递增子序列** 。 -定义一个数组 dp 存储最长递增子序列的长度，dp[n] 表示以 Sn 结尾的序列的最长递增子序列长度。对于一个递增子序列 {Si1, Si2,...,Sim}，如果 im < n 并且 Sim < Sn ，此时 {Si1, Si2,..., Sim, Sn} 为一个递增子序列，递增子序列的长度增加 1。满足上述条件的递增子序列中，长度最长的那个递增子序列就是要找的，在长度最长的递增子序列上加上 Sn 就构成了以 Sn 为结尾的最长递增子序列。因此 dp[n] = max{ dp[i]+1 | Si < Sn && i < n} 。 +定义一个数组 dp 存储最长递增子序列的长度，dp[n] 表示以 Sn 结尾的序列的最长递增子序列长度。对于一个递增子序列 {Si1, Si2,...,Sim}，如果 im < n 并且 Sim < Sn，此时 {Si1, Si2,..., Sim, Sn} 为一个递增子序列，递增子序列的长度增加 1。满足上述条件的递增子序列中，长度最长的那个递增子序列就是要找的，在长度最长的递增子序列上加上 Sn 就构成了以 Sn 为结尾的最长递增子序列。因此 dp[n] = max{ dp[i]+1 | Si < Sn && i < n} 。 因为在求 dp[n] 时可能无法找到一个满足条件的递增子序列，此时 {Sn} 就构成了递增子序列，需要对前面的求解方程做修改，令 dp[n] 最小为 1，即：

-对于一个长度为 N 的序列，最长递增子序列并不一定会以 SN 为结尾，因此 dp[N] 不是序列的最长递增子序列的长度，需要遍历 dp 数组找出最大值才是所要的结果，即 max{ dp[i] | 1 <= i <= N} 即为所求。 +对于一个长度为 N 的序列，最长递增子序列并不一定会以 SN 为结尾，因此 dp[N] 不是序列的最长递增子序列的长度，需要遍历 dp 数组找出最大值才是所要的结果，max{ dp[i] | 1 <= i <= N} 即为所求。 **最长递增子序列** @@ -2790,7 +2785,7 @@ for (int i = 0; i < n; i++) { return ret; ``` -以上解法的时间复杂度为 O(N2) ，可以使用二分查找将时间复杂度降低为 O(NlogN)。 +以上解法的时间复杂度为 O(N2)，可以使用二分查找将时间复杂度降低为 O(NlogN)。 定义一个 tails 数组，其中 tails[i] 存储长度为 i + 1 的最长递增子序列的最后一个元素。对于一个元素 x， @@ -2915,19 +2910,19 @@ public int wiggleMaxLength(int[] nums) { 定义一个二维数组 dp 用来存储最长公共子序列的长度，其中 dp[i][j] 表示 S1 的前 i 个字符与 S2 的前 j 个字符最长公共子序列的长度。考虑 S1i 与 S2j 值是否相等，分为两种情况： -- 当 S1i==S2j 时，那么就能在 S1 的前 i-1 个字符与 S2 的前 j-1 个字符最长公共子序列的基础上再加上 S1i 这个值，最长公共子序列长度加 1 ，即 dp[i][j] = dp[i-1][j-1] + 1。 -- 当 S1i != S2j 时，此时最长公共子序列为 S1 的前 i-1 个字符和 S2 的前 j 个字符最长公共子序列，与 S1 的前 i 个字符和 S2 的前 j-1 个字符最长公共子序列，它们的最大者，即 dp[i][j] = max{ dp[i-1][j], dp[i][j-1] }。 +- 当 S1i==S2j 时，那么就能在 S1 的前 i-1 个字符与 S2 的前 j-1 个字符最长公共子序列的基础上再加上 S1i 这个值，最长公共子序列长度加 1，即 dp[i][j] = dp[i-1][j-1] + 1。 +- 当 S1i != S2j 时，此时最长公共子序列为 S1 的前 i-1 个字符和 S2 的前 j 个字符最长公共子序列，或者 S1 的前 i 个字符和 S2 的前 j-1 个字符最长公共子序列，取它们的最大者，即 dp[i][j] = max{ dp[i-1][j], dp[i][j-1] }。 综上，最长公共子序列的状态转移方程为：

-对于长度为 N 的序列 S1 和 长度为 M 的序列 S2，dp[N][M] 就是序列 S1 和序列 S2 的最长公共子序列长度。 +对于长度为 N 的序列 S1 和长度为 M 的序列 S2，dp[N][M] 就是序列 S1 和序列 S2 的最长公共子序列长度。 与最长递增子序列相比，最长公共子序列有以下不同点： - 针对的是两个序列，求它们的最长公共子序列。 -- 在最长递增子序列中，dp[i] 表示以 Si 为结尾的最长递增子序列长度，子序列必须包含 Si ；在最长公共子序列中，dp[i][j] 表示 S1 中前 i 个字符与 S2 中前 j 个字符的最长公共子序列长度，不一定包含 S1i 和 S2j 。 +- 在最长递增子序列中，dp[i] 表示以 Si 为结尾的最长递增子序列长度，子序列必须包含 Si ；在最长公共子序列中，dp[i][j] 表示 S1 中前 i 个字符与 S2 中前 j 个字符的最长公共子序列长度，不一定包含 S1i 和 S2j。 - 在求最终解时，最长公共子序列中 dp[N][M] 就是最终解，而最长递增子序列中 dp[N] 不是最终解，因为以 SN 为结尾的最长递增子序列不一定是整个序列最长递增子序列，需要遍历一遍 dp 数组找到最大者。 ```java @@ -2956,9 +2951,7 @@ public int lengthOfLCS(int[] nums1, int[] nums2) { - 第 i 件物品没添加到背包，总体积不超过 j 的前 i 件物品的最大价值就是总体积不超过 j 的前 i-1 件物品的最大价值，dp[i][j] = dp[i-1][j]。 - 第 i 件物品添加到背包中，dp[i][j] = dp[i-1][j-w] + v。 -第 i 件物品可添加也可以不添加，取决于哪种情况下最大价值更大。 - -综上，0-1 背包的状态转移方程为： +第 i 件物品可添加也可以不添加，取决于哪种情况下最大价值更大。因此，0-1 背包的状态转移方程为：

@@ -2981,11 +2974,11 @@ public int knapsack(int W, int N, int[] weights, int[] values) { **空间优化** -在程序实现时可以对 0-1 背包做优化。观察状态转移方程可以知道，前 i 件物品的状态仅由前 i-1 件物品的状态有关，因此可以将 dp 定义为一维数组，其中 dp[j] 既可以表示 dp[i-1][j] 也可以表示 dp[i][j]。此时， +在程序实现时可以对 0-1 背包做优化。观察状态转移方程可以知道，前 i 件物品的状态仅与前 i-1 件物品的状态有关，因此可以将 dp 定义为一维数组，其中 dp[j] 既可以表示 dp[i-1][j] 也可以表示 dp[i][j]。此时，

-因为 dp[j-w] 表示 dp[i-1][j-w]，因此不能先求 dp[i][j-w]，以防止将 dp[i-1][j-w] 覆盖。也就是说要先计算 dp[i][j] 再计算 dp[i][j-w]，在程序实现时需要按倒序来循环求解。 +因为 dp[j-w] 表示 dp[i-1][j-w]，因此不能先求 dp[i][j-w]，以防将 dp[i-1][j-w] 覆盖。也就是说要先计算 dp[i][j] 再计算 dp[i][j-w]，在程序实现时需要按倒序来循环求解。 ```java public int knapsack(int W, int N, int[] weights, int[] values) { @@ -3205,7 +3198,7 @@ public int findMaxForm(String[] strs, int m, int n) { } ``` -**找零钱的方法数** +**找零钱的最少硬币数** [322. Coin Change (Medium)](https://leetcode.com/problems/coin-change/description/) @@ -3286,60 +3279,6 @@ public int combinationSum4(int[] nums, int target) { } ``` -**只能进行 k 次的股票交易** - -[188. Best Time to Buy and Sell Stock IV (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/description/) - -```java -public int maxProfit(int k, int[] prices) { - int n = prices.length; - if (k >= n / 2) { // 这种情况下该问题退化为普通的股票交易问题 - int maxProfit = 0; - for (int i = 1; i < n; i++) { - if (prices[i] > prices[i - 1]) { - maxProfit += prices[i] - prices[i - 1]; - } - } - return maxProfit; - } - int[][] maxProfit = new int[k + 1][n]; - for (int i = 1; i <= k; i++) { - int localMax = maxProfit[i - 1][0] - prices[0]; - for (int j = 1; j < n; j++) { - maxProfit[i][j] = Math.max(maxProfit[i][j - 1], prices[j] + localMax); - localMax = Math.max(localMax, maxProfit[i - 1][j] - prices[j]); - } - } - return maxProfit[k][n - 1]; -} -``` - -**只能进行两次的股票交易** - -[123. Best Time to Buy and Sell Stock III (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/description/) - -```java -public int maxProfit(int[] prices) { - int firstBuy = Integer.MIN_VALUE, firstSell = 0; - int secondBuy = Integer.MIN_VALUE, secondSell = 0; - for (int curPrice : prices) { - if (firstBuy < -curPrice) { - firstBuy = -curPrice; - } - if (firstSell < firstBuy + curPrice) { - firstSell = firstBuy + curPrice; - } - if (secondBuy < firstSell - curPrice) { - secondBuy = firstSell - curPrice; - } - if (secondSell < secondBuy + curPrice) { - secondSell = secondBuy + curPrice; - } - } - return secondSell; -} -``` - ### 股票交易 **需要冷却期的股票交易** @@ -3432,6 +3371,60 @@ public int maxProfit(int[] prices) { } ``` +**只能进行两次的股票交易** + +[123. Best Time to Buy and Sell Stock III (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/description/) + +```java +public int maxProfit(int[] prices) { + int firstBuy = Integer.MIN_VALUE, firstSell = 0; + int secondBuy = Integer.MIN_VALUE, secondSell = 0; + for (int curPrice : prices) { + if (firstBuy < -curPrice) { + firstBuy = -curPrice; + } + if (firstSell < firstBuy + curPrice) { + firstSell = firstBuy + curPrice; + } + if (secondBuy < firstSell - curPrice) { + secondBuy = firstSell - curPrice; + } + if (secondSell < secondBuy + curPrice) { + secondSell = secondBuy + curPrice; + } + } + return secondSell; +} +``` + +**只能进行 k 次的股票交易** + +[188. Best Time to Buy and Sell Stock IV (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/description/) + +```java +public int maxProfit(int k, int[] prices) { + int n = prices.length; + if (k >= n / 2) { // 这种情况下该问题退化为普通的股票交易问题 + int maxProfit = 0; + for (int i = 1; i < n; i++) { + if (prices[i] > prices[i - 1]) { + maxProfit += prices[i] - prices[i - 1]; + } + } + return maxProfit; + } + int[][] maxProfit = new int[k + 1][n]; + for (int i = 1; i <= k; i++) { + int localMax = maxProfit[i - 1][0] - prices[0]; + for (int j = 1; j < n; j++) { + maxProfit[i][j] = Math.max(maxProfit[i][j - 1], prices[j] + localMax); + localMax = Math.max(localMax, maxProfit[i - 1][j] - prices[j]); + } + } + return maxProfit[k][n - 1]; +} +``` + ### 字符串编辑 **删除两个字符串的字符使它们相等** @@ -3450,11 +3443,8 @@ Explanation: You need one step to make "sea" to "ea" and another step to make "e public int minDistance(String word1, String word2) { int m = word1.length(), n = word2.length(); int[][] dp = new int[m + 1][n + 1]; - for (int i = 0; i <= m; i++) { - for (int j = 0; j <= n; j++) { - if (i == 0 || j == 0) { - continue; - } + for (int i = 1; i <= m; i++) { + for (int j = 1; j <= n; j++) { if (word1.charAt(i - 1) == word2.charAt(j - 1)) { dp[i][j] = dp[i - 1][j - 1] + 1; } else { diff --git a/notes/Linux.md b/notes/Linux.md index 14d3b317..8ff3e2c6 100644 --- a/notes/Linux.md +++ b/notes/Linux.md @@ -129,15 +129,16 @@ info 与 man 类似，但是 info 将文档分成一个个页面，每个页面 /usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/dmtsai/.local/bin:/home/dmtsai/bin ``` -env 命令可以获取当前终端的环境变量。 - ## sudo sudo 允许一般用户使用 root 可执行的命令，不过只有在 /etc/sudoers 配置文件中添加的用户才能使用该指令。 ## 包管理工具 -RPM 和 DPKG 为最常见的两类软件包管理工具。RPM 全称为 Redhat Package Manager，最早由 Red Hat 公司制定实施，随后被 GNU 开源操作系统接受并成为很多 Linux 系统 (RHEL) 的既定软件标准。与 RPM 进行竞争的是基于 Debian 操作系统 (UBUNTU) 的 DEB 软件包管理工具 DPKG，全称为 Debian Package，功能方面与 RPM 相似。 +RPM 和 DPKG 为最常见的两类软件包管理工具： + +- RPM 全称为 Redhat Package Manager，最早由 Red Hat 公司制定实施，随后被 GNU 开源操作系统接受并成为很多 Linux 系统 (RHEL) 的既定软件标准。 +- 与 RPM 进行竞争的是基于 Debian 操作系统 (Ubuntu) 的 DEB 软件包管理工具 DPKG，全称为 Debian Package，功能方面与 RPM 相似。 YUM 基于 RPM，具有依赖管理功能，并具有软件升级的功能。 @@ -194,13 +195,13 @@ IDE（ATA）全称 Advanced Technology Attachment，接口速度最大为 133MB/ ### 2. SATA -SATA 全称 Serial ATA，也就是使用串口的 ATA 接口，因抗干扰性强，且对数据线的长度要求比 ATA 低很多，支持热插拔等功能，SATA-II 的接口速度为 300MiB/s，而新的 SATA-III 标准可达到 600MiB/s 的传输速度。SATA 的数据线也比 ATA 的细得多，有利于机箱内的空气流通，整理线材也比较方便。 +SATA 全称 Serial ATA，也就是使用串口的 ATA 接口，抗干扰性强，且对数据线的长度要求比 ATA 低很多，支持热插拔等功能。SATA-II 的接口速度为 300MiB/s，而新的 SATA-III 标准可达到 600MiB/s 的传输速度。SATA 的数据线也比 ATA 的细得多，有利于机箱内的空气流通，整理线材也比较方便。

### 3. SCSI -SCSI 全称是 Small Computer System Interface（小型机系统接口），经历多代的发展，从早期的 SCSI-II，到目前的 Ultra320 SCSI 以及 Fiber-Channel（光纤通道），接口型式也多种多样。SCSI 硬盘广为工作站级个人电脑以及服务器所使用，因此会使用较为先进的技术，如碟片转速 15000rpm 的高转速，且资料传输时 CPU 占用率较低，但是单价也比相同容量的 ATA 及 SATA 硬盘更加昂贵。 +SCSI 全称是 Small Computer System Interface（小型机系统接口），经历多代的发展，从早期的 SCSI-II 到目前的 Ultra320 SCSI 以及 Fiber-Channel（光纤通道），接口型式也多种多样。SCSI 硬盘广为工作站级个人电脑以及服务器所使用，因此会使用较为先进的技术，如碟片转速 15000rpm 的高转速，且传输时 CPU 占用率较低，但是单价也比相同容量的 ATA 及 SATA 硬盘更加昂贵。

@@ -229,7 +230,7 @@ Linux 中每个硬件都被当做一个文件，包括磁盘。磁盘以磁盘 MBR 中，第一个扇区最重要，里面有主要开机记录（Master boot record, MBR）及分区表（partition table），其中主要开机记录占 446 bytes，分区表占 64 bytes。 -分区表只有 64 bytes，最多只能存储 4 个分区，这 4 个分区为主分区（Primary）和扩展分区（Extended）。其中扩展分区只有一个，它将其它扇区用来记录分区表，因此通过扩展分区可以分出更多分区，这些分区称为逻辑分区。 +分区表只有 64 bytes，最多只能存储 4 个分区，这 4 个分区为主分区（Primary）和扩展分区（Extended）。其中扩展分区只有一个，它使用其它扇区用记录额外的分区表，因此通过扩展分区可以分出更多分区，这些分区称为逻辑分区。 Linux 也把分区当成文件，分区文件的命名方式为：磁盘文件名 + 编号，例如 /dev/sda1。注意，逻辑分区的编号从 5 开始。 @@ -251,10 +252,10 @@ MBR 不支持 2.2 TB 以上的硬盘，GPT 则最多支持到 233 TB BIOS（Basic Input/Output System，基本输入输出系统），它是一个固件（嵌入在硬件中的软件），BIOS 程序存放在断电后内容不会丢失的只读内存中。 -BIOS 是开机的时候计算机执行的第一个程序，这个程序知道可以开机的磁盘，并读取磁盘第一个扇区的主要开机记录（MBR），由主要开机记录（MBR）执行其中的开机管理程序，这个开机管理程序会加载操作系统的核心文件。 -

+BIOS 是开机的时候计算机执行的第一个程序，这个程序知道可以开机的磁盘，并读取磁盘第一个扇区的主要开机记录（MBR），由主要开机记录（MBR）执行其中的开机管理程序，这个开机管理程序会加载操作系统的核心文件。 + 主要开机记录（MBR）中的开机管理程序提供以下功能：选单、载入核心文件以及转交其它开机管理程序。转交这个功能可以用来实现了多重引导，只需要将另一个操作系统的开机管理程序安装在其它分区的启动扇区上，在启动开机管理程序时，就可以通过选单选择启动当前的操作系统或者转交给其它开机管理程序从而启动另一个操作系统。 下图中，第一扇区的主要开机记录（MBR）中的开机管理程序提供了两个选单：M1、M2，M1 指向了 Windows 操作系统，而 M2 指向其它分区的启动扇区，里面包含了另外一个开机管理程序，提供了一个指向 Linux 的选单。 @@ -283,11 +284,10 @@ BIOS 不可以读取 GPT 分区表，而 UEFI 可以。 除此之外还包括： - superblock：记录文件系统的整体信息，包括 inode 和 block 的总量、使用量、剩余量，以及文件系统的格式与相关信息等； -- block bitmap：记录 block 是否被使用的位域； +- block bitmap：记录 block 是否被使用的位域。

- ## 文件读取 对于 Ext2 文件系统，当要读取一个文件的内容时，先在 inode 中去查找文件内容所在的所有 block，然后把所有 block 的内容读出来。 diff --git a/notes/MySQL.md b/notes/MySQL.md index 7ac9685f..54067977 100644 --- a/notes/MySQL.md +++ b/notes/MySQL.md @@ -1,22 +1,23 @@ -* [一、存储引擎](#一存储引擎) +* [一、索引](#一索引) + * [B+ Tree 原理](#b-tree-原理) + * [MySQL 索引](#mysql-索引) + * [索引优化](#索引优化) + * [索引的优点](#索引的优点) + * [索引的使用场景](#索引的使用场景) +* [二、查询性能优化](#二查询性能优化) + * [使用 Explain 进行分析](#使用-explain-进行分析) + * [优化数据访问](#优化数据访问) + * [重构查询方式](#重构查询方式) +* [三、存储引擎](#三存储引擎) * [InnoDB](#innodb) * [MyISAM](#myisam) * [比较](#比较) -* [二、数据类型](#二数据类型) +* [四、数据类型](#四数据类型) * [整型](#整型) * [浮点数](#浮点数) * [字符串](#字符串) * [时间和日期](#时间和日期) -* [三、索引](#三索引) - * [B+ Tree 原理](#b-tree-原理) - * [索引分类](#索引分类) - * [索引的优点](#索引的优点) - * [索引优化](#索引优化) -* [四、查询性能优化](#四查询性能优化) - * [使用 Explain 进行分析](#使用-explain-进行分析) - * [优化数据访问](#优化数据访问) - * [重构查询方式](#重构查询方式) * [五、切分](#五切分) * [水平切分](#水平切分) * [垂直切分](#垂直切分) @@ -29,101 +30,7 @@ -# 一、存储引擎 - -## InnoDB - -InnoDB 是 MySQL 默认的事务型存储引擎，只有在需要 InnoDB 不支持的特性时，才考虑使用其它存储引擎。 - -实现了四个标准的隔离级别，默认级别是可重复读（REPEATABLE READ）。在可重复读隔离级别下，通过多版本并发控制（MVCC）+ 间隙锁（next-key locking）防止幻影读。 - -主索引是聚簇索引，在索引中保存了数据，从而避免直接读取磁盘，因此对查询性能有很大的提升。 - -内部做了很多优化，包括从磁盘读取数据时采用的可预测性读、能够加快读操作并且自动创建的自适应哈希索引、能够加速插入操作的插入缓冲区等。 - -支持真正的在线热备份。其它存储引擎不支持在线热备份，要获取一致性视图需要停止对所有表的写入，而在读写混合场景中，停止写入可能也意味着停止读取。 - -## MyISAM - -MyISAM 设计简单，数据以紧密格式存储。对于只读数据，或者表比较小、可以容忍修复操作，则依然可以使用 MyISAM。 - -MyISAM 提供了大量的特性，包括压缩表、空间数据索引等。 - -不支持事务。 - -不支持行级锁，只能对整张表加锁，读取时会对需要读到的所有表加共享锁，写入时则对表加排它锁。但在表有读取操作的同时，也可以往表中插入新的记录，这被称为并发插入（CONCURRENT INSERT）。 - -可以手工或者自动执行检查和修复操作，但是和事务恢复以及崩溃恢复不同，可能导致一些数据丢失，而且修复操作是非常慢的。 - -如果指定了 DELAY_KEY_WRITE 选项，在每次修改执行完成时，不会立即将修改的索引数据写入磁盘，而是会写到内存中的键缓冲区，只有在清理键缓冲区或者关闭表的时候才会将对应的索引块写入磁盘。这种方式可以极大的提升写入性能，但是在数据库或者主机崩溃时会造成索引损坏，需要执行修复操作。 - -## 比较 - -- 事务：InnoDB 是事务型的，可以使用 Commit 和 Rollback 语句。 - -- 并发：MyISAM 只支持表级锁，而 InnoDB 还支持行级锁。 - -- 外键：InnoDB 支持外键。 - -- 备份：InnoDB 支持在线热备份。 - -- 崩溃恢复：MyISAM 崩溃后发生损坏的概率比 InnoDB 高很多，而且恢复的速度也更慢。 - -- 其它特性：MyISAM 支持压缩表和空间数据索引。 - -# 二、数据类型 - -## 整型 - -TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT 分别使用 8, 16, 24, 32, 64 位存储空间，一般情况下越小的列越好。 - -INT(11) 中的数字只是规定了交互工具显示字符的个数，对于存储和计算来说是没有意义的。 - -## 浮点数 - -FLOAT 和 DOUBLE 为浮点类型，DECIMAL 为高精度小数类型。CPU 原生支持浮点运算，但是不支持 DECIMAl 类型的计算，因此 DECIMAL 的计算比浮点类型需要更高的代价。 - -FLOAT、DOUBLE 和 DECIMAL 都可以指定列宽，例如 DECIMAL(18, 9) 表示总共 18 位，取 9 位存储小数部分，剩下 9 位存储整数部分。 - -## 字符串 - -主要有 CHAR 和 VARCHAR 两种类型，一种是定长的，一种是变长的。 - -VARCHAR 这种变长类型能够节省空间，因为只需要存储必要的内容。但是在执行 UPDATE 时可能会使行变得比原来长，当超出一个页所能容纳的大小时，就要执行额外的操作。MyISAM 会将行拆成不同的片段存储，而 InnoDB 则需要分裂页来使行放进页内。 - -VARCHAR 会保留字符串末尾的空格，而 CHAR 会删除。 - -## 时间和日期 - -MySQL 提供了两种相似的日期时间类型：DATETIME 和 TIMESTAMP。 - -### 1. DATETIME - -能够保存从 1001 年到 9999 年的日期和时间，精度为秒，使用 8 字节的存储空间。 - -它与时区无关。 - -默认情况下，MySQL 以一种可排序的、无歧义的格式显示 DATETIME 值，例如“2008-01-16 22:37:08”，这是 ANSI 标准定义的日期和时间表示方法。 - -### 2. TIMESTAMP - -和 UNIX 时间戳相同，保存从 1970 年 1 月 1 日午夜（格林威治时间）以来的秒数，使用 4 个字节，只能表示从 1970 年 到 2038 年。 - -它和时区有关，也就是说一个时间戳在不同的时区所代表的具体时间是不同的。 - -MySQL 提供了 FROM_UNIXTIME() 函数把 UNIX 时间戳转换为日期，并提供了 UNIX_TIMESTAMP() 函数把日期转换为 UNIX 时间戳。 - -默认情况下，如果插入时没有指定 TIMESTAMP 列的值，会将这个值设置为当前时间。 - -应该尽量使用 TIMESTAMP，因为它比 DATETIME 空间效率更高。 - -# 三、索引 - -索引能够轻易将查询性能提升几个数量级。 - -对于非常小的表、大部分情况下简单的全表扫描比建立索引更高效。对于中到大型的表，索引就非常有效。但是对于特大型的表，建立和维护索引的代价将会随之增长。这种情况下，需要用到一种技术可以直接区分出需要查询的一组数据，而不是一条记录一条记录地匹配，例如可以使用分区技术。 - -索引是在存储引擎层实现的，而不是在服务器层实现的，所以不同存储引擎具有不同的索引类型和实现。 +# 一、索引 ## B+ Tree 原理 @@ -141,37 +48,37 @@ B+ Tree 是基于 B Tree 和叶子节点顺序访问指针进行实现，它具 进行查找操作时，首先在根节点进行二分查找，找到一个 key 所在的指针，然后递归地在指针所指向的节点进行查找。直到查找到叶子节点，然后在叶子节点上进行二分查找，找出 key 所对应的 data。 -插入删除操作记录会破坏平衡树的平衡性，因此在插入删除时，需要对树进行一个分裂、合并、旋转等操作。 +插入删除操作记录会破坏平衡树的平衡性，因此在插入删除操作之后，需要对树进行一个分裂、合并、旋转等操作来维护平衡性。 ### 3. 与红黑树的比较 红黑树等平衡树也可以用来实现索引，但是文件系统及数据库系统普遍采用 B+ Tree 作为索引结构，主要有以下两个原因： -（一）更少的检索次数 +（一）更少的查找次数 -平衡树检索数据的时间复杂度等于树高 h，而树高大致为 O(h)=O(logdN)，其中 d 为每个节点的出度。 +平衡树查找操作的时间复杂度等于树高 h，而树高大致为 O(h)=O(logdN)，其中 d 为每个节点的出度。 -红黑树的出度为 2，而 B+ Tree 的出度一般都非常大。红黑树的树高 h 很明显比 B+ Tree 大非常多，因此检索的次数也就更多。 +红黑树的出度为 2，而 B+ Tree 的出度一般都非常大，所以红黑树的树高 h 很明显比 B+ Tree 大非常多，检索的次数也就更多。 （二）利用计算机预读特性 -为了减少磁盘 I/O，磁盘往往不是严格按需读取，而是每次都会预读。这样做的理论依据是计算机科学中著名的局部性原理：当一个数据被用到时，其附近的数据也通常会马上被使用。预读过程中，磁盘进行顺序读取，顺序读取不需要进行磁盘寻道，并且只需要很短的旋转时间，因此速度会非常快。 +为了减少磁盘 I/O，磁盘往往不是严格按需读取，而是每次都会预读。预读过程中，磁盘进行顺序读取，顺序读取不需要进行磁盘寻道，并且只需要很短的旋转时间，因此速度会非常快。 操作系统一般将内存和磁盘分割成固态大小的块，每一块称为一页，内存与磁盘以页为单位交换数据。数据库系统将索引的一个节点的大小设置为页的大小，使得一次 I/O 就能完全载入一个节点，并且可以利用预读特性，相邻的节点也能够被预先载入。 -## 索引分类 +## MySQL 索引 + +索引是在存储引擎层实现的，而不是在服务器层实现的，所以不同存储引擎具有不同的索引类型和实现。 ### 1. B+Tree 索引 -B+Tree 索引是大多数 MySQL 存储引擎的默认索引类型。 +是大多数 MySQL 存储引擎的默认索引类型。 因为不再需要进行全表扫描，只需要对树进行搜索即可，因此查找速度快很多。除了用于查找，还可以用于排序和分组。 可以指定多个列作为索引列，多个索引列共同组成键。 -B+Tree 索引适用于全键值、键值范围和键前缀查找，其中键前缀查找只适用于最左前缀查找。 - -如果不是按照索引列的顺序进行查找，则无法使用索引。 +适用于全键值、键值范围和键前缀查找，其中键前缀查找只适用于最左前缀查找。如果不是按照索引列的顺序进行查找，则无法使用索引。 InnoDB 的 B+Tree 索引分为主索引和辅助索引。 @@ -185,12 +92,12 @@ InnoDB 的 B+Tree 索引分为主索引和辅助索引。 ### 2. 哈希索引 -InnoDB 引擎有一个特殊的功能叫“自适应哈希索引”，当某个索引值被使用的非常频繁时，会在 B+Tree 索引之上再创建一个哈希索引，这样就让 B+Tree 索引具有哈希索引的一些优点，比如快速的哈希查找。 - 哈希索引能以 O(1) 时间进行查找，但是失去了有序性，它具有以下限制： - 无法用于排序与分组； -- 只支持精确查找，无法用于部分查找和范围查找； +- 只支持精确查找，无法用于部分查找和范围查找。 + +InnoDB 存储引擎有一个特殊的功能叫“自适应哈希索引”，当某个索引值被使用的非常频繁时，会在 B+Tree 索引之上再创建一个哈希索引，这样就让 B+Tree 索引具有哈希索引的一些优点，比如快速的哈希查找。 ### 3. 全文索引 @@ -200,20 +107,12 @@ MyISAM 存储引擎支持全文索引，用于查找文本中的关键词，而 InnoDB 存储引擎在 MySQL 5.6.4 版本中也开始支持全文索引。 -### 4. 空间数据索引（R-Tree） +### 4. 空间数据索引 -MyISAM 存储引擎支持空间数据索引，可以用于地理数据存储。空间数据索引会从所有维度来索引数据，可以有效地使用任意维度来进行组合查询。 +MyISAM 存储引擎支持空间数据索引（R-Tree），可以用于地理数据存储。空间数据索引会从所有维度来索引数据，可以有效地使用任意维度来进行组合查询。 必须使用 GIS 相关的函数来维护数据。 -## 索引的优点 - -- 大大减少了服务器需要扫描的数据行数。 - -- 帮助服务器避免进行排序和创建临时表（B+Tree 索引是有序的，可以用来做 ORDER BY 和 GROUP BY 操作）； - -- 将随机 I/O 变为顺序 I/O（B+Tree 索引是有序的，也就将相邻的数据都存储在一起）。 - ## 索引优化 ### 1. 独立的列 @@ -266,11 +165,25 @@ customer_id_selectivity: 0.0373 具有以下优点： -- 因为索引条目通常远小于数据行的大小，所以若只读取索引，能大大减少数据访问量。 +- 索引通常远小于数据行的大小，只读取索引能大大减少数据访问量。 - 一些存储引擎（例如 MyISAM）在内存中只缓存索引，而数据依赖于操作系统来缓存。因此，只访问索引可以不使用系统调用（通常比较费时）。 - 对于 InnoDB 引擎，若辅助索引能够覆盖查询，则无需访问主索引。 -# 四、查询性能优化 +## 索引的优点 + +- 大大减少了服务器需要扫描的数据行数。 + +- 帮助服务器避免进行排序和分组，也就不需要创建临时表（B+Tree 索引是有序的，可以用于 ORDER BY 和 GROUP BY 操作。临时表主要是在排序和分组过程中创建，因为不需要排序和分组，也就不需要创建临时表）。 + +- 将随机 I/O 变为顺序 I/O（B+Tree 索引是有序的，也就将相邻的数据都存储在一起）。 + +## 索引的使用场景 + +- 对于非常小的表、大部分情况下简单的全表扫描比建立索引更高效。 +- 对于中到大型的表，索引就非常有效。 +- 但是对于特大型的表，建立和维护索引的代价将会随之增长。这种情况下，需要用到一种技术可以直接区分出需要查询的一组数据，而不是一条记录一条记录地匹配，例如可以使用分区技术。 + +# 二、查询性能优化 ## 使用 Explain 进行分析 @@ -282,23 +195,13 @@ Explain 用来分析 SELECT 查询语句，开发人员可以通过分析 Explai - key : 使用的索引 - rows : 扫描的行数 -更多内容请参考：[MySQL 性能优化神器 Explain 使用分析](https://segmentfault.com/a/1190000008131735) - ## 优化数据访问 ### 1. 减少请求的数据量 -（一）只返回必要的列 - -最好不要使用 SELECT * 语句。 - -（二）只返回必要的行 - -使用 WHERE 语句进行查询过滤，有时候也需要使用 LIMIT 语句来限制返回的数据。 - -（三）缓存重复查询的数据 - -使用缓存可以避免在数据库中进行查询，特别要查询的数据经常被重复查询，缓存可以带来的查询性能提升将会是非常明显的。 +- 只返回必要的列：最好不要使用 SELECT * 语句。 +- 只返回必要的行：使用 LIMIT 语句来限制返回的数据。 +- 缓存重复查询的数据：使用缓存可以避免在数据库中进行查询，特别在要查询的数据经常被重复查询时，缓存带来的查询性能提升将会是非常明显的。 ### 2. 减少服务器端扫描的行数 @@ -324,12 +227,12 @@ do { ### 2. 分解大连接查询 -将一个大连接查询（JOIN）分解成对每一个表进行一次单表查询，然后将结果在应用程序中进行关联，这样做的好处有： +将一个大连接查询分解成对每一个表进行一次单表查询，然后将结果在应用程序中进行关联，这样做的好处有： - 让缓存更高效。对于连接查询，如果其中一个表发生变化，那么整个查询缓存就无法使用。而分解后的多个查询，即使其中一个表发生变化，对其它表的查询缓存依然可以使用。 - 分解成多个单表查询，这些单表查询的缓存结果更可能被其它查询使用到，从而减少冗余记录的查询。 - 减少锁竞争； -- 在应用层进行连接，可以更容易对数据库进行拆分，从而更容易做到高性能和可扩展。 +- 在应用层进行连接，可以更容易对数据库进行拆分，从而更容易做到高性能和可伸缩。 - 查询本身效率也可能会有所提升。例如下面的例子中，使用 IN() 代替连接查询，可以让 MySQL 按照 ID 顺序进行查询，这可能比随机的连接要更高效。 ```sql @@ -345,23 +248,111 @@ SELECT * FROM tag_post WHERE tag_id=1234; SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904); ``` +# 三、存储引擎 + +## InnoDB + +是 MySQL 默认的事务型存储引擎，只有在需要它不支持的特性时，才考虑使用其它存储引擎。 + +实现了四个标准的隔离级别，默认级别是可重复读（REPEATABLE READ）。在可重复读隔离级别下，通过多版本并发控制（MVCC）+ 间隙锁（Next-Key Locking）防止幻影读。 + +主索引是聚簇索引，在索引中保存了数据，从而避免直接读取磁盘，因此对查询性能有很大的提升。 + +内部做了很多优化，包括从磁盘读取数据时采用的可预测性读、能够加快读操作并且自动创建的自适应哈希索引、能够加速插入操作的插入缓冲区等。 + +支持真正的在线热备份。其它存储引擎不支持在线热备份，要获取一致性视图需要停止对所有表的写入，而在读写混合场景中，停止写入可能也意味着停止读取。 + +## MyISAM + +设计简单，数据以紧密格式存储。对于只读数据，或者表比较小、可以容忍修复操作，则依然可以使用它。 + +提供了大量的特性，包括压缩表、空间数据索引等。 + +不支持事务。 + +不支持行级锁，只能对整张表加锁，读取时会对需要读到的所有表加共享锁，写入时则对表加排它锁。但在表有读取操作的同时，也可以往表中插入新的记录，这被称为并发插入（CONCURRENT INSERT）。 + +可以手工或者自动执行检查和修复操作，但是和事务恢复以及崩溃恢复不同，可能导致一些数据丢失，而且修复操作是非常慢的。 + +如果指定了 DELAY_KEY_WRITE 选项，在每次修改执行完成时，不会立即将修改的索引数据写入磁盘，而是会写到内存中的键缓冲区，只有在清理键缓冲区或者关闭表的时候才会将对应的索引块写入磁盘。这种方式可以极大的提升写入性能，但是在数据库或者主机崩溃时会造成索引损坏，需要执行修复操作。 + +## 比较 + +- 事务：InnoDB 是事务型的，可以使用 Commit 和 Rollback 语句。 + +- 并发：MyISAM 只支持表级锁，而 InnoDB 还支持行级锁。 + +- 外键：InnoDB 支持外键。 + +- 备份：InnoDB 支持在线热备份。 + +- 崩溃恢复：MyISAM 崩溃后发生损坏的概率比 InnoDB 高很多，而且恢复的速度也更慢。 + +- 其它特性：MyISAM 支持压缩表和空间数据索引。 + +# 四、数据类型 + +## 整型 + +TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT 分别使用 8, 16, 24, 32, 64 位存储空间，一般情况下越小的列越好。 + +INT(11) 中的数字只是规定了交互工具显示字符的个数，对于存储和计算来说是没有意义的。 + +## 浮点数 + +FLOAT 和 DOUBLE 为浮点类型，DECIMAL 为高精度小数类型。CPU 原生支持浮点运算，但是不支持 DECIMAl 类型的计算，因此 DECIMAL 的计算比浮点类型需要更高的代价。 + +FLOAT、DOUBLE 和 DECIMAL 都可以指定列宽，例如 DECIMAL(18, 9) 表示总共 18 位，取 9 位存储小数部分，剩下 9 位存储整数部分。 + +## 字符串 + +主要有 CHAR 和 VARCHAR 两种类型，一种是定长的，一种是变长的。 + +VARCHAR 这种变长类型能够节省空间，因为只需要存储必要的内容。但是在执行 UPDATE 时可能会使行变得比原来长，当超出一个页所能容纳的大小时，就要执行额外的操作。MyISAM 会将行拆成不同的片段存储，而 InnoDB 则需要分裂页来使行放进页内。 + +VARCHAR 会保留字符串末尾的空格，而 CHAR 会删除。 + +## 时间和日期 + +MySQL 提供了两种相似的日期时间类型：DATETIME 和 TIMESTAMP。 + +### 1. DATETIME + +能够保存从 1001 年到 9999 年的日期和时间，精度为秒，使用 8 字节的存储空间。 + +它与时区无关。 + +默认情况下，MySQL 以一种可排序的、无歧义的格式显示 DATETIME 值，例如“2008-01-16 22:37:08”，这是 ANSI 标准定义的日期和时间表示方法。 + +### 2. TIMESTAMP + +和 UNIX 时间戳相同，保存从 1970 年 1 月 1 日午夜（格林威治时间）以来的秒数，使用 4 个字节，只能表示从 1970 年 到 2038 年。 + +它和时区有关，也就是说一个时间戳在不同的时区所代表的具体时间是不同的。 + +MySQL 提供了 FROM_UNIXTIME() 函数把 UNIX 时间戳转换为日期，并提供了 UNIX_TIMESTAMP() 函数把日期转换为 UNIX 时间戳。 + +默认情况下，如果插入时没有指定 TIMESTAMP 列的值，会将这个值设置为当前时间。 + +应该尽量使用 TIMESTAMP，因为它比 DATETIME 空间效率更高。 + # 五、切分 ## 水平切分 -

- 水平切分又称为 Sharding，它是将同一个表中的记录拆分到多个结构相同的表中。 当一个表的数据不断增多时，Sharding 是必然的选择，它可以将数据分布到集群的不同节点上，从而缓存单个数据库的压力。 +

+ ## 垂直切分

垂直切分是将一张表按列切分成多个表，通常是按照列的关系密集程度进行切分，也可以利用垂直切分将经常被使用的列和不经常被使用的列切分到不同的表中。 -在数据库的层面使用垂直切分将按数据库中表的密集程度部署到不同的库中，例如将原来的电商数据库垂直切分成商品数据库 payDB、用户数据库 userDB 等。 +在数据库的层面使用垂直切分将按数据库中表的密集程度部署到不同的库中，例如将原来的电商数据库垂直切分成商品数据库、用户数据库等。 ## Sharding 策略 @@ -375,15 +366,15 @@ SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904); 使用分布式事务来解决，比如 XA 接口。 -### 2. JOIN +### 2. 链接 -可以将原来的 JOIN 查询分解成多个单表查询，然后在用户程序中进行 JOIN。 +可以将原来的 JOIN 分解成多个单表查询，然后在用户程序中进行 JOIN。 ### 3. ID 唯一性 -- 使用全局唯一 ID：GUID。 -- 为每个分片指定一个 ID 范围。 -- 分布式 ID 生成器 (如 Twitter 的 Snowflake 算法)。 +- 使用全局唯一 ID：GUID +- 为每个分片指定一个 ID 范围 +- 分布式 ID 生成器 (如 Twitter 的 Snowflake 算法) 更多内容请参考： @@ -396,24 +387,24 @@ SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904); 主要涉及三个线程：binlog 线程、I/O 线程和 SQL 线程。 -- **binlog 线程** ：负责将主服务器上的数据更改写入二进制文件（binlog）中。 -- **I/O 线程** ：负责从主服务器上读取二进制日志文件，并写入从服务器的中继日志中。 +- **binlog 线程** ：负责将主服务器上的数据更改写入二进制日志中。 +- **I/O 线程** ：负责从主服务器上读取二进制日志，并写入从服务器的中继日志中。 - **SQL 线程** ：负责读取中继日志并重放其中的 SQL 语句。

## 读写分离 -主服务器用来处理写操作以及实时性要求比较高的读操作，而从服务器用来处理读操作。 +主服务器处理写操作以及实时性要求比较高的读操作，而从服务器处理读操作。 -读写分离常用代理方式来实现，代理服务器接收应用层传来的读写请求，然后决定转发到哪个服务器。 - -MySQL 读写分离能提高性能的原因在于： +读写分离能提高性能的原因在于： - 主从服务器负责各自的读和写，极大程度缓解了锁的争用； -- 从服务器可以配置 MyISAM 引擎，提升查询性能以及节约系统开销； +- 从服务器可以使用 MyISAM，提升查询性能以及节约系统开销； - 增加冗余，提高可用性。 +读写分离常用代理方式来实现，代理服务器接收应用层传来的读写请求，然后决定转发到哪个服务器。 +

# 参考资料 @@ -425,3 +416,4 @@ MySQL 读写分离能提高性能的原因在于： - [How to create unique row ID in sharded databases?](https://stackoverflow.com/questions/788829/how-to-create-unique-row-id-in-sharded-databases) - [SQL Azure Federation – Introduction](http://geekswithblogs.net/shaunxu/archive/2012/01/07/sql-azure-federation-ndash-introduction.aspx "Title of this entry.") - [MySQL 索引背后的数据结构及算法原理](http://blog.codinglabs.org/articles/theory-of-mysql-index.html) +- [MySQL 性能优化神器 Explain 使用分析](https://segmentfault.com/a/1190000008131735) diff --git a/notes/Redis.md b/notes/Redis.md index 0981abf0..8f231382 100644 --- a/notes/Redis.md +++ b/notes/Redis.md @@ -49,7 +49,7 @@ Redis 是速度非常快的非关系型（NoSQL）内存键值数据库，可以存储键和五种不同类型的值之间的映射。 -键的类型只能为字符串，值支持的五种类型数据类型为：字符串、列表、集合、有序集合、散列表。 +键的类型只能为字符串，值支持的五种类型数据类型为：字符串、列表、集合、散列表、有序集合。 Redis 支持很多特性，例如将内存中的数据持久化到硬盘中，使用复制来扩展读性能，使用分片来扩展写性能。 @@ -58,7 +58,7 @@ Redis 支持很多特性，例如将内存中的数据持久化到硬盘中， | 数据类型 | 可以存储的值 | 操作 | | :--: | :--: | :--: | | STRING | 字符串、整数或者浮点数 | 对整个字符串或者字符串的其中一部分执行操作
对整数和浮点数执行自增或者自减操作 | -| LIST | 列表 | 从两端压入或者弹出元素
读取单个或者多个元素
进行修剪，只保留一个范围内的元素 | +| LIST | 列表 | 从两端压入或者弹出元素
对单个或者多个元素
进行修剪，只保留一个范围内的元素 | | SET | 无序集合 | 添加、获取、移除单个元素
检查一个元素是否存在于集合中
计算交集、并集、差集
从集合里面随机获取元素 | | HASH | 包含键值对的无序散列表 | 添加、获取、移除单个键值对
获取所有键值对
检查某个键是否存在| | ZSET | 有序集合 | 添加、获取、删除元素
根据分值范围或者成员来获取元素
计算一个键的排名 | @@ -555,7 +555,7 @@ Sentinel（哨兵）可以监听主服务器，并在主服务器进入下线状 分片是将数据划分为多个部分的方法，可以将数据存储到多台机器里面，这种方法在解决某些问题时可以获得线性级别的性能提升。 -假设有 4 个 Reids 实例 R0，R1，R2，R3，还有很多表示用户的键 user:1，user:2，... 等等，有不同的方式来选择一个指定的键存储在哪个实例中。 +假设有 4 个 Reids 实例 R0，R1，R2，R3，还有很多表示用户的键 user:1，user:2，... ，有不同的方式来选择一个指定的键存储在哪个实例中。 - 最简单的方式是范围分片，例如用户 id 从 0\~1000 的存储到实例 R0 中，用户 id 从 1001\~2000 的存储到实例 R1 中，等等。但是这样需要维护一张映射范围表，维护操作代价很高。 - 还有一种方式是哈希分片，使用 CRC32 哈希函数将键转换为一个数字，再对实例数量求模就能知道应该存储的实例。 diff --git a/notes/数据库系统原理.md b/notes/数据库系统原理.md index e7ef804b..1bcd2533 100644 --- a/notes/数据库系统原理.md +++ b/notes/数据库系统原理.md @@ -20,6 +20,7 @@ * [可串行化（SERIALIZABLE）](#可串行化serializable) * [五、多版本并发控制](#五多版本并发控制) * [版本号](#版本号) + * [隐藏的列](#隐藏的列) * [Undo 日志](#undo-日志) * [实现过程](#实现过程) * [快照读与当前读](#快照读与当前读) @@ -58,9 +59,7 @@ ### 2. 一致性（Consistency） -数据库在事务执行前后都保持一致性状态。 - -在一致性状态下，所有事务对一个数据的读取结果都是相同的。 +数据库在事务执行前后都保持一致性状态。在一致性状态下，所有事务对一个数据的读取结果都是相同的。 ### 3. 隔离性（Isolation） @@ -78,10 +77,10 @@ - 只有满足一致性，事务的执行结果才是正确的。 - 在无并发的情况下，事务串行执行，隔离性一定能够满足。此时只要能满足原子性，就一定能满足一致性。 -- 在并发的情况下，多个事务并发执行，事务不仅要满足原子性，还需要满足隔离性，才能满足一致性。 +- 在并发的情况下，多个事务并行执行，事务不仅要满足原子性，还需要满足隔离性，才能满足一致性。 - 事务满足持久化是为了能应对数据库崩溃的情况。 -

+

## AUTOCOMMIT @@ -95,25 +94,25 @@ MySQL 默认采用自动提交模式。也就是说，如果不显式使用`STAR T1 和 T2 两个事务都对一个数据进行修改，T1 先修改，T2 随后修改，T2 的修改覆盖了 T1 的修改。 -

+

## 读脏数据 T1 修改一个数据，T2 随后读取这个数据。如果 T1 撤销了这次修改，那么 T2 读取的数据是脏数据。 -

+

## 不可重复读 T2 读取一个数据，T1 对该数据做了修改。如果 T2 再次读取这个数据，此时读取的结果和第一次读取的结果不同。 -

+

## 幻影读 T1 读取某个范围的数据，T2 在这个范围内插入新的数据，T1 再次读取这个范围的数据，此时读取的结果和和第一次读取的结果不同。 -

+

---- @@ -123,7 +122,6 @@ T1 读取某个范围的数据，T2 在这个范围内插 ## 封锁粒度 - MySQL 中提供了两种封锁粒度：行级锁以及表级锁。 应该尽量只锁定需要修改的那部分数据，而不是所有的资源。锁定的数据量越少，发生锁争用的可能就越小，系统的并发程度就越高。 @@ -150,8 +148,8 @@ MySQL 中提供了两种封锁粒度：行级锁以及表级锁。 | - | X | S | | :--: | :--: | :--: | -|X|NO|NO| -|S|NO|YES| +|X|×|×| +|S|×|√| ### 2. 意向锁 @@ -170,10 +168,10 @@ MySQL 中提供了两种封锁粒度：行级锁以及表级锁。 | - | X | IX | S | IS | | :--: | :--: | :--: | :--: | :--: | -|X |NO |NO |NO | NO| -|IX |NO |YES |NO | YES| -|S |NO |NO |YES | YES| -|IS |NO |YES |YES | YES| +|X |× |× |× | ×| +|IX |× |√ |× | √| +|S |× |× |√ | √| +|IS |× |√ |√ | √| 解释如下： @@ -298,32 +296,30 @@ SELECT ... FOR UPDATE; | 隔离级别 | 脏读 | 不可重复读 | 幻影读 | | :---: | :---: | :---:| :---: | -| 未提交读 | YES | YES | YES | -| 提交读 | NO | YES | YES | -| 可重复读 | NO | NO | YES | -| 可串行化 | NO | NO | NO | +| 未提交读 | √ | √ | √ | +| 提交读 | × | √ | √ | +| 可重复读 | × | × | √ | +| 可串行化 | × | × | × | # 五、多版本并发控制 -多版本并发控制（Multi-Version Concurrency Control, MVCC）是 MySQL 的 InnoDB 存储引擎实现隔离级别的一种具体方式，用于实现提交读和可重复读这两种隔离级别。 - -而未提交读隔离级别总是读取最新的数据行，无需使用 MVCC。 - -可串行化隔离级别需要对所有读取的行都加锁，单纯使用 MVCC 无法实现。 +多版本并发控制（Multi-Version Concurrency Control, MVCC）是 MySQL 的 InnoDB 存储引擎实现隔离级别的一种具体方式，用于实现提交读和可重复读这两种隔离级别。而未提交读隔离级别总是读取最新的数据行，无需使用 MVCC。可串行化隔离级别需要对所有读取的行都加锁，单纯使用 MVCC 无法实现。 ## 版本号 - 系统版本号：是一个递增的数字，每开始一个新的事务，系统版本号就会自动递增。 - 事务版本号：事务开始时的系统版本号。 -InooDB 的 MVCC 在每行记录后面都保存着两个隐藏的列，用来存储两个版本号： +## 隐藏的列 + +MVCC 在每行记录后面都保存着两个隐藏的列，用来存储两个版本号： - 创建版本号：指示创建一个数据行的快照时的系统版本号； - 删除版本号：如果该快照的删除版本号大于当前事务版本号表示该快照有效，否则表示该快照已经被删除了。 ## Undo 日志 -InnoDB 的 MVCC 使用到的快照存储在 Undo 日志中，该日志通过回滚指针把一个数据行（Record）的所有快照连接起来。 +MVCC 使用到的快照存储在 Undo 日志中，该日志通过回滚指针把一个数据行（Record）的所有快照连接起来。

@@ -331,15 +327,13 @@ InnoDB 的 MVCC 使用到的快照存储在 Undo 日志中，该日志通过回 以下实现过程针对可重复读隔离级别。 -### 1. SELECT - 当开始新一个事务时，该事务的版本号肯定会大于当前所有数据行快照的创建版本号，理解这一点很关键。 +### 1. SELECT + 多个事务必须读取到同一个数据行的快照，并且这个快照是距离现在最近的一个有效快照。但是也有例外，如果有一个事务正在修改该数据行，那么它可以读取事务本身所做的修改，而不用和其它事务的读取结果一致。 -把没有对一个数据行做修改的事务称为 T，T 所要读取的数据行快照的创建版本号必须小于 T 的版本号，因为如果大于或者等于 T 的版本号，那么表示该数据行快照是其它事务的最新修改，因此不能去读取它。 - -除了上面的要求，T 所要读取的数据行快照的删除版本号必须大于 T 的版本号，因为如果小于等于 T 的版本号，那么表示该数据行快照是已经被删除的，不应该去读取它。 +把没有对一个数据行做修改的事务称为 T，T 所要读取的数据行快照的创建版本号必须小于 T 的版本号，因为如果大于或者等于 T 的版本号，那么表示该数据行快照是其它事务的最新修改，因此不能去读取它。除此之外，T 所要读取的数据行快照的删除版本号必须大于 T 的版本号，因为如果小于等于 T 的版本号，那么表示该数据行快照是已经被删除的，不应该去读取它。 ### 2. INSERT @@ -385,7 +379,7 @@ MVCC 不能解决幻读的问题，Next-Key Locks 就是为了解决这个问题 锁定一个记录上的索引，而不是记录本身。 -如果表没有设置索引，InnoDB 会自动在主键上创建隐藏的聚集索引，因此 Record Locks 依然可以使用。 +如果表没有设置索引，InnoDB 会自动在主键上创建隐藏的聚簇索引，因此 Record Locks 依然可以使用。 ## Gap Locks @@ -397,7 +391,7 @@ SELECT c FROM t WHERE c BETWEEN 10 and 20 FOR UPDATE; ## Next-Key Locks -它是 Record Locks 和 Gap Locks 的结合，不仅锁定一个记录上的索引，也锁定范围内的索引。例如一个索引包含以下值：10, 11, 13, and 20，那么就需要锁定以下区间： +它是 Record Locks 和 Gap Locks 的结合，不仅锁定一个记录上的索引，也锁定索引之间的间隙。例如一个索引包含以下值：10, 11, 13, and 20，那么就需要锁定以下区间： ```sql (negative infinity, 10] @@ -432,10 +426,10 @@ SELECT c FROM t WHERE c BETWEEN 10 and 20 FOR UPDATE; 不符合范式的关系，会产生很多异常，主要有以下四种异常： -- 冗余数据：例如 学生-2 出现了两次。 +- 冗余数据：例如 `学生-2` 出现了两次。 - 修改异常：修改了一个记录中的信息，但是另一个记录中相同的信息却没有被修改。 -- 删除异常：删除一个信息，那么也会丢失其它信息。例如如果删除了 课程-1，需要删除第一行和第三行，那么 学生-1 的信息就会丢失。 -- 插入异常，例如想要插入一个学生的信息，如果这个学生还没选课，那么就无法插入。 +- 删除异常：删除一个信息，那么也会丢失其它信息。例如删除了 `课程-1` 需要删除第一行和第三行，那么 `学生-1` 的信息就会丢失。 +- 插入异常：例如想要插入一个学生的信息，如果这个学生还没选课，那么就无法插入。 ## 范式 @@ -506,7 +500,11 @@ Sname, Sdept 和 Mname 都部分依赖于键码，当一个学生选修了多门 非主属性不传递函数依赖于键码。 -上面的 关系-1 中存在以下传递函数依赖：Sno -> Sdept -> Mname，可以进行以下分解： +上面的 关系-1 中存在以下传递函数依赖： + +- Sno -> Sdept -> Mname + +可以进行以下分解： 关系-11 @@ -533,13 +531,19 @@ Entity-Relationship，有三个组成部分：实体、属性、联系。 包含一对一，一对多，多对多三种。 -如果 A 到 B 是一对多关系，那么画个带箭头的线段指向 B；如果是一对一，画两个带箭头的线段；如果是多对多，画两个不带箭头的线段。下图的 Course 和 Student 是一对多的关系。 +- 如果 A 到 B 是一对多关系，那么画个带箭头的线段指向 B； +- 如果是一对一，画两个带箭头的线段； +- 如果是多对多，画两个不带箭头的线段。 + +下图的 Course 和 Student 是一对多的关系。

## 表示出现多次的关系 -一个实体在联系出现几次，就要用几条线连接。下图表示一个课程的先修关系，先修关系出现两个 Course 实体，第一个是先修课程，后一个是后修课程，因此需要用两条线来表示这种关系。 +一个实体在联系出现几次，就要用几条线连接。 + +下图表示一个课程的先修关系，先修关系出现两个 Course 实体，第一个是先修课程，后一个是后修课程，因此需要用两条线来表示这种关系。

@@ -549,7 +553,7 @@ Entity-Relationship，有三个组成部分：实体、属性、联系。

-一般只使用二元联系，可以把多元关系转换为二元关系。 +一般只使用二元联系，可以把多元联系转换为二元联系。

diff --git a/notes/设计模式.md b/notes/设计模式.md index b8f4dc9b..531595e3 100644 --- a/notes/设计模式.md +++ b/notes/设计模式.md @@ -60,9 +60,9 @@ （一）懒汉式-线程不安全 -以下实现中，私有静态变量 uniqueInstance 被延迟化实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 uniqueInstance，从而节约资源。 +以下实现中，私有静态变量 uniqueInstance 被延迟实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 uniqueInstance，从而节约资源。 -这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 `if (uniqueInstance == null)` ，并且此时 uniqueInstance 为 null，那么多个线程会执行 `uniqueInstance = new Singleton();` 语句，这将导致多次实例化 uniqueInstance。 +这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 `if (uniqueInstance == null)` ，并且此时 uniqueInstance 为 null，那么会有多个线程执行 `uniqueInstance = new Singleton();` 语句，这将导致多次实例化 uniqueInstance。 ```java public class Singleton { @@ -81,11 +81,21 @@ public class Singleton { } ``` -（二）懒汉式-线程安全 +（二）饿汉式-线程安全 -只需要对 getUniqueInstance() 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了对 uniqueInstance 进行多次实例化的问题。 +线程不安全问题主要是由于 uniqueInstance 被多次实例化，采取直接实例化 uniqueInstance 的方式就不会产生线程不安全问题。 -但是这样有一个问题，就是当一个线程进入该方法之后，其它线程试图进入该方法都必须等待，因此性能上有一定的损耗。 +但是直接实例化的方式也丢失了延迟实例化带来的节约资源的好处。 + +```java +private static Singleton uniqueInstance = new Singleton(); +``` + +（三）懒汉式-线程安全 + +只需要对 getUniqueInstance() 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了多次实例化 uniqueInstance 的问题。 + +但是当一个线程进入该方法之后，其它试图进入该方法的线程都必须等待，因此性能上有一定的损耗。 ```java public static synchronized Singleton getUniqueInstance() { @@ -96,16 +106,6 @@ public static synchronized Singleton getUniqueInstance() { } ``` -（三）饿汉式-线程安全 - -线程不安全问题主要是由于 uniqueInstance 被实例化了多次，如果 uniqueInstance 采用直接实例化的话，就不会被实例化多次，也就不会产生线程不安全问题。 - -但是直接实例化的方式也丢失了延迟实例化带来的节约资源的好处。 - -```java -private static Singleton uniqueInstance = new Singleton(); -``` - （四）双重校验锁-线程安全 uniqueInstance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行，只有当 uniqueInstance 没有被实例化时，才需要进行加锁。 @@ -175,7 +175,7 @@ public class Singleton { } ``` -（五）枚举实现 +（六）枚举实现 这是单例模式的最佳实践，它实现简单，并且在面对复杂的序列化或者反射攻击的时候，能够防止实例化多次。 @@ -231,27 +231,9 @@ public class Singleton implements Serializable { 简单工厂不是设计模式，更像是一种编程习惯。它把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个具体子类来实例化。 -

- 这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类。因为客户类往往有多个，如果不使用简单工厂，所有的客户类都要知道所有子类的细节。而且一旦子类发生改变，例如增加子类，那么所有的客户类都要进行修改。 -如果存在下面这种代码，就需要使用简单工厂将对象实例化的部分放到简单工厂中。 - -```java -public class Client { - public static void main(String[] args) { - int type = 1; - Product product; - if (type == 1) { - product = new ConcreteProduct1(); - } else if (type == 2) { - product = new ConcreteProduct2(); - } else { - product = new ConcreteProduct(); - } - } -} -``` +

### 实现 @@ -275,6 +257,27 @@ public class ConcreteProduct2 implements Product { } ``` +以下的 Client 类中包含了实例化的代码，这是一种错误的实现，如果在客户类中存在实例化代码，就需要将代码放到简单工厂中。 + +```java +public class Client { + public static void main(String[] args) { + int type = 1; + Product product; + if (type == 1) { + product = new ConcreteProduct1(); + } else if (type == 2) { + product = new ConcreteProduct2(); + } else { + product = new ConcreteProduct(); + } + // do something with the product + } +} +``` + +以下的 SimpleFactory 是简单工厂实现，它被所有需要进行实例化的客户类调用。 + ```java public class SimpleFactory { public Product createProduct(int type) { @@ -293,6 +296,7 @@ public class Client { public static void main(String[] args) { SimpleFactory simpleFactory = new SimpleFactory(); Product product = simpleFactory.createProduct(1); + // do something with the product } } ``` @@ -2906,7 +2910,7 @@ Java 利用缓存来加速大量小对象的访问时间。 - 远程代理（Remote Proxy）：控制对远程对象（不同地址空间）的访问，它负责将请求及其参数进行编码，并向不同地址空间中的对象发送已经编码的请求。 - 虚拟代理（Virtual Proxy）：根据需要创建开销很大的对象，它可以缓存实体的附加信息，以便延迟对它的访问，例如在网站加载一个很大图片时，不能马上完成，可以用虚拟代理缓存图片的大小信息，然后生成一张临时图片代替原始图片。 - 保护代理（Protection Proxy）：按权限控制对象的访问，它负责检查调用者是否具有实现一个请求所必须的访问权限。 -- 智能代理（Smart Reference）：取代了简单的指针，它在访问对象时执行一些附加操作：记录对象的引用次数，比如智能智能；当第一次引用一个持久化对象时，将它装入内存；在访问一个实际对象前，检查是否已经锁定了它，以确保其它对象不能改变它。 +- 智能代理（Smart Reference）：取代了简单的指针，它在访问对象时执行一些附加操作：记录对象的引用次数；当第一次引用一个持久化对象时，将它装入内存；在访问一个实际对象前，检查是否已经锁定了它，以确保其它对象不能改变它。

diff --git a/notes/面向对象思想.md b/notes/面向对象思想.md index 9b59e43d..203c7ebf 100644 --- a/notes/面向对象思想.md +++ b/notes/面向对象思想.md @@ -37,6 +37,7 @@ ```java public class Person { + private String name; private int gender; private int age; @@ -63,17 +64,20 @@ public class Person { 继承实现了 **IS-A** 关系，例如 Cat 和 Animal 就是一种 IS-A 关系，因此 Cat 可以继承自 Animal，从而获得 Animal 非 private 的属性和方法。 +继承应该遵循里氏替换原则，子类对象必须能够替换掉所有父类对象。 + Cat 可以当做 Animal 来使用，也就是说可以使用 Animal 引用 Cat 对象。父类引用指向子类对象称为 **向上转型** 。 ```java Animal animal = new Cat(); ``` -继承应该遵循里氏替换原则，子类对象必须能够替换掉所有父类对象。 - ## 多态 -多态分为编译时多态和运行时多态。编译时多态主要指方法的重载，运行时多态指程序中定义的对象引用所指向的具体类型在运行期间才确定。 +多态分为编译时多态和运行时多态： + +- 编译时多态主要指方法的重载 +- 运行时多态指程序中定义的对象引用所指向的具体类型在运行期间才确定 运行时多态有三个条件： @@ -116,7 +120,7 @@ public class Music { # 二、类图 -以下类图使用 [PlantUML](https://www.planttext.com/) 绘制，更多语法及使用请参考：http://plantuml.com/ +以下类图使用 [PlantUML](https://www.planttext.com/) 绘制，更多语法及使用请参考：http://plantuml.com/ 。 ## 泛化关系 (Generalization) @@ -327,7 +331,7 @@ Vihicle .. N ### 2. 合成复用原则 -尽量使用对象组合，而不是继承来达到复用的目的。 +尽量使用对象组合，而不是通过继承来达到复用的目的。 ### 3. 共同封闭原则 @@ -349,3 +353,4 @@ Vihicle .. N - [看懂 UML 类图和时序图](http://design-patterns.readthedocs.io/zh_CN/latest/read_uml.html#generalization) - [UML 系列——时序图（顺序图）sequence diagram](http://www.cnblogs.com/wolf-sun/p/UML-Sequence-diagram.html) - [面向对象编程三大特性 ------ 封装、继承、多态](http://blog.csdn.net/jianyuerensheng/article/details/51602015) + From 99a1aeb51d11c22ee2221d201e584cb7955b4138 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=83=91=E6=B0=B8=E5=B7=9D?= Date: Fri, 17 Aug 2018 21:36:50 +0800 Subject: [PATCH 11/24] Update README.md --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index f35ee455..942d6096 100644 --- a/README.md +++ b/README.md @@ -13,6 +13,10 @@ ## 算法 :pencil2: +- [算法](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/算法.md) + + 排序、并查集、栈和队列、红黑树、散列表。 + - [剑指 Offer 题解](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/剑指%20offer%20题解.md) 目录根据原书第二版进行编排，代码和原书有所不同，尽量比原书更简洁。 @@ -21,10 +25,6 @@ 对题目做了一个大致分类，并对每种题型的解题思路做了总结。 -- [算法](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/算法.md) - - 排序、并查集、栈和队列、红黑树、散列表。 - ## 操作系统 :computer: - [计算机操作系统](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/计算机操作系统.md) From d33f9a31119bf9703f78d144a97b2533f80995e5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=83=91=E6=B0=B8=E5=B7=9D?= Date: Sat, 18 Aug 2018 16:29:59 +0800 Subject: [PATCH 12/24] Update README.md --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 942d6096..3209d82f 100644 --- a/README.md +++ b/README.md @@ -13,10 +13,6 @@ ## 算法 :pencil2: -- [算法](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/算法.md) - - 排序、并查集、栈和队列、红黑树、散列表。 - - [剑指 Offer 题解](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/剑指%20offer%20题解.md) 目录根据原书第二版进行编排，代码和原书有所不同，尽量比原书更简洁。 @@ -24,6 +20,10 @@ - [Leetcode 题解](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/Leetcode%20题解.md) 对题目做了一个大致分类，并对每种题型的解题思路做了总结。 + + - [算法](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/算法.md) + + 排序、并查集、栈和队列、红黑树、散列表。 ## 操作系统 :computer: From f100a61a61dea9f7c09ee9493fd0fc8be89568bb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=83=91=E6=B0=B8=E5=B7=9D?= Date: Sat, 18 Aug 2018 16:30:19 +0800 Subject: [PATCH 13/24] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 3209d82f..f9c604d9 100644 --- a/README.md +++ b/README.md @@ -21,7 +21,7 @@ 对题目做了一个大致分类，并对每种题型的解题思路做了总结。 - - [算法](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/算法.md) + - [算法](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/算法.md) 排序、并查集、栈和队列、红黑树、散列表。 From fad52dbef4167ace6a352e7c9dd9bf57f52ceb68 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=83=91=E6=B0=B8=E5=B7=9D?= Date: Sat, 18 Aug 2018 16:30:33 +0800 Subject: [PATCH 14/24] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f9c604d9..ce7257e5 100644 --- a/README.md +++ b/README.md @@ -23,7 +23,7 @@ - [算法](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/算法.md) - 排序、并查集、栈和队列、红黑树、散列表。 + 排序、并查集、栈和队列、红黑树、散列表。 ## 操作系统 :computer: From 7186c28cc5a3c42d228188c579f2d7161b4634ac Mon Sep 17 00:00:00 2001 From: zhang xuelong <35026038+zhangxuelong10@users.noreply.github.com> Date: Sun, 19 Aug 2018 18:33:49 +0800 Subject: [PATCH 15/24] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=8B=BC=E5=86=99?= =?UTF-8?q?=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- notes/Java 基础.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notes/Java 基础.md b/notes/Java 基础.md index b329e0bc..44ca873a 100644 --- a/notes/Java 基础.md +++ b/notes/Java 基础.md @@ -707,7 +707,7 @@ public class EqualExample { ## hashCode() -hasCode() 返回散列值，而 equals() 是用来判断两个对象是否等价。等价的两个对象散列值一定相同，但是散列值相同的两个对象不一定等价。 +hashCode() 返回散列值，而 equals() 是用来判断两个对象是否等价。等价的两个对象散列值一定相同，但是散列值相同的两个对象不一定等价。 在覆盖 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象散列值也相等。 From d10ec622b02fff0a465ad8e93ce21a32df3dfe2e Mon Sep 17 00:00:00 2001 From: RocXing <120695313@qq.com> Date: Mon, 20 Aug 2018 18:46:03 +0800 Subject: [PATCH 16/24] =?UTF-8?q?=E8=A1=A5=E5=AD=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- notes/Java 并发.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notes/Java 并发.md b/notes/Java 并发.md index 64f9e7d6..ea8b2898 100644 --- a/notes/Java 并发.md +++ b/notes/Java 并发.md @@ -185,7 +185,7 @@ public static void main(String[] args) { } ``` ## 三种实现方式的比较 -- 实现Runnable接又可以避免Java单继承特性而带来的局限;增强程序的健壮性，代码能够被多个线程共享，代码与数据是独立的;适合多个相同程序代码的线程区处理同一资源的情况。 +- 实现Runnable接口又可以避免Java单继承特性而带来的局限;增强程序的健壮性，代码能够被多个线程共享，代码与数据是独立的;适合多个相同程序代码的线程区处理同一资源的情况。 - 继承Thread类和实现Runnable方法启动线 程都是使用start方法，然后JVM虚拟机将此线程放到就绪队列中，如果有处理机可用， 则执行run方法。 - 实现Callable接又要实现call方法，并且线 程执行完毕后会有返回值。其他的两种都是 重写run方法，没有返回值。 ## 实现接口 VS 继承 Thread From 67322b7a32ddf156827a0977a17493e3a3000509 Mon Sep 17 00:00:00 2001 From: CyC2018 <1029579233@qq.com> Date: Mon, 20 Aug 2018 20:32:42 +0800 Subject: [PATCH 17/24] auto commit --- notes/Docker.md | 11 ++++++----- notes/Java 并发.md | 5 +---- notes/Leetcode 题解.md | 9 ++++----- 3 files changed, 11 insertions(+), 14 deletions(-) diff --git a/notes/Docker.md b/notes/Docker.md index f230f762..80108896 100644 --- a/notes/Docker.md +++ b/notes/Docker.md @@ -30,15 +30,15 @@ Docker 主要解决环境配置问题，它是一种虚拟化技术，对进程 ## 启动速度 -启动虚拟机需要启动虚拟机的操作系统，再启动相应的应用，这个过程会非常慢； +启动虚拟机需要启动虚拟机的操作系统，再启动应用，这个过程非常慢； 而启动 Docker 相当于启动宿主操作系统上的一个进程。 ## 占用资源 -虚拟机是一个完整的操作系统，需要占用大量的磁盘空间、内存和 CPU，一台机器只能开启几十个的虚拟机。 +虚拟机是一个完整的操作系统，需要占用大量的磁盘、内存和 CPU，一台机器只能开启几十个的虚拟机。 -而 Docker 只是一个进程，只需要将应用以及相应的组件打包，在运行时占用很少的资源，一台机器可以开启成千上万个 Docker。 +而 Docker 只是一个进程，只需要将应用以及相关的组件打包，在运行时占用很少的资源，一台机器可以开启成千上万个 Docker。 参考资料： @@ -58,7 +58,7 @@ Docker 使用分层技术和镜像，使得应用可以更容易复用重复部 ## 更容易扩展 -可以使用基础镜像进一步扩展得到新的镜像，并且官方和开源社区提供了大量的镜像，通过扩展这些镜像得到我们想要的镜像非常容易。 +可以使用基础镜像进一步扩展得到新的镜像，并且官方和开源社区提供了大量的镜像，通过扩展这些镜像可以非常容易得到我们想要的镜像。 参考资料： @@ -91,7 +91,7 @@ Docker 轻量级的特点使得它很适合用于部署、维护、组合微服 镜像包含着容器运行时所需要的代码以及其它组件，它是一种分层结构，每一层都是只读的（read-only layers）。构建镜像时，会一层一层构建，前一层是后一层的基础。镜像的这种分层存储结构很适合镜像的复用以及定制。 -在构建容器时，通过在镜像的基础上添加一个可写层（writable layer），用来保存着容器运行过程中的修改。 +构建容器时，通过在镜像的基础上添加一个可写层（writable layer），用来保存着容器运行过程中的修改。

@@ -100,3 +100,4 @@ Docker 轻量级的特点使得它很适合用于部署、维护、组合微服 - [How to Create Docker Container using Dockerfile](https://linoxide.com/linux-how-to/dockerfile-create-docker-container/) - [理解 Docker（2）：Docker 镜像](http://www.cnblogs.com/sammyliu/p/5877964.html) + diff --git a/notes/Java 并发.md b/notes/Java 并发.md index ea8b2898..d3682d33 100644 --- a/notes/Java 并发.md +++ b/notes/Java 并发.md @@ -184,10 +184,7 @@ public static void main(String[] args) { mt.start(); } ``` -## 三种实现方式的比较 -- 实现Runnable接口又可以避免Java单继承特性而带来的局限;增强程序的健壮性，代码能够被多个线程共享，代码与数据是独立的;适合多个相同程序代码的线程区处理同一资源的情况。 -- 继承Thread类和实现Runnable方法启动线 程都是使用start方法，然后JVM虚拟机将此线程放到就绪队列中，如果有处理机可用， 则执行run方法。 -- 实现Callable接又要实现call方法，并且线 程执行完毕后会有返回值。其他的两种都是 重写run方法，没有返回值。 + ## 实现接口 VS 继承 Thread 实现接口会更好一些，因为： diff --git a/notes/Leetcode 题解.md b/notes/Leetcode 题解.md index 68af3cb7..04a751c7 100644 --- a/notes/Leetcode 题解.md +++ b/notes/Leetcode 题解.md @@ -3602,7 +3602,7 @@ public int countPrimes(int n) { ```java int gcd(int a, int b) { - return b == 0 ? a : gcd(b, a% b); + return b == 0 ? a : gcd(b, a % b); } ``` @@ -3673,7 +3673,7 @@ public String convertToBase7(int num) { } ``` -Java 中 static String toString(int num, int radix) 可以将一个整数转换为 redix 进制表示的字符串。 +Java 中 static String toString(int num, int radix) 可以将一个整数转换为 radix 进制表示的字符串。 ```java public String convertToBase7(int num) { @@ -6403,7 +6403,6 @@ public int maxChunksToSorted(int[] arr) { } ``` - ## 图 ### 二分图 @@ -6620,6 +6619,7 @@ public int[] findRedundantConnection(int[][] edges) { } private class UF { + private int[] id; UF(int N) { @@ -6665,7 +6665,7 @@ x ^ x = 0 x & x = x x | x = x ``` - 利用 x ^ 1s = \~x 的特点，可以将位级表示翻转；利用 x ^ x = 0 的特点，可以将三个数中重复的两个数去除，只留下另一个数。 -- 利用 x & 0s = 0 和 x & 1s = x 的特点，可以实现掩码操作。一个数 num 与 mask ：00111100 进行位与操作，只保留 num 中与 mask 的 1 部分相对应的位。 +- 利用 x & 0s = 0 和 x & 1s = x 的特点，可以实现掩码操作。一个数 num 与 mask：00111100 进行位与操作，只保留 num 中与 mask 的 1 部分相对应的位。 - 利用 x | 0s = x 和 x | 1s = 1s 的特点，可以实现设值操作。一个数 num 与 mask：00111100 进行位或操作，将 num 中与 mask 的 1 部分相对应的位都设置为 1。 位与运算技巧： @@ -6910,7 +6910,6 @@ public boolean isPowerOfFour(int num) { } ``` - **判断一个数的位级表示是否不会出现连续的 0 和 1** [693. Binary Number with Alternating Bits (Easy)](https://leetcode.com/problems/binary-number-with-alternating-bits/description/) From f7f68ba1f86b7af5d938dbad8630f7dbfae124a2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=83=91=E6=B0=B8=E5=B7=9D?= <1029579233@qq.com> Date: Mon, 20 Aug 2018 20:50:41 +0800 Subject: [PATCH 18/24] Update README.md --- README.md | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/README.md b/README.md index ce7257e5..bf186a04 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ -## 算法 :pencil2: +### 算法 :pencil2: - [剑指 Offer 题解](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/剑指%20offer%20题解.md) @@ -25,7 +25,7 @@ 排序、并查集、栈和队列、红黑树、散列表。 -## 操作系统 :computer: +### 操作系统 :computer: - [计算机操作系统](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/计算机操作系统.md) @@ -35,7 +35,7 @@ 基本实现原理以及基本操作。 -## 网络 :cloud: +### 网络 :cloud: - [计算机网络](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/计算机网络.md) @@ -49,7 +49,7 @@ I/O 模型、I/O 多路复用。 -## 面向对象 :couple: +### 面向对象 :couple: - [设计模式](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/设计模式.md) @@ -59,7 +59,7 @@ 三大原则（继承、封装、多态）、类图、设计原则。 -## 数据库 :floppy_disk: +### 数据库 :floppy_disk: - [数据库系统原理](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/数据库系统原理.md) @@ -81,7 +81,7 @@ 五种数据类型、字典和跳跃表数据结构、使用场景、和 Memcache 的比较、淘汰策略、持久化、文件事件的 Reactor 模式、复制。 -## Java :coffee: +### Java :coffee: - [Java 基础](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/Java%20基础.md) @@ -103,7 +103,7 @@ NIO 的原理以及实例。 -## 系统设计 :bulb: +### 系统设计 :bulb: - [系统设计基础](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/系统设计基础.md) @@ -129,7 +129,7 @@ 消息处理模型、使用场景、可靠性 -## 工具 :hammer: +### 工具 :hammer: - [Git](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/Git.md) @@ -147,7 +147,7 @@ 构建工具的基本概念、主流构建工具介绍。 -## 编码实践 :speak_no_evil: +### 编码实践 :speak_no_evil: - [重构](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/重构.md) @@ -161,9 +161,9 @@ Google 开源项目的代码风格规范。 -## 后记 :memo: +### 后记 :memo: -### About +#### About 这个仓库是笔者的一个学习笔记，主要总结一些比较重要的知识点，希望对大家有所帮助。 @@ -171,7 +171,7 @@ [BOOKLIST](https://github.com/CyC2018/Interview-Notebook/blob/master/BOOKLIST.md)，这个书单是笔者至今看的一些比较好的技术书籍，虽然没有全都看完，但每本书多多少少都看了一部分。 -### How To Contribute +#### How To Contribute 笔记内容是笔者一个字一个字打上去的，难免会有一些笔误，如果发现笔误可直接在相应文档进行编辑修改。 @@ -179,7 +179,7 @@ 欢迎在 Issue 中提交对本仓库的改进建议~ -### Typesetting +#### Typesetting 笔记内容按照 [中文文案排版指北](http://mazhuang.org/wiki/chinese-copywriting-guidelines/) 进行排版，以保证内容的可读性。 @@ -187,7 +187,7 @@ 笔者将自己实现的文档排版功能提取出来，放在 Github Page 中，无需下载安装即可免费使用：[Text-Typesetting](https://github.com/CyC2018/Markdown-Typesetting)。 -### Uploading +#### Uploading 笔者在本地使用为知笔记软件进行书写，为了方便将本地笔记内容上传到 Github 上，实现了一整套自动化上传方案，包括文本文件的导出、提取图片、Markdown 文档转换、Git 同步。 @@ -195,21 +195,21 @@ 笔者将自己实现文档转换功能提取出来，方便大家在需要将本地 Markdown 上传到 Github，或者制作项目 README 文档时生成目录时使用：[GFM-Converter](https://github.com/CyC2018/GFM-Converter)。 -### License +#### License 在对本作品进行演绎时，请署名并以相同方式共享。 知识共享许可协议 -### Statement +#### Statement 本仓库不参与商业行为，不向读者收取任何费用。(This repository is not engaging in business activities, and does not charge readers any fee.) -### Logo +#### Logo Power by [logomakr](https://logomakr.com/). -### Acknowledgements +#### Acknowledgements 感谢以下人员对本仓库做出的贡献，当然不仅仅只有这些贡献者，这里就不一一列举了。如果你希望被添加到这个名单中，并且提交过 Issue 或者 PR，请与笔者联系。 From 13e069030293de666b6c99fd928dfdaeb51f505e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=83=91=E6=B0=B8=E5=B7=9D?= <1029579233@qq.com> Date: Mon, 20 Aug 2018 20:58:21 +0800 Subject: [PATCH 19/24] Update README.md --- README.md | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/README.md b/README.md index bf186a04..3e829c1b 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ | Ⅰ | Ⅱ | Ⅲ | Ⅳ | Ⅴ | Ⅵ | Ⅶ | Ⅷ | Ⅸ | Ⅹ | | :--------: | :---------: | :---------: | :---------: | :---------: | :---------:| :---------: | :-------: | :-------:| :------:| -| 算法[:pencil2:](#算法-pencil2) | 操作系统[:computer:](#操作系统-computer)|网络[:cloud:](#网络-cloud) | 面向对象[:couple:](#面向对象-couple) |数据库[:floppy_disk:](#数据库-floppy_disk)| Java [:coffee:](#java-coffee)| 系统设计[:bulb:](#系统设计-bulb)| 工具[:hammer:](#工具-hammer)| 编码实践[:speak_no_evil:](#编码实践-speak_no_evil)| 后记[:memo:](#后记-memo) | +| 算法[:pencil2:](#pencil2-算法) | 操作系统[:computer:](#computer-操作系统)|网络[:cloud:](#cloud-网络) | 面向对象[:couple:](#couple-面向对象) |数据库[:floppy_disk:](#floppy_disk-数据库)| Java [:coffee:](#coffee-java)| 系统设计[:bulb:](#bulb-系统设计)| 工具[:hammer:](#hammer-工具)| 编码实践[:speak_no_evil:](#speak_no_evil-编码实践)| 后记[:memo:](#memo-后记) |
@@ -11,7 +11,7 @@ -### 算法 :pencil2: +## :pencil2: 算法 - [剑指 Offer 题解](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/剑指%20offer%20题解.md) @@ -25,7 +25,7 @@ 排序、并查集、栈和队列、红黑树、散列表。 -### 操作系统 :computer: +## :computer: 操作系统 - [计算机操作系统](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/计算机操作系统.md) @@ -35,7 +35,7 @@ 基本实现原理以及基本操作。 -### 网络 :cloud: +## :cloud: 网络 - [计算机网络](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/计算机网络.md) @@ -49,7 +49,7 @@ I/O 模型、I/O 多路复用。 -### 面向对象 :couple: +## :couple: 面向对象 - [设计模式](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/设计模式.md) @@ -59,7 +59,7 @@ 三大原则（继承、封装、多态）、类图、设计原则。 -### 数据库 :floppy_disk: +## :floppy_disk: 数据库 - [数据库系统原理](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/数据库系统原理.md) @@ -81,7 +81,7 @@ 五种数据类型、字典和跳跃表数据结构、使用场景、和 Memcache 的比较、淘汰策略、持久化、文件事件的 Reactor 模式、复制。 -### Java :coffee: +## :coffee: Java - [Java 基础](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/Java%20基础.md) @@ -103,7 +103,7 @@ NIO 的原理以及实例。 -### 系统设计 :bulb: +## :bulb: 系统设计 - [系统设计基础](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/系统设计基础.md) @@ -129,7 +129,7 @@ 消息处理模型、使用场景、可靠性 -### 工具 :hammer: +## :hammer: 工具 - [Git](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/Git.md) @@ -147,7 +147,7 @@ 构建工具的基本概念、主流构建工具介绍。 -### 编码实践 :speak_no_evil: +## :speak_no_evil: 编码实践 - [重构](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/重构.md) @@ -161,9 +161,9 @@ Google 开源项目的代码风格规范。 -### 后记 :memo: +## :memo: 后记 -#### About +### About 这个仓库是笔者的一个学习笔记，主要总结一些比较重要的知识点，希望对大家有所帮助。 @@ -171,7 +171,7 @@ [BOOKLIST](https://github.com/CyC2018/Interview-Notebook/blob/master/BOOKLIST.md)，这个书单是笔者至今看的一些比较好的技术书籍，虽然没有全都看完，但每本书多多少少都看了一部分。 -#### How To Contribute +### How To Contribute 笔记内容是笔者一个字一个字打上去的，难免会有一些笔误，如果发现笔误可直接在相应文档进行编辑修改。 @@ -179,7 +179,7 @@ 欢迎在 Issue 中提交对本仓库的改进建议~ -#### Typesetting +### Typesetting 笔记内容按照 [中文文案排版指北](http://mazhuang.org/wiki/chinese-copywriting-guidelines/) 进行排版，以保证内容的可读性。 @@ -187,7 +187,7 @@ 笔者将自己实现的文档排版功能提取出来，放在 Github Page 中，无需下载安装即可免费使用：[Text-Typesetting](https://github.com/CyC2018/Markdown-Typesetting)。 -#### Uploading +### Uploading 笔者在本地使用为知笔记软件进行书写，为了方便将本地笔记内容上传到 Github 上，实现了一整套自动化上传方案，包括文本文件的导出、提取图片、Markdown 文档转换、Git 同步。 @@ -195,21 +195,21 @@ 笔者将自己实现文档转换功能提取出来，方便大家在需要将本地 Markdown 上传到 Github，或者制作项目 README 文档时生成目录时使用：[GFM-Converter](https://github.com/CyC2018/GFM-Converter)。 -#### License +### License 在对本作品进行演绎时，请署名并以相同方式共享。 知识共享许可协议 -#### Statement +### Statement 本仓库不参与商业行为，不向读者收取任何费用。(This repository is not engaging in business activities, and does not charge readers any fee.) -#### Logo +### Logo Power by [logomakr](https://logomakr.com/). -#### Acknowledgements +### Acknowledgements 感谢以下人员对本仓库做出的贡献，当然不仅仅只有这些贡献者，这里就不一一列举了。如果你希望被添加到这个名单中，并且提交过 Issue 或者 PR，请与笔者联系。 From ded6dee5cd049d22fc558b8e5e755c33c0b71b4b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=83=91=E6=B0=B8=E5=B7=9D?= <1029579233@qq.com> Date: Mon, 20 Aug 2018 20:59:44 +0800 Subject: [PATCH 20/24] Update README.md --- README.md | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 3e829c1b..d511fa7c 100644 --- a/README.md +++ b/README.md @@ -195,12 +195,6 @@ 笔者将自己实现文档转换功能提取出来，方便大家在需要将本地 Markdown 上传到 Github，或者制作项目 README 文档时生成目录时使用：[GFM-Converter](https://github.com/CyC2018/GFM-Converter)。 -### License - -在对本作品进行演绎时，请署名并以相同方式共享。 - -知识共享许可协议 - ### Statement 本仓库不参与商业行为，不向读者收取任何费用。(This repository is not engaging in business activities, and does not charge readers any fee.) @@ -235,5 +229,9 @@ Power by [logomakr](https://logomakr.com/). +### License +在对本作品进行演绎时，请署名并以相同方式共享。 + +知识共享许可协议 From db08ad2cda7d49e8d93e34c9b6397380cf27bae0 Mon Sep 17 00:00:00 2001 From: Elong Date: Tue, 21 Aug 2018 15:11:03 +0800 Subject: [PATCH 21/24] =?UTF-8?q?Update=20Java=20=E5=B9=B6=E5=8F=91.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 文字描述修改的更加严谨一些 --- notes/Java 并发.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notes/Java 并发.md b/notes/Java 并发.md index d3682d33..16e20a24 100644 --- a/notes/Java 并发.md +++ b/notes/Java 并发.md @@ -1020,7 +1020,7 @@ ForkJoinPool 实现了工作窃取算法来提高 CPU 的利用率。每个线 如果多个线程对同一个共享数据进行访问而不采取同步操作的话，那么操作的结果是不一致的。 -以下代码演示了 1000 个线程同时对 cnt 执行自增操作，操作结束之后它的值为 997 而不是 1000。 +以下代码演示了 1000 个线程同时对 cnt 执行自增操作，操作结束之后它的值一般情况下小于 1000。 ```java public class ThreadUnsafeExample { From cd354fb46cd472b9b20a206df89ae7b83bb0b890 Mon Sep 17 00:00:00 2001 From: wangxujian-laixuzhui <33362969+wangxujian-laixuzhui@users.noreply.github.com> Date: Tue, 21 Aug 2018 18:29:57 +0800 Subject: [PATCH 22/24] =?UTF-8?q?=E5=BF=AB=E6=8E=92=E4=B8=8D=E7=A8=B3?= =?UTF-8?q?=E5=AE=9A=EF=BC=8C=E5=A6=82221=EF=BC=8C=E7=AC=AC=E4=B8=80?= =?UTF-8?q?=E4=B8=AA2=E4=BC=9A=E5=92=8C1=E4=BA=A4=E6=8D=A2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- notes/算法.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notes/算法.md b/notes/算法.md index 30467b42..8007375b 100644 --- a/notes/算法.md +++ b/notes/算法.md @@ -770,7 +770,7 @@ public class HeapSort> extends Sort { | 算法 | 稳定 | 时间复杂度 | 空间复杂度 | 备注 | | :---: | :---: |:---: | :---: | :---: | -| 选择排序 | √| N2 | 1 | | +| 选择排序 | ×| N2 | 1 | | | 冒泡排序 | √ | N2 | 1 | | | 插入排序 | √ | N \~ N2 | 1 | 时间复杂度和初始顺序有关 | | 希尔排序 | × | N 的若干倍乘于递增序列的长度 | 1 | | From d4610276542bc6ebd4940a0f0845cc27ce4b74ea Mon Sep 17 00:00:00 2001 From: CyC2018 <1029579233@qq.com> Date: Tue, 21 Aug 2018 20:05:55 +0800 Subject: [PATCH 23/24] auto commit --- notes/Java 并发.md | 2 +- notes/攻击技术.md | 2 +- notes/消息队列.md | 13 +++++++------ notes/算法.md | 2 +- notes/缓存.md | 30 +++++++++--------------------- 5 files changed, 19 insertions(+), 30 deletions(-) diff --git a/notes/Java 并发.md b/notes/Java 并发.md index 16e20a24..1403f764 100644 --- a/notes/Java 并发.md +++ b/notes/Java 并发.md @@ -1020,7 +1020,7 @@ ForkJoinPool 实现了工作窃取算法来提高 CPU 的利用率。每个线 如果多个线程对同一个共享数据进行访问而不采取同步操作的话，那么操作的结果是不一致的。 -以下代码演示了 1000 个线程同时对 cnt 执行自增操作，操作结束之后它的值一般情况下小于 1000。 +以下代码演示了 1000 个线程同时对 cnt 执行自增操作，操作结束之后它的值有可能小于 1000。 ```java public class ThreadUnsafeExample { diff --git a/notes/攻击技术.md b/notes/攻击技术.md index d5a735ba..46dd4616 100644 --- a/notes/攻击技术.md +++ b/notes/攻击技术.md @@ -207,7 +207,7 @@ ResultSet rs = stmt.executeQuery(); 拒绝服务攻击（denial-of-service attack，DoS），亦称洪水攻击，其目的在于使目标电脑的网络或系统资源耗尽，使服务暂时中断或停止，导致其正常用户无法访问。 -分布式拒绝服务攻击（distributed denial-of-service attack，DDoS），指攻击者使用网络上两个或以上被攻陷的电脑作为“僵尸”向特定的目标发动“拒绝服务”式攻击。 +分布式拒绝服务攻击（distributed denial-of-service attack，DDoS），指攻击者使用两个或以上被攻陷的电脑作为“僵尸”向特定的目标发动“拒绝服务”式攻击。 # 参考资料 diff --git a/notes/消息队列.md b/notes/消息队列.md index c5687e8a..209d962a 100644 --- a/notes/消息队列.md +++ b/notes/消息队列.md @@ -9,6 +9,7 @@ * [三、可靠性](#三可靠性) * [发送端的可靠性](#发送端的可靠性) * [接收端的可靠性](#接收端的可靠性) +* [参考资料](#参考资料) @@ -29,15 +30,10 @@ 发布与订阅模式和观察者模式有以下不同： - 观察者模式中，观察者和主题都知道对方的存在；而在发布与订阅模式中，发布者与订阅者不知道对方的存在，它们之间通过频道进行通信。 -- 观察者模式是同步的，当事件触发时，主题会去调用观察者的方法，然后等待方法返回；而发布与订阅模式是异步的，发布者向频道发送一个消息之后，就不需要关心订阅者何时去订阅这个消息。 +- 观察者模式是同步的，当事件触发时，主题会调用观察者的方法，然后等待方法返回；而发布与订阅模式是异步的，发布者向频道发送一个消息之后，就不需要关心订阅者何时去订阅这个消息，可以立即返回。

-参考： - -- [Observer vs Pub-Sub](http://developers-club.com/posts/270339/) -- [消息队列中点对点与发布订阅区别](https://blog.csdn.net/lizhitao/article/details/47723105) - # 二、使用场景 ## 异步处理 @@ -78,3 +74,8 @@ - 保证接收端处理消息的业务逻辑具有幂等性：只要具有幂等性，那么消费多少次消息，最后处理的结果都是一样的。 - 保证消息具有唯一编号，并使用一张日志表来记录已经消费的消息编号。 + +# 参考资料 + +- [Observer vs Pub-Sub](http://developers-club.com/posts/270339/) +- [消息队列中点对点与发布订阅区别](https://blog.csdn.net/lizhitao/article/details/47723105) diff --git a/notes/算法.md b/notes/算法.md index 8007375b..152adfda 100644 --- a/notes/算法.md +++ b/notes/算法.md @@ -770,7 +770,7 @@ public class HeapSort> extends Sort { | 算法 | 稳定 | 时间复杂度 | 空间复杂度 | 备注 | | :---: | :---: |:---: | :---: | :---: | -| 选择排序 | ×| N2 | 1 | | +| 选择排序 | × | N2 | 1 | | | 冒泡排序 | √ | N2 | 1 | | | 插入排序 | √ | N \~ N2 | 1 | 时间复杂度和初始顺序有关 | | 希尔排序 | × | N 的若干倍乘于递增序列的长度 | 1 | | diff --git a/notes/缓存.md b/notes/缓存.md index 9a9f2810..ed834253 100644 --- a/notes/缓存.md +++ b/notes/缓存.md @@ -6,6 +6,7 @@ * [五、缓存问题](#五缓存问题) * [六、数据分布](#六数据分布) * [七、一致性哈希](#七一致性哈希) +* [参考资料](#参考资料) @@ -29,10 +30,6 @@ - LRU（Least Recently Used）：最近最久未使用策略，优先淘汰最久未使用的数据，也就是上次被访问时间距离现在最远的数据。该策略可以保证内存中的数据都是热点数据，也就是经常被访问的数据，从而保证缓存命中率。 -参考资料： - -- [缓存那些事](https://tech.meituan.com/cache_about.html) - # 二、LRU 以下是一个基于 双向链表 + HashMap 的 LRU 算法实现，对算法的解释如下： @@ -143,10 +140,6 @@ public class LRU implements Iterable { } ``` -源代码： - -- [CyC2018/Algorithm](https://github.com/CyC2018/Algorithm/tree/master/Caching) - # 三、缓存位置 ## 浏览器 @@ -169,7 +162,7 @@ public class LRU implements Iterable { 使用 Redis、Memcache 等分布式缓存将数据缓存在分布式缓存系统中。 -相对于本地缓存来说，分布式缓存单独部署，可以根据需求分配硬件资源。不仅如此，服务器集群都可以访问分布式缓存。而本地缓存需要在服务器集群之间进行同步，实现和性能开销上都非常大。 +相对于本地缓存来说，分布式缓存单独部署，可以根据需求分配硬件资源。不仅如此，服务器集群都可以访问分布式缓存，而本地缓存需要在服务器集群之间进行同步，实现和性能开销上都非常大。 ## 数据库缓存 @@ -177,7 +170,7 @@ MySQL 等数据库管理系统具有自己的查询缓存机制来提高 SQL 查 # 四、CDN -内容分发网络（Content distribution network，CDN）是一种通过互连的网络系统，利用更靠近用户的服务器更快更可靠地将 HTML、CSS、JavaScript、音乐、图片、视频等静态资源分发给用户。 +内容分发网络（Content distribution network，CDN）是一种互连的网络系统，它利用更靠近用户的服务器从而更快更可靠地将 HTML、CSS、JavaScript、音乐、图片、视频等静态资源分发给用户。 CDN 主要有以下优点： @@ -187,11 +180,6 @@ CDN 主要有以下优点：

-参考资料： - -- [内容分发网络](https://zh.wikipedia.org/wiki/%E5%85%A7%E5%AE%B9%E5%82%B3%E9%81%9E%E7%B6%B2%E8%B7%AF) -- [How Aspiration CDN helps to improve your website loading speed?](https://www.aspirationhosting.com/aspiration-cdn/) - # 五、缓存问题 ## 缓存穿透 @@ -213,7 +201,7 @@ CDN 主要有以下优点： - 为了防止缓存在同一时间大面积过期导致的缓存雪崩，可以通过观察用户行为，合理设置缓存过期时间来实现； - 为了防止缓存服务器宕机出现的缓存雪崩，可以使用分布式缓存，分布式缓存中每一个节点只缓存部分的数据，当某个节点宕机时可以保证其它节点的缓存仍然可用。 -- 也可以在进行缓存预热，避免在系统刚启动不久由于还未将大量数据进行缓存而导致缓存雪崩。 +- 也可以进行缓存预热，避免在系统刚启动不久由于还未将大量数据进行缓存而导致缓存雪崩。 ## 缓存一致性 @@ -243,10 +231,6 @@ CDN 主要有以下优点： - 能保持数据原有的顺序； - 并且能够准确控制每台服务器存储的数据量，从而使得存储空间的利用率最大。 -参考资料： - -- 大规模分布式存储系统 - # 七、一致性哈希 Distributed Hash Table（DHT） 是一种哈希分布方式，其目的是为了克服传统哈希分布在服务器节点数量变化时大量数据失效的问题。 @@ -267,6 +251,10 @@ Distributed Hash Table（DHT） 是一种哈希分布方式，其目的是为了 数据不均匀主要是因为节点在哈希环上分布的不均匀，这种情况在节点数量很少的情况下尤其明显。解决方式是通过增加虚拟节点，然后将虚拟节点映射到真实节点上。虚拟节点的数量比真实节点来得大，那么虚拟节点在哈希环上分布的均匀性就会比原来的真实节点好，从而使得数据分布也更加均匀。 -参考资料： +# 参考资料 +- 大规模分布式存储系统 +- [缓存那些事](https://tech.meituan.com/cache_about.html) - [一致性哈希算法](https://my.oschina.net/jayhu/blog/732849) +- [内容分发网络](https://zh.wikipedia.org/wiki/%E5%85%A7%E5%AE%B9%E5%82%B3%E9%81%9E%E7%B6%B2%E8%B7%AF) +- [How Aspiration CDN helps to improve your website loading speed?](https://www.aspirationhosting.com/aspiration-cdn/) From 25cd99a8d03637bbc624e58e3991a41c36810c1a Mon Sep 17 00:00:00 2001 From: CyC2018 <1029579233@qq.com> Date: Tue, 21 Aug 2018 20:14:05 +0800 Subject: [PATCH 24/24] auto commit --- notes/算法.md | 2 +- pics/766aedd0-1b00-4065-aa2b-7d31138df84f.png | Bin 0 -> 19456 bytes 2 files changed, 1 insertion(+), 1 deletion(-) create mode 100644 pics/766aedd0-1b00-4065-aa2b-7d31138df84f.png diff --git a/notes/算法.md b/notes/算法.md index 152adfda..25d1550e 100644 --- a/notes/算法.md +++ b/notes/算法.md @@ -507,7 +507,7 @@ public class QuickSort> extends Sort { 取 a[l] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于等于它的元素，交换这两个元素。不断进行这个过程，就可以保证左指针 i 的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。当两个指针相遇时，将切分元素 a[l] 和 a[j] 交换位置。 -

+

```java private int partition(T[] nums, int l, int h) { diff --git a/pics/766aedd0-1b00-4065-aa2b-7d31138df84f.png b/pics/766aedd0-1b00-4065-aa2b-7d31138df84f.png new file mode 100644 index 0000000000000000000000000000000000000000..e8a69bff4827a53c56bc89507c42318a2aa8a0d2 GIT binary patch literal 19456 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 literal 0 HcmV?d00001