remove src dir

Author: andavid

note/001/README.md

@@ -21,7 +21,7 @@ return [0, 1].
 
 遍历数组，使用一个 HashMap 记录数组里的数及其索引，如果总数与当前数的差值在 HashMap 里存在相应的记录，就找到了。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -47,4 +47,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/two-sum
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_001/Solution.java
+

note/007/README.md

@@ -32,7 +32,7 @@ Assume we are dealing with an environment which could only hold integers within
 ## 思路
 使用长整型保存结果。依次模 10 得到最右边一位。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -50,4 +50,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/reverse-integer
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_007/Solution.java
+

note/008/README.md

@@ -29,7 +29,7 @@ If no valid conversion could be performed, a zero value is returned. If the corr
 3. 然后依次读取字符，如果是非数字字符或者数值超过 INT 最大值退出
 4. 结果乘以标志位，和 INT 最大值、INT 最小值进行比较
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -78,4 +78,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/string-to-integer-atoi
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_008/Solution.java
+

note/013/README.md

@@ -20,7 +20,7 @@ Input is guaranteed to be within the range from 1 to 3999.
 
 根据以上几个规则，主要是右加左减，可以从右往左扫描字符串，如果遇到 I、X、C 判断是减还是加，如果遇到其他罗马数字，直接累加。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -58,4 +58,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/roman-to-integer
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_013/Solution.java
+

note/014/README.md

@@ -16,7 +16,7 @@ LCP(S<sub>mid+1</sub>...S<sub>j</sub>)，其中 mid = (i+j) / 2.
 
 根据这两个子问题的解，即可求出最长公共前缀。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -97,5 +97,5 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/longest-common-prefix
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_014/Solution.java
+
 [src2]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_014/Solution2.java

note/019/README.md

@@ -21,7 +21,7 @@ Try to do this in one pass.
 
 如果知道链表的长度，就可以从前往后一次遍历就可以了。但是求链表长度还需要遍历一次，因此总共需要两次遍历。题目要求使用一次遍历，可以使用两个指针来实现。初始都指向 head，第一个指针前进 N 步，然后两个指针同时前进直到第一个指针到达链表末尾，第二个指针后面的那个节点就是要移除的节点。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 /**
@@ -56,4 +56,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/remove-nth-node-from-end-of-list
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_019/Solution.java
+

note/020/README.md

@@ -10,7 +10,7 @@ The brackets must close in the correct order, "()" and "()[]{}" are all valid bu
 
 使用一个堆栈，遍历字符串的字符，遇到 '(' 压入 ')'，遇到 '{' 压入 '}'，遇到 '[' 压入 ']'，遇到其他字符时，判断是否与栈顶字符相同。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -34,4 +34,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/valid-parentheses
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_020/Solution.java
+

note/021/README.md

@@ -13,7 +13,7 @@ Output: 1->1->2->3->4->4
 
 遍历两个链表，比较两个链表节点的大小，修改当前节点使其指向较小的那个节点。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 /**
@@ -90,5 +90,5 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/merge-two-sorted-lists
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_021/Solution.java
+
 [src2]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_021/Solution2.java

note/026/README.md

@@ -22,7 +22,7 @@ It doesn't matter what you leave beyond the new length.
 
 判断长度小于等于 1 的话直接返回原长度即可，否则的话遍历一遍数组，用一个 tail 变量指向新的数组尾部，如果后面的元素和前面的元素不同，就让后面的元素写到 tail 所指数组元素，然后 tail 变量加一，最后返回 tail 即可。
 
-## [完整代码][src]
+## 实现代码
 
 ```Java
 class Solution {
@@ -43,4 +43,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/remove-duplicates-from-sorted-array
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_026/Solution.java
+

note/028/README.md

@@ -24,7 +24,7 @@ Output: -1
 
 太简单了吧，indexOf 搞定。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -38,4 +38,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/implement-strstr
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_028/Solution.java
+

note/036/README.md

@@ -20,7 +20,7 @@ A valid Sudoku board (partially filled) is not necessarily solvable. Only the fi
 
 因此，只需要从左往右，从上到下，依次遍历 board 里的数字，一旦发现数字所在的行、列或小九宫格里该数字对应的位置为 true，说明不是有效的数独。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 import java.util.HashSet;
@@ -55,4 +55,4 @@ public class Solution {
 
 [title]: https://leetcode.com/problems/valid-sudoku
 [sudoku]: http://sudoku.com.au/TheRules.aspx
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_036/Solution.java
+

note/038/README.md

@@ -36,7 +36,7 @@ Output: "1211"
 ## 思路
 遍历字符串，如果当前字符和上一个字符不相同，则输出计数情况，否则计数器加1。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -70,4 +70,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/count-and-say
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_038/Solution.java
+

note/048/README.md

@@ -53,7 +53,7 @@ rotate the input matrix in-place such that it becomes:
 
 思路是从外往内，一圈一圈的进行。其中每一圈的每个元素顺时针旋转 90 度，连续操作四次。注意边界，防止重复操作。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -73,4 +73,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/rotate-image
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_048/Solution.java
+

note/053/README.md

@@ -19,7 +19,7 @@ If you have figured out the O(n) solution, try coding another solution using the
 
 如果局部最大值大于全局最大值，则进行更新。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -40,4 +40,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/maximum-subarray
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_053/Solution.java
+

note/066/README.md

@@ -12,7 +12,7 @@ The digits are stored such that the most significant digit is at the head of the
 一个整数按位从高到低依次存储到一个 int 数组中，从数组最后一位开始加 1，如果没有进位，只需修改最后一位即可，否则继续向前进位，如果一直到第一位都有进位，说明全部都是 9，新的数组长度需要加 1，首位是 1，其余位都是 0。
 时间复杂度 O(n)。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -41,4 +41,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/plus-one
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_066/Solution.java
+

note/070/README.md

@@ -37,7 +37,7 @@ Explanation:  There are three ways to climb to the top.
 爬到第 N 步有两种方法，从 第 N-1 步爬一步，或者从第 N-2 步爬两步。
 题目其实就是求斐波那契数列的第 N 个数。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -57,4 +57,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/climbing-stairs
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_070/Solution.java
+

note/088/README.md

@@ -19,7 +19,7 @@ You may assume that nums1 has enough space (size that is greater or equal to m +
 * 如果是第二个数组的数用完了，剩下的全是数组 1，不用填充了
 
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -40,4 +40,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/merge-sorted-array
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_088/Solution.java
+

note/098/README.md

@@ -34,7 +34,7 @@ Binary tree `[1,2,3]`, return false.
 递归。带上两个参数，分别表示最小值和最大值。
 左子树的最大值要小于根节点，右子树的最小值要大于根节点。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 /**
@@ -64,4 +64,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/validate-binary-search-tree
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_098/Solution.java
+

note/101/README.md

@@ -36,7 +36,7 @@ Bonus points if you could solve it both recursively and iteratively.
 * 如果左右孩子节点都不为空，但是值不相等，也不是对称的。
 * 如果左右孩子节点都不为空，且值相等，如果左孩子节点的左子树与右孩子节点的右子树是对称的，并且左孩子节点的右子树与右孩子节点的左子树是对称的，则二叉树是对称的。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 /**
@@ -105,5 +105,5 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/symmetric-tree
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_101/Solution.java
+
 [src2]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_101/Solution2.java

note/102/README.md

@@ -31,7 +31,7 @@ return its level order traversal as:
 * 如果节点不为空，把当前值加到列表，然后把节点的左右孩子节点压入队列尾部（如果孩子节点不为空）
 * 如果节点为空，并且队列不为空，则添加当前列表
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 /**
@@ -163,6 +163,6 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/binary-tree-level-order-traversal
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_102/Solution.java
+
 [src2]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_102/Solution2.java
 [src3]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_102/Solution3.java

note/104/README.md

@@ -23,7 +23,7 @@ return its depth = 3.
 
 递归。求二叉树 root 节点左子树和右子树的深度，其中较大的深度加 1 即为二叉树的深度。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 /**
@@ -67,5 +67,5 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/maximum-depth-of-binary-tree
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_104/Solution.java
+
 [src2]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_104/Solution2.java

note/108/README.md

@@ -26,7 +26,7 @@ One possible answer is: [0,-3,9,-10,null,5], which represents the following heig
 有序数组的中间作为平衡二叉树的根节点，前半部分作为左子树，后半部分作为右子树。
 
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 /**
@@ -55,4 +55,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_108/Solution.java
+

note/118/README.md

@@ -22,7 +22,7 @@ Return
 第 n 行有 n 个数字，第一个和最后一个数字为 1，其余每个数字等于它的左上方与右上方两个数字之和。
 因此，可以根据第 n - 1 行得到第 n 行。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -52,4 +52,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/pascals-triangle
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_118/Solution.java
+

note/119/README.md

@@ -15,7 +15,7 @@ Could you optimize your algorithm to use only O(k) extra space?
 
 如何从第 n-1 行的列表变化到第 n 行的列表？可以从后往前覆盖列表，将列表第 i 个元素的值与第 i-1 个元素的和覆盖到第 i 个元素，最后再添加末尾元素 1 即可。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -37,4 +37,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/pascals-triangle-ii
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_119/Solution.java
+

note/121/README.md

@@ -26,7 +26,7 @@ In this case, no transaction is done, i.e. max profit = 0.
 
 题意是给出一个数组代表每天的股票金额，让你在最多买卖一次的情况下算出最大的收益额。思路是遍历一次数组，每次记录当前值减去最小值的差值，与上一次的最大值进行比较然后更新最大值即可。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -50,4 +50,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/best-time-to-buy-and-sell-stock
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_121/Solution.java
+

note/122/README.md

@@ -11,7 +11,7 @@ Design an algorithm to find the maximum profit. You may complete as many transac
 
 只需要把所有相邻递增的值都加起来即可。
 
-## [完整代码][src]
+## 实现代码
 
 ```java
 class Solution {
@@ -29,4 +29,4 @@ class Solution {
 ```
 
 [title]: https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii
-[src]: https://github.com/andavid/leetcode-java/blob/master/src/com/andavid/leetcode/_122/Solution.java
+