feat: add 026

Author: Blankj

README.md

@@ -15,6 +15,7 @@
 |19|[Remove Nth Node From End of List][019]|Linked List, Two Pointers|
 |20|[Valid Parentheses][020]|Stack, String|
 |21|[Merge Two Sorted Lists][021]|Linked List|
+|26|[Remove Duplicates from Sorted Array][026]|Linked List|
 
 
 ## Medium
@@ -44,3 +45,4 @@
 [019]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/019/README.md
 [020]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/020/README.md
 [021]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/021/README.md
+[026]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/026/README.md

note/007/README.md

@@ -29,7 +29,7 @@ The input is assumed to be a 32-bit signed integer. Your function should **retur
 
 ## 思路
 
-题意很清楚，就是给你一个整型数，返回它的逆序整型数，而且有个小坑点，当它的逆序整型数溢出的话，那么就返回0
+题意是给你一个整型数，求它的逆序整型数，而且有个小坑点，当它的逆序整型数溢出的话，那么就返回0
 ，用我们代码表示的话可以求得结果保存在long中，最后把结果和整型的两个范围比较即可。
 
 ``` java

note/019/README.md

@@ -20,6 +20,7 @@ Try to do this in one pass.
 
 **Tags:** Linked List, Two Pointers
 
+
 ## 思路
 
 题意是让你删除链表中的倒数第n个数，我的解法是利用双指针，这两个指针相差n个元素，当后面的指针扫到链表末尾的时候，自然它前面的那个指针所指向的下一个元素就是要删除的元素，即`pre.next = pre.next.next;`，但是如果一开始后面的指针指向的为空，此时代表的意思就是要删除第一个元素，即`head = head.next;`。

note/020/README.md

@@ -8,6 +8,7 @@ The brackets must close in the correct order, `"()"` and `"()[]{}"` are all vali
 
 **Tags:** Stack, String
 
+
 ## 思路
 
 题意是判断括号匹配是否正确，很明显，我们可以用栈来解决这个问题，当出现左括号的时候入栈，当遇到右括号时，判断栈顶的左括号是否何其匹配，不匹配的话直接返回`false`即可，最终判断是否空栈即可，这里我们可以用数组模拟栈的操作使其操作更快，有个细节注意下`top =  1;`，从而省去了之后判空的操作和`top - 1`导致数组越界的错误。

note/021/README.md

@@ -2,10 +2,18 @@
 
 ## Description
 
-Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.
+Given a sorted array, remove the duplicates in place such that each element appear only *once* and return the new length.
+
+Do not allocate extra space for another array, you must do this in place with constant memory.
+
+For example,
+Given input array *nums* = `[1,1,2]`,
+
+Your function should return length = `2`, with the first two elements of *nums* being `1` and `2` respectively. It doesn't matter what you leave beyond the new length.
 
 **Tags:** Linked List
 
+
 ## 思路
 
 题意是用一个新链表来合并两个已排序的链表，那我们只需要从头开始比较已排序的两个链表，新链表指针每次指向值小的节点，依次比较下去，最后，当其中一个链表到达了末尾，我们只需要把新链表指针指向另一个没有到末尾的链表此时的指针即可。

note/026/README.md

@@ -0,0 +1,45 @@
+# [Remove Duplicates from Sorted Array][title]
+
+## Description
+
+Given a sorted array, remove the duplicates in place such that each element appear only *once* and return the new length.
+
+Do not allocate extra space for another array, you must do this in place with constant memory.
+
+For example,
+Given input array *nums* = `[1,1,2]`,
+
+Your function should return length = `2`, with the first two elements of *nums* being `1` and `2` respectively. It doesn't matter what you leave beyond the new length.
+
+**Tags:** Array, Two Pointers
+
+
+## 思路
+
+题意是让你从一个有序的数组中移除重复的元素，并返回之后数组的长度。我的思路是判断长度小于等于1的话直接返回原长度即可，否则的话遍历一遍数组，用一个`tail`变量指向尾部，如果后面的元素和前面的元素不同，就让`tail`变量加一，最后返回tail即可。
+
+``` java
+public class Solution {
+    public int removeDuplicates(int[] nums) {
+        int len = nums.length;
+        if (len <= 1) return len;
+        int tail = 1;
+        for (int i = 1; i < len; ++i) {
+            if (nums[i - 1] != nums[i]) {
+                nums[tail++] = nums[i];
+            }
+        }
+        return tail;
+    }
+}
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode.com/problems/remove-duplicates-from-sorted-array
+[ajl]: https://github.com/Blankj/awesome-java-leetcode

project/LeetCode/leetcode/src/main/java/com/blankj/easy/_008/Solution.java

@@ -4,7 +4,7 @@
  * <pre>
  *     author: Blankj
  *     blog  : http://blankj.com
- *     time  : 2017/04/21
+ *     time  : 2017/04/23
  *     desc  :
  * </pre>
  */

project/LeetCode/leetcode/src/main/java/com/blankj/easy/_009/Solution.java

@@ -4,7 +4,7 @@
  * <pre>
  *     author: Blankj
  *     blog  : http://blankj.com
- *     time  : 2017/04/22
+ *     time  : 2017/04/24
  *     desc  :
  * </pre>
  */

project/LeetCode/leetcode/src/main/java/com/blankj/easy/_013/Solution.java

@@ -7,7 +7,7 @@
  * <pre>
  *     author: Blankj
  *     blog  : http://blankj.com
- *     time  : 2017/04/22
+ *     time  : 2017/04/25
  *     desc  :
  * </pre>
  */

project/LeetCode/leetcode/src/main/java/com/blankj/easy/_014/Solution.java

@@ -7,7 +7,7 @@
  * <pre>
  *     author: Blankj
  *     blog  : http://blankj.com
- *     time  : 2017/04/21
+ *     time  : 2017/04/26
  *     desc  :
  * </pre>
  */

project/LeetCode/leetcode/src/main/java/com/blankj/easy/_019/Solution.java

@@ -7,7 +7,7 @@
  * <pre>
  *     author: Blankj
  *     blog  : http://blankj.com
- *     time  : 2017/04/21
+ *     time  : 2017/04/27
  *     desc  :
  * </pre>
  */

project/LeetCode/leetcode/src/main/java/com/blankj/easy/_020/Solution.java

@@ -7,7 +7,7 @@
  * <pre>
  *     author: Blankj
  *     blog  : http://blankj.com
- *     time  : 2017/04/21
+ *     time  : 2017/04/28
  *     desc  :
  * </pre>
  */
@@ -35,5 +35,7 @@ else if (c == '}' && stack[top - 1] != '{')
 
     public static void main(String[] args) {
         Solution solution = new Solution();
+        System.out.println(solution.isValid("()[]{}({[]})"));
+        System.out.println(solution.isValid("(])]"));
     }
 }

project/LeetCode/leetcode/src/main/java/com/blankj/easy/_021/Solution.java

@@ -4,7 +4,7 @@
  * <pre>
  *     author: Blankj
  *     blog  : http://blankj.com
- *     time  : 2017/04/21
+ *     time  : 2017/04/29
  *     desc  :
  * </pre>
  */

project/LeetCode/leetcode/src/main/java/com/blankj/easy/_026/Solution.java

@@ -0,0 +1,33 @@
+package com.blankj.easy._026;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2017/04/21
+ *     desc  :
+ * </pre>
+ */
+
+public class Solution {
+    public int removeDuplicates(int[] nums) {
+        int len = nums.length;
+        if (len <= 1) return len;
+        int tail = 1;
+        for (int i = 1; i < len; ++i) {
+            if (nums[i - 1] != nums[i]) {
+                nums[tail++] = nums[i];
+            }
+        }
+        return tail;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        int[] data = new int[]{0, 1, 1, 2, 3, 3, 3};
+        int len = solution.removeDuplicates(data);
+        for (int i = 0; i < len; i++) {
+            System.out.print(data[i] + (i == len - 1 ? "" : ", "));
+        }
+    }
+}