Merge pull request #1 from algorithm001/master

Pull the latest code.

Author: hapiman

Week_01/.DS_Store

@@ -1 +1,58 @@
-# 学习笔记
+# 本周学习重点
+
+由于时间有限，本周学习重点放在 链表和数组 这两类题型上。
+
+一些比较有收获的点是：
+1. 同一类型的题目，可以从 easy 开始做，然后到 middle 最后再到 hard，层层递进，因为难题都是由简单题目演进而来的，由浅入深会比较容易接受，
+2. 做题前，先对“已知信息”做收集，然后再看利用已有知识，如何达到题目要求。
+3. 解题思路可以靠画图辅助梳理，解法也可以在纸上走一遍进行推导，不要上来就写代码。
+4. 最后，同一题可以尝试用不同的方法去解决。
+
+
+# 链表题型总结
+本周截止写这篇总结时，做完的链表题目有：
+- [leetcode.83.删除排序链表中的重复元素](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/)
+- [leetcode.21.合并两个有序链表](https://leetcode-cn.com/problems/merge-two-sorted-lists/)
+- [leetcode.24.两两交换链表中的节点](https://leetcode-cn.com/problems/swap-nodes-in-pairs/)
+- [leetcode.142.环形链表2](https://leetcode-cn.com/problems/linked-list-cycle-ii/)
+- [leetcode.25.k个一组翻转链表](https://leetcode-cn.com/problems/reverse-nodes-in-k-group/)
+
+一些小总结：
+- 链表题型，怎么都跑不了一些基本操作：插入节点（头、尾、中间），删除节点（头、尾、中间），相邻节点交换。所以，必须对这些操作熟悉的不能再熟悉。
+- 链表题型，比较常见的是：
+    - 删除指定条件的元素（eg：删除重复元素、删除倒数第k个节点、删除中间节点或a/b处的节点）
+    - 链表反转（eg：整体反转、两两反转、k个一组反转）
+    - 环的问题（eg：判断链表中是否有环、找到链表环的第一个节点）
+    - 两个链表的问题（eg：两个有序链表合并、求两个有序链表的公共部分）
+    - 。。。。。。
+- 链表问题的解法：
+    - 常规题，一般是辅助指针，加上常规的插入删除交换操作就可以搞定。
+    - 部分题型需要结合哈希表。
+    - 有一些题目需要用些小技巧，比如多次迭代、快慢指针等。
+- 写代码时需要注意的点：
+    - 注意不要丢节点，有一些操作的前后顺序很重要，一不小心就把后面的整条链给丢掉了。
+    - 也不要造成环，链表拆解或合并，最容易出现这种情况，一定要在纸上把流程捋清晰了再写代码。
+    - 有时候，加一个哨兵节点能够简化操作。
+
+
+# 数组题型总结
+本周截止到写这篇总结时，做完的链表题目有：
+- [leetcode.905.按奇偶排序数组](https://leetcode-cn.com/problems/sort-array-by-parity/)
+- [leetcpde.922.按奇偶排序数组2](https://leetcode-cn.com/problems/sort-array-by-parity-ii/)
+- [leetcode.153.寻找旋转排序数组中的最小值](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/submissions/)
+- [leetcode.33.搜索旋转排序数组](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/description/)
+- [leetcode.704.二分查找](https://leetcode-cn.com/problems/binary-search/)
+
+一些小总结：
+- 数组题型相比链表就比较杂了，我做过的题目也不是太多，以我浅薄的经验稍稍总结一下。
+- 数组的特点基本操作，一般是：数据移动交换或删除。不一般是：排序、二分、以及其他图算法等等。
+- 我目前做的这几道题，基本上都是排序和二分查找。几个关键点吧：
+    - 排序题目要么是冒泡、插入、归并等这些经典的算法题，要么是这些算法题的变种。其中以归并、快排的思路居多，也偶尔有一些插入排序的变形题。
+    - 查找类题目，只要要求了 O(logn)，基本上就二分没跑了，实现上可能能用递归解决。
+- 写代码时：
+    - 首先要注意数组越界问题。
+    - 接下来是需要用到的索引指针的初始化的问题。
+    - 以及，非常琐碎的边界点的问题，比如 是 > 还是 >=，是 left=middle 还是 left = middle+1。
+
+
+

Week_01/id_118/NOTE.md

@@ -0,0 +1,54 @@
+/**
+ * https://leetcode-cn.com/problems/linked-list-cycle-ii/
+ * 
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode detectCycle(ListNode head) {
+        // 不允许修改给定的链表。也就是不能在数据节点做标记，也不能修改链表节点指向。
+        // 第一种解法哈希表，第二种解法快慢指针。
+         
+        // 1. 边界处理
+        if(head == null ||  head.next == null){
+             return null;
+        }
+        
+        // 2. 加哨兵节点
+        ListNode guard = new ListNode(-1);
+        guard.next = head;
+        
+        // 3. 定义快慢指针
+        ListNode fast = guard;
+        ListNode slow = guard;
+        
+        // 4. 遍历，检查是否有环。
+        //  - 要是没环的话，会直接抛出去
+        //  - 要是有环的话，则快慢指针一定会相遇，退出循环
+        while(true){
+            if(fast.next == null || fast.next.next==null){
+                return null;
+            }
+            slow = slow.next;
+            fast = fast.next.next;
+            if(slow == fast){
+                break;
+            }
+        }
+        
+        // 5. 查找环的位置
+        slow = guard;
+        while(slow != fast){
+            slow = slow.next;
+            fast= fast.next;
+        }
+        return slow;        
+    }
+}

Week_01/id_118/leetcode_142_118.java

@@ -0,0 +1,33 @@
+/**
+ * https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/submissions/
+ */
+class Solution {
+    public int findMin(int[] nums) {
+        // 从旋转节点分隔，左侧数据 > 右侧数据，所以找到这个旋转点就能找到最小值。
+        
+        // 用二分的方式，进行递归
+        // - nums[left] > nums[right] 则最小值一定在左边
+        // - nums[left] < nums[right] 则最小值一定在右边
+        // 递归终止条件为：left==right 或 left+1==right，最小值为 nums[right]。
+        
+        // PS：有一个点要特别需要注意的是，如果本身已经有序了（第一个点<最后一个点），就不需要这么找了，第一个就是最小值。
+        
+        if(nums[0] < nums[nums.length-1]){
+            return nums[0];
+        }
+        return findMin(nums,0,nums.length-1);
+    }
+    
+    int findMin(int[] nums,int left,int right){
+        // 找到反转位置
+        if(left == right || left+1==right){
+            return nums[right];
+        }
+        int middle = left+(right-left)/2;
+        if(nums[left] > nums[middle]){
+            return findMin(nums,left,middle);
+        }else{
+            return findMin(nums,middle,right);
+        }
+    }
+}

Week_01/id_118/leetcode_153_118.java

@@ -0,0 +1,53 @@
+
+/**
+ *
+ * https://leetcode-cn.com/problems/merge-two-sorted-lists/submissions/
+ *
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+
+        // 1. 边界处理：两个都为null或任意一个为null
+        if(l1==null || l2==null ){
+            return l1 == null ? l2 : l1;
+        }
+
+        // 2. 初始化新链表中的节点。
+        // - 为了简化处理，初始化一个头结点作为哨兵节点，值为0。
+        // - 再初始化一个临时指针，指向头结点，从头开始往链表上挂节点。
+        ListNode head = new ListNode(0);
+        ListNode current = head;
+
+        // 3. 同时遍历两个链表，哪个头结点值最小，则把哪个节点的头拆下来
+        //  - 注意，拆头结点的时候，千万别把指针拆丢了
+        while(l1!=null && l2!=null){
+            if(l1.val<=l2.val){
+                current.next = l1;
+                l1=l1.next;
+            }else{
+                current.next = l2;
+                l2=l2.next;
+            }
+            current=current.next;
+            current.next = null;
+        }
+
+        // 4. 边界处理：可能某一个指针还没走完，直接无脑追加上就好了
+        if(l1!=null){
+            current.next = l1;
+        }
+        if(l2!=null){
+            current.next = l2;
+        }
+
+        // 5. 最后，返回 head.next，因为head节点数据无意义
+        return head.next;
+
+    }
+}

Week_01/id_118/leetcode_21_118.java

@@ -0,0 +1,52 @@
+/**
+ * https://leetcode-cn.com/problems/swap-nodes-in-pairs/
+ * 
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode swapPairs(ListNode head) {
+        
+        // 1. 边界：空链表或只有一个节点
+        if(head==null || head.next == null){
+            return head;
+        }
+        
+        // 2. 为了方便处理，需要加一个哨兵节点，指向 head
+        ListNode guard = new ListNode(0);
+        guard.next = head;
+        
+        // 3. 然后，两个节点的交换需要涉及到其前后节点，加起来共四个节点，按顺序分别将他们定义为：
+        // start_left,要交换两个节点中起点的前一个节点。初始为 guard
+        // start，要交换的起点。初始为 head
+        // end，要交换的终点。初始为 head.next
+        // end_right，要交换的两个节点中终点的后一个节点。初始为 head.next.next。这个节点有可能为空
+        ListNode start_left = guard;
+        ListNode start = head;
+        ListNode end = head.next;
+        ListNode end_right = head.next.next;
+        
+        // 4. 开始做节点交换和指针移动，end==null时停止
+        while(end!=null){
+            // 先交换
+            start_left.next = end;
+            start.next = end_right;
+            end.next = start;
+            // 后移动。注意判断接下来是否还有两个非空节点
+            if(end_right == null || end_right.next == null){
+                break;
+            }
+            start_left = start;
+            start = start_left.next;
+            end = start.next;
+            end_right = end.next;
+        }
+        
+        // 5. 最后返回 guard.next。注意，这里不要返回 head，因为head 已经被交换到第二个节点了。
+        return guard.next;
+    }
+}

Week_01/id_118/leetcode_24_118.java

@@ -0,0 +1,79 @@
+/**
+ * https://leetcode-cn.com/problems/reverse-nodes-in-k-group/
+ * 
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode reverseKGroup(ListNode head, int k) {
+        
+        // 1. 边界值处理：空指针、一个节点、k小于等于1
+        if(head==null || head.next==null || k<=1){
+            return head;
+        }
+        
+        // 2. 加哨兵节点
+        ListNode guard = new ListNode(0);
+        guard.next = head;
+        
+        // 3. 左侧已翻转完链表的尾节点，并将其指向 null，避免产生环
+        ListNode left = guard;
+        left.next = null;
+        
+        // 4. head 不为 null，则持续翻转
+        while(head!=null){
+            
+            // 判断剩下的部分是否还有 k 个节点能翻转
+            if(!hasEnoughNode(head,k)){
+                break;
+            }
+
+            // 把头结点提拉出来，作为翻转部分的第一个节点
+            ListNode new_tail = head;// 新翻转链表的尾节点
+            ListNode new_head = head;// 新翻转链表的头结点
+            head = head.next;
+            new_tail.next = null;// 这是为了避免误操作搞出环来
+            
+            // 然后再找k-1个节点出来，插到链表头
+            int count = k-1;
+            while(count!=0){
+                ListNode tmp = head;
+                head = head.next;
+                tmp.next = new_head;
+                new_head = tmp;
+                count--;
+            }
+            
+            // 左边的链表，和新翻转的链表串起来
+            left.next = new_head;
+            
+            // 移动尾巴
+            left = new_tail;
+        }
+        
+        // 5.最后再把没反转的部分给链上
+        left.next = head;
+        
+        // 6. 返回
+        return guard.next;
+    }
+    
+    
+    // 判断后面是否还有足够的节点可以反转。
+    boolean hasEnoughNode(ListNode head,int k){
+        ListNode tmp = head;
+        while(k!=0){
+            if(tmp == null){
+                return false;
+            }
+            tmp=tmp.next;
+            k--;
+        }
+        return true;
+    }
+    
+}

Week_01/id_118/leetcode_25_118.java

@@ -0,0 +1,44 @@
+/**
+ * https://leetcode-cn.com/problems/search-in-rotated-sorted-array/
+ */
+class Solution {
+    public int search(int[] A, int target) {
+        // 非递归
+        
+        // 边界处理
+        if(A.length<1){
+            return -1;
+        }
+        
+        // 定义左右索引
+        int left =0;
+        int right = A.length-1;
+        
+        // 折半搜索。需要特别注意，用 >= 还是 >，用 left=mid 还是 left=mid+1。十分重要！！！
+        while(left <= right){
+            int mid = (left+right)/2;
+            
+            if(A[mid] == target){
+                return mid;
+            }
+            
+            if(A[mid] < A[right]){
+                if(target>A[mid] && target<=A[right]){
+                    left=mid+1;
+                }
+                else{
+                    right = mid-1;
+                }
+            }else{
+                if(target>=A[left] && target<A[mid]){
+                    right=mid-1;
+                }else{
+                    left=mid+1;
+                }
+            }
+        }
+        // 没找到
+        return -1;
+    }
+    
+}