[Function add]

1. Add leetcode solutions.

Author: Botao Xiao

README.md

@@ -415,6 +415,12 @@
 
 [236. Lowest Common Ancestor of a Binary Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/236.%20Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.md)
 
+[237. Delete Node in a Linked List](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/237.%20Delete%20Node%20in%20a%20Linked%20List.md)
+
+[238. Product of Array Except Self](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/238.%20Product%20of%20Array%20Except%20Self.md)
+
+[239. Sliding Window Maximum](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/239.%20Sliding%20Window%20Maximum.md)
+
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.
 All java realization codes are placed in different packages.

leetcode/237. Delete Node in a Linked List.md

@@ -51,4 +51,29 @@ class Solution {
         node.next = node.next.next;
     }
 }
-```
+```
+
+### 二刷
+1. Same as what I did in previous time.
+```Java
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public void deleteNode(ListNode node) {
+        ListNode cur = node;
+        ListNode pre = null;
+        while(cur.next != null){
+            cur.val = cur.next.val;
+            pre = cur;
+            cur = cur.next;
+        }
+        pre.next = null;
+    }
+}
+```

leetcode/238. Product of Array Except Self.md

@@ -39,4 +39,27 @@ class Solution {
         return result;
     }
 }
-```
+```
+
+### 二刷
+* Method 1:
+	1. We use a same size array to save the production of left side(exclude itself).
+	2. Then we traverse the array from end to top and time the values saved in the array to save the product of right side.
+	3. For each number, we actually times the left product with right product(itself is not included).
+```Java
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        int len = nums.length;
+        int[] result = new int[len];
+        for(int i = 0, temp = 1; i < len; i++){
+            result[i] = temp;
+            temp *= nums[i];
+        }
+        for(int i = len - 1, temp = 1; i >= 0; i--){
+            result[i] *= temp;
+            temp *= nums[i];
+        }
+        return result;
+    }
+}
+```

leetcode/239. Sliding Window Maximum.md

@@ -43,4 +43,32 @@ class Solution {
         return result;
     }
 }
-```
+```
+
+### 二刷
+1. Still use priority queue. It's not O(n);
+```Java
+class Solution {
+    public int[] maxSlidingWindow(int[] nums, int k) {
+        if(nums == null || nums.length == 0) return new int[0];
+        int len = nums.length;
+        int[] result = new int[len - k + 1];
+        PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
+            @Override
+            public int compare(Integer a, Integer b){
+                return b - a;
+            }
+        });
+        for(int i = 0; i < k; i++){
+            pq.offer(nums[i]);
+        }
+        for(int i = k; i <= nums.length; i++){
+            result[i - k] = pq.peek();
+            pq.remove(nums[i - k]);
+            if(i < nums.length)
+                pq.offer(nums[i]);
+        }
+        return result;
+    }
+}
+```