相对地址和更正错题

把一些目录的变成了相对地址，同时更正了一道错题（剑指OFFER#16）
2019-08-03 14:30:54 +08:00 · 2019-08-03 14:30:54 +08:00 · bd23623460
commit bd23623460
parent e8d80f8bb8
5 changed files with 49 additions and 78 deletions
--- a/README.md
+++ b/README.md
@ -20,62 +20,62 @@

 ## :pencil2: 算法

- [剑指 Offer 题解](https://github.com/CyC2018/CS-Notes/blob/master/notes/剑指%20Offer%20题解%20-%20目录.md)
- [Leetcode 题解](https://github.com/CyC2018/CS-Notes/blob/master/notes/Leetcode%20题解%20-%20目录.md)
- [算法](https://github.com/CyC2018/CS-Notes/blob/master/notes/算法%20-%20目录.md)
+- [剑指 Offer 题解](./notes/剑指%20Offer%20题解%20-%20目录.md)
+- [Leetcode 题解](./notes/Leetcode%20题解%20-%20目录.md)
+- [算法](./notes/算法%20-%20目录.md)

 ## :computer: 操作系统

- [计算机操作系统](https://github.com/CyC2018/CS-Notes/blob/master/notes/计算机操作系统%20-%20目录.md)
- [Linux](https://github.com/CyC2018/CS-Notes/blob/master/notes/Linux.md)
+- [计算机操作系统](./notes/计算机操作系统%20-%20目录.md)
+- [Linux](./notes/Linux.md)

 ## :cloud: 网络 

- [计算机网络](https://github.com/CyC2018/CS-Notes/blob/master/notes/计算机网络%20-%20目录.md)
- [HTTP](https://github.com/CyC2018/CS-Notes/blob/master/notes/HTTP.md)
- [Socket](https://github.com/CyC2018/CS-Notes/blob/master/notes/Socket.md)
+- [计算机网络](./notes/计算机网络%20-%20目录.md)
+- [HTTP](./notes/HTTP.md)
+- [Socket](./notes/Socket.md)

 ## :art: 面向对象

- [设计模式](https://github.com/CyC2018/CS-Notes/blob/master/notes/设计模式.md)
- [面向对象思想](https://github.com/CyC2018/CS-Notes/blob/master/notes/面向对象思想.md)
+- [设计模式](./notes/设计模式.md)
+- [面向对象思想](./notes/面向对象思想.md)

 ## :floppy_disk: 数据库 

- [数据库系统原理](https://github.com/CyC2018/CS-Notes/blob/master/notes/数据库系统原理.md)
- [SQL](https://github.com/CyC2018/CS-Notes/blob/master/notes/SQL.md)
- [Leetcode-Database 题解](https://github.com/CyC2018/CS-Notes/blob/master/notes/Leetcode-Database%20题解.md)
- [MySQL](https://github.com/CyC2018/CS-Notes/blob/master/notes/MySQL.md)
- [Redis](https://github.com/CyC2018/CS-Notes/blob/master/notes/Redis.md)
+- [数据库系统原理](./notes/数据库系统原理.md)
+- [SQL](./notes/SQL.md)
+- [Leetcode-Database 题解](.notes/Leetcode-Database%20题解.md)
+- [MySQL](./notes/MySQL.md)
+- [Redis](./notes/Redis.md)

 ## :coffee: Java

- [Java 基础](https://github.com/CyC2018/CS-Notes/blob/master/notes/Java%20基础.md)
- [Java 容器](https://github.com/CyC2018/CS-Notes/blob/master/notes/Java%20容器.md)
- [Java 并发](https://github.com/CyC2018/CS-Notes/blob/master/notes/Java%20并发.md)
- [Java 虚拟机](https://github.com/CyC2018/CS-Notes/blob/master/notes/Java%20虚拟机.md)
- [Java I/O](https://github.com/CyC2018/CS-Notes/blob/master/notes/Java%20IO.md)
+- [Java 基础](./notes/Java%20基础.md)
+- [Java 容器](./notes/Java%20容器.md)
+- [Java 并发](./notes/Java%20并发.md)
+- [Java 虚拟机](./notes/Java%20虚拟机.md)
+- [Java I/O](./notes/Java%20IO.md)

 ## :bulb: 系统设计 

- [系统设计基础](https://github.com/CyC2018/CS-Notes/blob/master/notes/系统设计基础.md)
- [分布式](https://github.com/CyC2018/CS-Notes/blob/master/notes/分布式.md)
- [集群](https://github.com/CyC2018/CS-Notes/blob/master/notes/集群.md)
- [攻击技术](https://github.com/CyC2018/CS-Notes/blob/master/notes/攻击技术.md)
- [缓存](https://github.com/CyC2018/CS-Notes/blob/master/notes/缓存.md)
- [消息队列](https://github.com/CyC2018/CS-Notes/blob/master/notes/消息队列.md)
+- [系统设计基础](./notes/系统设计基础.md)
+- [分布式](./notes/分布式.md)
+- [集群](./notes/集群.md)
+- [攻击技术](./notes/攻击技术.md)
+- [缓存](./notes/缓存.md)
+- [消息队列](./notes/消息队列.md)

 ## :wrench: 工具 

- [Git](https://github.com/CyC2018/CS-Notes/blob/master/notes/Git.md)
- [Docker](https://github.com/CyC2018/CS-Notes/blob/master/notes/Docker.md)
- [构建工具](https://github.com/CyC2018/CS-Notes/blob/master/notes/构建工具.md)
- [正则表达式](https://github.com/CyC2018/CS-Notes/blob/master/notes/正则表达式.md)
+- [Git](./notes/Git.md)
+- [Docker](./notes/Docker.md)
+- [构建工具](./notes/构建工具.md)
+- [正则表达式](./notes/正则表达式.md)

 ## :watermelon: 编码实践 

- [代码可读性](https://github.com/CyC2018/CS-Notes/blob/master/notes/代码可读性.md)
- [代码风格规范](https://github.com/CyC2018/CS-Notes/blob/master/notes/代码风格规范.md)
+- [代码可读性](./notes/代码可读性.md)
+- [代码风格规范](./notes/代码风格规范.md)

 ## :memo: 后记

@ -86,7 +86,6 @@
 <br>

 <div align="center"><img width="300px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/other/公众号海报6.png"></img></div>
-
 ### 更多内容

 - 内推：[Job-Recommend](https://github.com/CyC2018/Job-Recommend)
--- a/notes/剑指
+++ b/notes/剑指
@ -27,13 +27,11 @@
 <!--<div align="center"><img src="https://latex.codecogs.com/gif.latex?f(n)=\left\{\begin{array}{rcl}0&&{n=0}\\1&&{n=1}\\f(n-1)+f(n-2)&&{n>1}\end{array}\right." class="mathjax-pic"/></div> <br> -->

 <div align="center"> <img src="pics/45be9587-6069-4ab7-b9ac-840db1a53744.jpg" width="300px"> </div><br>
-
 ## 解题思路

 如果使用递归求解，会重复计算一些子问题。例如，计算 f(4) 需要计算 f(3) 和 f(2)，计算 f(3) 需要计算 f(2) 和 f(1)，可以看到 f(2) 被重复计算了。

 <div align="center"> <img src="pics/c13e2a3d-b01c-4a08-a69b-db2c4e821e09.png" width="350px"/> </div><br>
-
 递归是将一个问题划分成多个子问题求解，动态规划也是如此，但是动态规划会把子问题的解缓存起来，从而避免重复求解子问题。

 ```java
@ -93,23 +91,19 @@ public class Solution {
 我们可以用 2\*1 的小矩形横着或者竖着去覆盖更大的矩形。请问用 n 个 2\*1 的小矩形无重叠地覆盖一个 2\*n 的大矩形，总共有多少种方法？

 <div align="center"> <img src="pics/b903fda8-07d0-46a7-91a7-e803892895cf.gif" width="100px"> </div><br>
-
 ## 解题思路

 当 n 为 1 时，只有一种覆盖方法：

 <div align="center"> <img src="pics/f6e146f1-57ad-411b-beb3-770a142164ef.png" width="100px"> </div><br>
-
 当 n 为 2 时，有两种覆盖方法：

 <div align="center"> <img src="pics/fb3b8f7a-4293-4a38-aae1-62284db979a3.png" width="200px"> </div><br>
-
 要覆盖 2\*n 的大矩形，可以先覆盖 2\*1 的矩形，再覆盖 2\*(n-1) 的矩形；或者先覆盖 2\*2 的矩形，再覆盖 2\*(n-2) 的矩形。而覆盖 2\*(n-1) 和 2\*(n-2) 的矩形可以看成子问题。该问题的递推公式如下：

 <!-- <div align="center"><img src="https://latex.codecogs.com/gif.latex?f(n)=\left\{\begin{array}{rcl}1&&{n=1}\\2&&{n=2}\\f(n-1)+f(n-2)&&{n>1}\end{array}\right." class="mathjax-pic"/></div> <br> -->

 <div align="center"> <img src="pics/508c6e52-9f93-44ed-b6b9-e69050e14807.jpg" width="350px"> </div><br>
-
 ```java
 public int RectCover(int n) {
    if (n <= 2)
@ -134,21 +128,17 @@ public int RectCover(int n) {
 一只青蛙一次可以跳上 1 级台阶，也可以跳上 2 级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

 <div align="center"> <img src="pics/9dae7475-934f-42e5-b3b3-12724337170a.png" width="380px"> </div><br>
-
 ## 解题思路

 当 n = 1 时，只有一种跳法：

 <div align="center"> <img src="pics/72aac98a-d5df-4bfa-a71a-4bb16a87474c.png" width="250px"> </div><br>
-
 当 n = 2 时，有两种跳法：

 <div align="center"> <img src="pics/1b80288d-1b35-4cd3-aa17-7e27ab9a2389.png" width="300px"> </div><br>
-
 跳 n 阶台阶，可以先跳 1 阶台阶，再跳 n-1 阶台阶；或者先跳 2 阶台阶，再跳 n-2 阶台阶。而 n-1 和 n-2 阶台阶的跳法可以看成子问题，该问题的递推公式为：

 <div align="center"> <img src="pics/508c6e52-9f93-44ed-b6b9-e69050e14807.jpg" width="350px"> </div><br>
-
 ```java
 public int JumpFloor(int n) {
    if (n <= 2)
@ -173,7 +163,6 @@ public int JumpFloor(int n) {
 一只青蛙一次可以跳上 1 级台阶，也可以跳上 2 级... 它也可以跳上 n 级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

 <div align="center"> <img src="pics/cd411a94-3786-4c94-9e08-f28320e010d5.png" width="380px"> </div><br>
-
 ## 解题思路

 ### 动态规划
@ -233,13 +222,11 @@ public int JumpFloorII(int target) {
 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。

 <div align="center"> <img src="pics/0038204c-4b8a-42a5-921d-080f6674f989.png" width="210px"> </div><br>
-
 ## 解题思路

 将旋转数组对半分可以得到一个包含最小元素的新旋转数组，以及一个非递减排序的数组。新的旋转数组的数组元素是原数组的一半，从而将问题规模减少了一半，这种折半性质的算法的时间复杂度为 O(logN)（为了方便，这里将 log<sub>2</sub>N 写为 logN）。

 <div align="center"> <img src="pics/424f34ab-a9fd-49a6-9969-d76b42251365.png" width="300px"> </div><br>
-
 此时问题的关键在于确定对半分得到的两个数组哪一个是旋转数组，哪一个是非递减数组。我们很容易知道非递减数组的第一个元素一定小于等于最后一个元素。

 通过修改二分查找算法进行求解（l 代表 low，m 代表 mid，h 代表 high）：
@ -301,13 +288,11 @@ private int minNumber(int[] nums, int l, int h) {
 例如下面的矩阵包含了一条 bfce 路径。

 <div align="center"> <img src="pics/1db1c7ea-0443-478b-8df9-7e33b1336cc4.png" width="200px"> </div><br>
-
 ## 解题思路

 使用回溯法（backtracking）进行求解，它是一种暴力搜索方法，通过搜索所有可能的结果来求解问题。回溯法在一次搜索结束时需要进行回溯（回退），将这一次搜索过程中设置的状态进行清除，从而开始一次新的搜索过程。例如下图示例中，从 f 开始，下一步有 4 种搜索可能，如果先搜索 b，需要将 b 标记为已经使用，防止重复使用。在这一次搜索结束之后，需要将 b 的已经使用状态清除，并搜索 c。

 <div align="center"> <img src="pics/dc964b86-7a08-4bde-a3d9-e6ddceb29f98.png" width="200px"> </div><br>
-
 本题的输入是数组而不是矩阵（二维数组），因此需要先将数组转换成矩阵。

 ```java
@ -524,7 +509,6 @@ public int NumberOf1(int n) {

 <div align="center"> <img src="pics/48b1d459-8832-4e92-938a-728aae730739.jpg" width="330px"> </div><br>

-
 因为 (x\*x)<sup>n/2</sup> 可以通过递归求解，并且每次递归 n 都减小一半，因此整个算法的时间复杂度为 O(logN)。

 ```java
@ -540,7 +524,9 @@ public double Power(double base, int exponent) {
    }
    double pow = Power(base * base, exponent / 2);
    if (exponent % 2 != 0)
-        pow = pow * base;
+        pow = pow * base * pow;
+    else
+        pow = pow * pow;
    return isNegative ? 1 / pow : pow;
 }
 ```
@ -593,11 +579,9 @@ private void printNumber(char[] number) {
 ① 如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，然后令该节点指向下下个节点，再删除下一个节点，时间复杂度为 O(1)。

 <div align="center"> <img src="pics/1176f9e1-3442-4808-a47a-76fbaea1b806.png" width="600"/> </div><br>
-
 ② 否则，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向 null，时间复杂度为 O(N)。

 <div align="center"> <img src="pics/4bf8d0ba-36f0-459e-83a0-f15278a5a157.png" width="600"/> </div><br>
-
 综上，如果进行 N 次操作，那么大约需要操作节点的次数为 N-1+N=2N-1，其中 N-1 表示 N-1 个不是尾节点的每个节点以 O(1) 的时间复杂度操作节点的总次数，N 表示 1 个尾节点以 O(N) 的时间复杂度操作节点的总次数。(2N-1)/N \~ 2，因此该算法的平均时间复杂度为 O(1)。

 ```java
@ -631,7 +615,6 @@ public ListNode deleteNode(ListNode head, ListNode tobeDelete) {
 ## 题目描述

 <div align="center"> <img src="pics/17e301df-52e8-4886-b593-841a16d13e44.png" width="450"/> </div><br>
-
 ## 解题描述

 ```java
--- a/notes/剑指
+++ b/notes/剑指
@ -35,7 +35,6 @@ Output:

 <div align="center"> <img src="pics/49d2adc1-b28a-44bf-babb-d44993f4a2e3.gif" width="250px"> </div><br>

-
 ```java
 public boolean duplicate(int[] nums, int length, int[] duplication) {
    if (nums == null || length <= 0)
@ -88,7 +87,6 @@ Given target = 20, return false.
 该二维数组中的一个数，小于它的数一定在其左边，大于它的数一定在其下边。因此，从右上角开始查找，就可以根据 target 和当前元素的大小关系来缩小查找区间，当前元素的查找区间为左下角的所有元素。

 <div align="center"> <img src="pics/0ad9f7ba-f408-4999-a77a-9b73562c9088.gif" width="200px"> </div><br>
-
 ```java
 public boolean Find(int target, int[][] matrix) {
    if (matrix == null || matrix.length == 0 || matrix[0].length == 0)
@ -133,7 +131,6 @@ Output:
 从后向前遍是为了在改变 P2 所指向的内容时，不会影响到 P1 遍历原来字符串的内容。

 <div align="center"> <img src="pics/6980aef0-debe-4b4b-8da5-8b1befbc1408.gif" width="230px"> </div><br>
-
 ```java
 public String replaceSpace(StringBuffer str) {
    int P1 = str.length() - 1;
@ -165,7 +162,6 @@ public String replaceSpace(StringBuffer str) {
 从尾到头反过来打印出每个结点的值。

 <div align="center"> <img src="pics/f5792051-d9b2-4ca4-a234-a4a2de3d5a57.png" width="280px"> </div><br>
-
 ## 解题思路

 ### 使用递归
@ -193,7 +189,6 @@ public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
 - 第一个节点就是链表的第一个真正存储值的节点。

 <div align="center"> <img src="pics/0dae7e93-cfd1-4bd3-97e8-325b032b716f.gif" width="370px"> </div><br>
-
 ```java
 public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
    // 头插法构建逆序链表
@ -220,7 +215,6 @@ public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
 栈具有后进先出的特点，在遍历链表时将值按顺序放入栈中，最后出栈的顺序即为逆序。

 <div align="center"> <img src="pics/9d1deeba-4ae1-41dc-98f4-47d85b9831bc.gif" width="300px"> </div><br>
-
 ```java
 public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
    Stack<Integer> stack = new Stack<>();
@ -245,13 +239,11 @@ public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {


 <div align="center"> <img src="pics/31d9adce-2af8-4754-8386-0aabb4e500b0.png" width="300"/> </div><br>
-
 ## 解题思路

 前序遍历的第一个值为根节点的值，使用这个值将中序遍历结果分成两部分，左部分为树的左子树中序遍历结果，右部分为树的右子树中序遍历的结果。

 <div align="center"> <img src="pics/c269e362-1128-4212-9cf3-d4c12b363b2f.gif" width="330px"> </div><br>
-
 ```java
 // 缓存中序遍历数组每个值对应的索引
 private Map<Integer, Integer> indexForInOrders = new HashMap<>();
@ -301,11 +293,9 @@ public class TreeLinkNode {
 ① 如果一个节点的右子树不为空，那么该节点的下一个节点是右子树的最左节点；

 <div align="center"> <img src="pics/b0611f89-1e5f-4494-a795-3544bf65042a.gif" width="220px"/> </div><br>
-
 ② 否则，向上找第一个左链接指向的树包含该节点的祖先节点。

 <div align="center"> <img src="pics/95080fae-de40-463d-a76e-783a0c677fec.gif" width="200px"/> </div><br>
-
 ```java
 public TreeLinkNode GetNext(TreeLinkNode pNode) {
    if (pNode.right != null) {
@ -338,7 +328,6 @@ public TreeLinkNode GetNext(TreeLinkNode pNode) {
 in 栈用来处理入栈（push）操作，out 栈用来处理出栈（pop）操作。一个元素进入 in 栈之后，出栈的顺序被反转。当元素要出栈时，需要先进入 out 栈，此时元素出栈顺序再一次被反转，因此出栈顺序就和最开始入栈顺序是相同的，先进入的元素先退出，这就是队列的顺序。

 <div align="center"> <img src="pics/3ea280b5-be7d-471b-ac76-ff020384357c.gif" width="350"/> </div><br>
-
 ```java
 Stack<Integer> in = new Stack<Integer>();
 Stack<Integer> out = new Stack<Integer>();
--- a/notes/剑指
+++ b/notes/剑指
@ -2,13 +2,13 @@

 # 目录

- [3\~9](剑指%20Offer%20题解%20-%203\~9.md)
- [10\~19](剑指%20Offer%20题解%20-%2010\~19.md)
- [20\~29](剑指%20Offer%20题解%20-%2020\~29.md)
- [30\~39](剑指%20Offer%20题解%20-%2030\~39.md)
- [40\~49](剑指%20Offer%20题解%20-%2040\~49.md)
- [50\~59](剑指%20Offer%20题解%20-%2050\~59.md)
- [60\~68](剑指%20Offer%20题解%20-%2060\~68.md)
+- [3\~9](./剑指 Offer 题解 - 3~9.md)
+- [10\~19](./剑指 Offer 题解 - 10~19.md)
+- [20\~29](./剑指 Offer 题解 - 20~29.md)
+- [30\~39](./剑指 Offer 题解 - 30~39.md)
+- [40\~49](./剑指 Offer 题解 - 40~49.md)
+- [50\~59](./剑指 Offer 题解 - 50~59.md)
+- [60\~68](./剑指 Offer 题解 - 60~68.md)

 # 参考文献

--- a/notes/剑指
+++ b/notes/剑指
@ -2,13 +2,13 @@

 # 目录

- [3\~9](notes/剑指%20Offer%20题解%20-%203\~9.md)
- [10\~19](notes/剑指%20Offer%20题解%20-%2010\~19.md)
- [20\~29](notes/剑指%20Offer%20题解%20-%2020\~29.md)
- [30\~39](notes/剑指%20Offer%20题解%20-%2030\~39.md)
- [40\~49](notes/剑指%20Offer%20题解%20-%2040\~49.md)
- [50\~59](notes/剑指%20Offer%20题解%20-%2050\~59.md)
- [60\~68](notes/剑指%20Offer%20题解%20-%2060\~68.md)
+- [3\~9](./剑指 Offer 题解 - 3~9.md)
+- [10\~19](./剑指 Offer 题解 - 10~19.md)
+- [20\~29](./剑指 Offer 题解 - 20~29.md)
+- [30\~39](./剑指 Offer 题解 - 30~39.md)
+- [40\~49](./剑指 Offer 题解 - 40~49.md)
+- [50\~59](./剑指 Offer 题解 - 50~59.md)
+- [60\~68](./剑指 Offer 题解 - 60~68.md)

 # 参考文献