From 8e8f8ffa6328e771c986d3ae06ca3b7850db63bd Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Mon, 3 Jun 2019 18:49:52 +0800
Subject: [PATCH 01/22] number 1,remove-duplicates-from-sorted-array

In my opinon, it is not true to delete count add one of array
---
 Week_01/id_1/LeetCode_26_1.java | 57 +++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 Week_01/id_1/LeetCode_26_1.java

diff --git a/Week_01/id_1/LeetCode_26_1.java b/Week_01/id_1/LeetCode_26_1.java
new file mode 100644
index 00000000..15418e64
--- /dev/null
+++ b/Week_01/id_1/LeetCode_26_1.java
@@ -0,0 +1,57 @@
+package week01;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/3  18:00
+ * @描述
+ */
+public class ArrayMain {
+    public static void main(String[] args) {
+        System.out.println(removeDuplicates(new int[]{0,0,1,1,1,2,2,3,3,4}));
+    }
+
+    /***
+     * 26. 删除排序数组中的重复项  https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/
+     * @param nums
+     * @return
+     * 要求 O(1) 的额外空间实现
+     * 思路：
+     *      因为是排序好的数组，临时变量 count=0, temp=nums[0],后一个就跟temp 比较是否相等，不相等 则 count++，temp=nums[i];
+     *
+     *结论: 用两个临时变量，一个用来计数，一个用来保存上一个不相等的值；
+     */
+    public static int removeDuplicates(int[] nums) {
+        if(nums == null) return 0;
+        int count=0;
+        int temp=nums[0];
+        for(int i=1;i<nums.length;i++){
+            if(temp!=nums[i]){
+                count++;
+                temp=nums[i];
+                nums[count]=nums[i];
+            }
+        }
+        return count+1;
+    }
+
+    /***
+     * 26. 删除排序数组中的重复项  https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/
+     * @param nums
+     * @return
+     * 要求 O(1) 的额外空间实现
+     * 思路：
+     *      基于上面的思路， 临时变量 temp == nums[count] ; 所以temp 有点多余，可以直接用 nums[count] 与最新元素 来判断是否相等
+     *
+     */
+    public static int removeDuplicates2(int[] nums) {
+        if(nums.length == 0) return 0;
+        int count=0;
+        for(int i=1;i<nums.length;i++){
+            if(nums[count]!=nums[i]){
+                count++;
+                nums[count]=nums[i];
+            }
+        }
+        return count+1;
+    }
+}

From 3db079bc028ff7170246885552a6e344999156d8 Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Mon, 3 Jun 2019 18:55:45 +0800
Subject: [PATCH 02/22] I'm don't understand the situ sorting

---
 Week_01/id_1/NOTE.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Week_01/id_1/NOTE.md b/Week_01/id_1/NOTE.md
index 107ea7d6..b395d280 100644
--- a/Week_01/id_1/NOTE.md
+++ b/Week_01/id_1/NOTE.md
@@ -1 +1,5 @@
 # 学习笔记
+
+1.LeetCode 26 : I'm confused what is In situ sorting? Even if I looked up the answer in baike;
+
+  

From bef53e912e40bc7f19fb0d1c281c0d4c08e9d11a Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Tue, 4 Jun 2019 11:58:00 +0800
Subject: [PATCH 03/22] That is very simplify for method 2

Method one by my thinking;Method two is refer to the others
---
 Week_01/id_1/LeetCode_189_1.java | 69 ++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 Week_01/id_1/LeetCode_189_1.java

diff --git a/Week_01/id_1/LeetCode_189_1.java b/Week_01/id_1/LeetCode_189_1.java
new file mode 100644
index 00000000..5567ff6f
--- /dev/null
+++ b/Week_01/id_1/LeetCode_189_1.java
@@ -0,0 +1,69 @@
+package week01;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/4  9:41
+ * @描述 LeetCode:189. 旋转数组  https://leetcode-cn.com/problems/rotate-array/
+ */
+public class RotateArray {
+    public static void main(String[] args) {
+        final RotateArray rotateArray = new RotateArray();
+        int[] nums = new int[]{-1, -100, 3, 99};
+        rotateArray.rotate(nums, 2);
+        for (int num : nums) {
+            System.out.print(num + ",");
+        }
+    }
+
+    /**
+     * Function one :
+     * k,两层循环， 第一层 数组 array; 第二层 k,要移动的位置
+     * array[i] = array[length -1 ]
+     * 时间复杂度 : O(k*n)
+     * 空间复杂度 ： O(1)
+     */
+    public static void rotate1(int[] nums, int k) {
+        if (nums.length == 0 || k == 0) {
+            return;
+        }
+        int n = nums.length;
+        k %= n;
+        for (int j = 1; j <= k; j++) {
+            int tempLast = nums[n - 1];
+            for (int i = n - 1; i > 0; i--) {
+                nums[i] = nums[i - 1];
+            }
+            nums[0] = tempLast;
+        }
+    }
+
+    /**
+     * Function two:
+     * 反转的思路:
+     * 第一次： 全部反转 一遍
+     * 接下来以 k 为节点 进行区分         reverse(nums,0,n-1)
+     * 第二次： k 之前的 数据反转一遍         reverse(nums,0,k-1)
+     * 第三次： k 之后的 数据也要反转一遍     reverse(nums,k,n-1)
+     *
+     * @param nums
+     * @param k
+     */
+    public void rotate(int[] nums, int k) {
+        int n=nums.length;
+        k %= n;
+        reserve(nums,0,n-1);
+        reserve(nums,0,k-1);
+        reserve(nums,k,n-1);
+    }
+
+    private void reserve(int[] nums, int start, int end) {
+        while (start < end) {
+            int temp = nums[start];
+            nums[start] = nums[end];
+            nums[end] = temp;
+            start++;
+            end--;
+        }
+    }
+
+}

From 2f81add5e68cfbeee0bf70c06ed41579f78bef6d Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Tue, 4 Jun 2019 12:12:05 +0800
Subject: [PATCH 04/22] LeetCode 189 , two methods ;

I really like the second method,
---
 Week_01/id_1/NOTE.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/Week_01/id_1/NOTE.md b/Week_01/id_1/NOTE.md
index b395d280..30c7c332 100644
--- a/Week_01/id_1/NOTE.md
+++ b/Week_01/id_1/NOTE.md
@@ -2,4 +2,7 @@
 
 1.LeetCode 26 : I'm confused what is In situ sorting? Even if I looked up the answer in baike;
 
-  
+2.LeetCode 189 :  The first idea is use two layers of circulation, the variable of first layer of circulation  is numbers of times K, next    ,the variable is  length of array;  Time complexity is O(k*n),space complexity is O(1);To be exact, time complexity is O(n* k%=n) ;
+   Code review by refer to others , three of inversion ,the code is very clean , what's more the time complexity  is getting      shorter,O(n),exactly , O(2n);
+   
+   

From 40f318b05ce6faec82c77a351081874c09632bea Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Tue, 4 Jun 2019 17:22:09 +0800
Subject: [PATCH 05/22] Three methods to solve merge-sorted-array

---
 Week_01/id_1/LeetCode_88_1.java | 75 +++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 Week_01/id_1/LeetCode_88_1.java

diff --git a/Week_01/id_1/LeetCode_88_1.java b/Week_01/id_1/LeetCode_88_1.java
new file mode 100644
index 00000000..e593773b
--- /dev/null
+++ b/Week_01/id_1/LeetCode_88_1.java
@@ -0,0 +1,75 @@
+package week01;
+
+import java.util.Arrays;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/4  14:55
+ * @描述 LeetCode : 88. 合并两个有序数组  https://leetcode-cn.com/problems/merge-sorted-array/
+ */
+public class MergeSortedArray {
+    public static void main(String[] args) {
+        MergeSortedArray array = new MergeSortedArray();
+        int[] a1 = new int[]{ 2, 3,4, 0, 0, 0};
+        int[] a2 = new int[]{3, 5, 6};
+        int m = 3;
+        int n = 3;
+        array.merge3(a1, m, a2, n);
+        for (int i : a1) {
+            System.out.print(i + ",");
+        }
+    }
+
+    // 方法1： 第二个数组 插入 第一个数组； 再对第一个数组进行排序
+    public void merge1(int[] nums1, int m, int[] nums2, int n) {
+        if (nums2.length == 0 || nums1.length == 0) {
+            return;
+        }
+        for (int i = 0; i < nums2.length; i++) {
+            nums1[m + i] = nums2[i];
+        }
+        Arrays.sort(nums1);
+        for (int i : nums1) {
+            System.out.print(i + ",");
+        }
+    }
+
+    // 方法2： 从前往后 进行合并
+    public void merge2(int[] nums1, int m, int[] nums2, int n) {
+        if (nums2.length == 0) {
+            return;
+        }
+        int[] nums1Copy = new int[m];
+        System.arraycopy(nums1, 0, nums1Copy, 0, m);
+        int p1 = 0;
+        int p2 = 0;
+        int newP = 0;
+        while (p1 < m && p2 < n) {
+            nums1[newP++] = (nums1Copy[p1] < nums2[p2] ? nums1Copy[p1++] : nums2[p2++]);
+        }
+        if (p1 < m) {
+            System.arraycopy(nums1Copy, p1, nums1, p1 + p2, m - p1);
+        }
+        if (p2 < n) {
+            System.arraycopy(nums2, p2, nums1, p1 + p2, n - p2);
+        }
+    }
+
+    // 方法3 ：  从后往前 进行合并
+    public void merge3(int[] nums1, int m, int[] nums2, int n) {
+        if (nums2.length == 0) {
+            return;
+        }
+        int p1 = m - 1;
+        int p2 = n - 1;
+        int newP = m + n - 1;
+        while (p1 >= 0 && p2 >= 0) {
+            nums1[newP--] = (nums1[p1] > nums2[p2] ? nums1[p1--] :nums2[p2--]);
+        }
+        if(p2>=0){
+            System.arraycopy(nums2,0,nums1,0,p2+1);
+        }
+    }
+
+
+}

From 473c8a317dc811373702738ad2b6b20ef7930463 Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Tue, 4 Jun 2019 17:25:59 +0800
Subject: [PATCH 06/22] Some do'nt understand about temporary variable

---
 Week_01/id_1/LeetCode_21_1.java | 47 +++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 Week_01/id_1/LeetCode_21_1.java

diff --git a/Week_01/id_1/LeetCode_21_1.java b/Week_01/id_1/LeetCode_21_1.java
new file mode 100644
index 00000000..6e7d83f1
--- /dev/null
+++ b/Week_01/id_1/LeetCode_21_1.java
@@ -0,0 +1,47 @@
+package week01;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/4  12:44
+ * @描述  LeetCode : 21. 合并两个有序链表     https://leetcode-cn.com/problems/merge-two-sorted-lists/submissions/
+ */
+public class MergeTwoSortedLists {
+    public static void main(String[] args) {
+        final MergeTwoSortedLists sortedLists = new MergeTwoSortedLists();
+        final ListNode node1 = new ListNode(1);
+        node1.next = new ListNode(2);
+        node1.next.next = new ListNode(4);
+
+        final ListNode node2 = new ListNode(1);
+        node2.next = new ListNode(3);
+        node2.next.next = new ListNode(4);
+        ListNode listNode = sortedLists.mergeTwoLists(node1, node2);
+        System.out.println(listNode);
+    }
+
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+        if (l1 == null || l2 == null) {
+            return l1 == null ? l2 : l1;
+        }
+        ListNode node = new ListNode(Math.min(l1.val, l2.val));
+        if (l1.val <= l2.val) {
+            l1 = l1.next;
+        } else {
+            l2 = l2.next;
+        }
+        ListNode curr = node; // why ?? why need create a temporary variable?
+        while (l1 != null && l2 != null) {
+            if (l1.val <= l2.val) {
+                curr.next = new ListNode(l1.val);
+                l1 = l1.next;
+            } else {
+                curr.next = new ListNode(l2.val);
+                l2 = l2.next;
+            }
+            curr = curr.next;
+        }
+        curr.next = l1 == null ? l2 : l1;
+        return node;
+    }
+
+}

From beb018c5b411003ac6c1bf978ef9621438624ae2 Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Tue, 4 Jun 2019 17:42:05 +0800
Subject: [PATCH 07/22] Solutions about LeetCode 21 and 88

---
 Week_01/id_1/NOTE.md | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/Week_01/id_1/NOTE.md b/Week_01/id_1/NOTE.md
index 30c7c332..4f4981fa 100644
--- a/Week_01/id_1/NOTE.md
+++ b/Week_01/id_1/NOTE.md
@@ -4,5 +4,12 @@
 
 2.LeetCode 189 :  The first idea is use two layers of circulation, the variable of first layer of circulation  is numbers of times K, next    ,the variable is  length of array;  Time complexity is O(k*n),space complexity is O(1);To be exact, time complexity is O(n* k%=n) ;
    Code review by refer to others , three of inversion ,the code is very clean , what's more the time complexity  is getting      shorter,O(n),exactly , O(2n);
+
+3.LeetCode 21: I can understand the way of solving problem, but don't understand why use a temporiry variable to next pointer? 
+
+4.LeetCode 88 : At first, i can think of two ways to do it. 
+      One: Add the second array directly to the first array, and then sort it; (time complexity is O(n+nlogn) , space complexity is O(1) )
+      Two:  Before and after thoughts, compare the size of the preceding element int two arrays, the smaller element plus(+1)
+      Three: It's the opposite of the last one. After and before thoughts. Operate directly within large array.
    
    

From 9475b5b483973c13cf013a8c6d02389f191964ad Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Wed, 5 Jun 2019 13:22:24 +0800
Subject: [PATCH 08/22] Id's hard to understand recursion in here

---
 Week_01/id_1/LeetCode_24_1.java | 57 +++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 Week_01/id_1/LeetCode_24_1.java

diff --git a/Week_01/id_1/LeetCode_24_1.java b/Week_01/id_1/LeetCode_24_1.java
new file mode 100644
index 00000000..2413dab0
--- /dev/null
+++ b/Week_01/id_1/LeetCode_24_1.java
@@ -0,0 +1,57 @@
+package week01;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/4  17:53
+ * @描述 LeetCode: 24. 两两交换链表中的节点     https://leetcode-cn.com/problems/swap-nodes-in-pairs/
+ */
+public class SwapNodesInPairs {
+    public static void main(String[] args) {
+        SwapNodesInPairs nodes = new SwapNodesInPairs();
+        ListNode head = new ListNode(1);
+        head.next = new ListNode(2);
+        head.next.next = new ListNode(3);
+        head.next.next.next = new ListNode(4);
+        ListNode node = nodes.swapPairs2(head);
+        System.out.println(node);
+    }
+
+    /**
+     * 思路：
+     * 循环解决
+     *      1、加一个初始节点 root; root --> head
+     *      2、三步完成转化过程：
+     *          1、初始节点 next 指向 第二个节点 ； root.next = root.next.next
+     *          2、原 之前的第一个节点的 next 指向 第二个节点的下一个 ：first.next = second
+     *          3、第二个节点的 next 指向第一个 second.next = first;
+     *          4、 交换完成后； 当前节点 往后面 走 两个  next;
+     *              走一步 next: curr = second;
+     *              走两步 next: curr = first (curr = second.next)
+     * @param head
+     * @return
+     */
+    public ListNode swapPairs(ListNode head) {
+        ListNode root = new ListNode(0);
+        root.next = head;
+        ListNode curr = root;
+        while (curr.next != null && curr.next.next != null) {
+            ListNode first = curr.next;
+            ListNode second = curr.next.next;
+            curr.next = second;
+            first.next = second.next;
+            second.next = first;
+            curr = first;
+        }
+        return root.next;
+    }
+
+    public ListNode swapPairs2(ListNode head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+        ListNode next = head.next;
+        head.next = swapPairs2(head.next.next);
+        next.next = head;
+        return next;
+    }
+}

From bca065f9ab5866466fcbba52968e2e1c53cbc47b Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Wed, 5 Jun 2019 13:23:38 +0800
Subject: [PATCH 09/22] Four methods to solve this problem

---
 Week_01/id_1/LeetCode_242_1.java | 110 +++++++++++++++++++++++++++++++
 1 file changed, 110 insertions(+)
 create mode 100644 Week_01/id_1/LeetCode_242_1.java

diff --git a/Week_01/id_1/LeetCode_242_1.java b/Week_01/id_1/LeetCode_242_1.java
new file mode 100644
index 00000000..cf0ae277
--- /dev/null
+++ b/Week_01/id_1/LeetCode_242_1.java
@@ -0,0 +1,110 @@
+package week01;
+
+import java.util.Arrays;
+import java.util.HashMap;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/5  12:32
+ * @描述  LeetCode: 242. 有效的字母异位词  https://leetcode-cn.com/problems/valid-anagram/
+ *  最优解 ：Method 4: 时间复杂度 ： O(n)  空间复杂度： O(1)
+ */
+public class ValidAnagram {
+    public static void main(String[] args) {
+         ValidAnagram anagram = new ValidAnagram();
+         String s = "anagram", t = "nagaram";
+        System.out.println(anagram.isAnagram4(s,t));
+    }
+
+    /**
+     *  Method 1 :  排序比较法
+     *      思路： 将两个 字母转化成 char 数组，再一一比较
+     *      数组采用的排序方式是 快速排序，
+     *      时间复杂度 ： O(2*n*logn + n)  空间复杂度： O(1)
+     *
+     * @param s
+     * @param t
+     * @return
+     */
+    public boolean isAnagram(String s, String t) {
+        final char[] charsOne = s.toCharArray();
+        final char[] charsTwo = t.toCharArray();
+        if(charsOne.length != charsTwo.length){
+            return false;
+        }
+        Arrays.sort(charsOne);
+        Arrays.sort(charsTwo);
+        for(int i=0;i<charsOne.length;i++){
+            if(charsOne[i]!=charsTwo[i]){
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     *  Method 2: 方法的简化版
+     *  时间复杂度 ： O(2*n*logn)  空间复杂度： O(1)
+     * @param s
+     * @param t
+     * @return
+     */
+    public boolean isAnagram2(String s, String t) {
+        final char[] charsOne = s.toCharArray();
+        final char[] charsTwo = t.toCharArray();
+        Arrays.sort(charsOne);
+        Arrays.sort(charsTwo);
+        return String.valueOf(charsOne).equals(String.valueOf(charsTwo));
+    }
+
+    /**
+     * Method 3: HashMap 来解决；  额外的空间 map, O(n)
+     *  时间复杂度 ： O(2n)  空间复杂度： O(n)
+     */
+    public boolean isAnagram3(String s, String t) {
+         HashMap<Character, Integer> map = new HashMap<>();
+        for (char c : s.toCharArray()) {
+            map.put(c,map.getOrDefault(c,0)+1);
+        }
+        for (char c : t.toCharArray()) {
+            final Integer integer = map.get(c);
+            if(integer==null){
+                return false;
+            }else if(integer>1){
+                map.put(c,integer-1);
+            }else{
+                map.remove(c);
+            }
+        }
+        return map.isEmpty();
+    }
+
+    /**
+     * Method 4: 用 26 个字母的 数组来 进行操作； 第一个数组 出现的字母的数组就++ ； 第一个数组 出现的字母的数组就 -- ；
+     * 时间复杂度 ： O(n)  空间复杂度： O(1)
+     * @param s
+     * @param t
+     * @return
+     */
+    public boolean isAnagram4(String s, String t) {
+        if(s.length() != t.length()){
+            return false;
+        }
+        final char[] charsOne = s.toCharArray();
+        final char[] charsTwo = t.toCharArray();
+        int[] array = new int[26];
+        for(int i=0;i<s.length();i++){
+            array[charsOne[i]-'a']++;
+            array[charsTwo[i]-'a']--;
+        }
+        for (int i : array) {
+            if(i!=0){
+                return false;
+            }
+        }
+        return true;
+    }
+
+
+
+    }

From 4ec280d4f4fc285ee9e1cf14b1cf1eda62390303 Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Wed, 5 Jun 2019 13:27:58 +0800
Subject: [PATCH 10/22] Update NOTE.md

---
 Week_01/id_1/NOTE.md | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/Week_01/id_1/NOTE.md b/Week_01/id_1/NOTE.md
index 4f4981fa..bfe00604 100644
--- a/Week_01/id_1/NOTE.md
+++ b/Week_01/id_1/NOTE.md
@@ -1,9 +1,9 @@
 # 学习笔记
 
-1.LeetCode 26 : I'm confused what is In situ sorting? Even if I looked up the answer in baike;
+1.LeetCode 26 : I'm confused what is In situ sorting? Even if I looked up the answer in baike.
 
 2.LeetCode 189 :  The first idea is use two layers of circulation, the variable of first layer of circulation  is numbers of times K, next    ,the variable is  length of array;  Time complexity is O(k*n),space complexity is O(1);To be exact, time complexity is O(n* k%=n) ;
-   Code review by refer to others , three of inversion ,the code is very clean , what's more the time complexity  is getting      shorter,O(n),exactly , O(2n);
+   Code review by refer to others , three of inversion ,the code is very clean , what's more the time complexity  is getting      shorter,O(n),exactly , O(2n).
 
 3.LeetCode 21: I can understand the way of solving problem, but don't understand why use a temporiry variable to next pointer? 
 
@@ -11,5 +11,8 @@
       One: Add the second array directly to the first array, and then sort it; (time complexity is O(n+nlogn) , space complexity is O(1) )
       Two:  Before and after thoughts, compare the size of the preceding element int two arrays, the smaller element plus(+1)
       Three: It's the opposite of the last one. After and before thoughts. Operate directly within large array.
-   
+      
+5.LeetCode 24: It's a little hard.Especially, recursive solution.
+
+6.LeetCode 242： Four solutions came to mind. Simple but fun.
    

From ca9a183ad51bde6fa0520d3b3bfe070e6ce163c5 Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Wed, 5 Jun 2019 16:21:19 +0800
Subject: [PATCH 11/22] Three ways to solve this problem with Map.

---
 Week_01/id_1/LeetCode_49_1.java | 100 ++++++++++++++++++++++++++++++++
 1 file changed, 100 insertions(+)
 create mode 100644 Week_01/id_1/LeetCode_49_1.java

diff --git a/Week_01/id_1/LeetCode_49_1.java b/Week_01/id_1/LeetCode_49_1.java
new file mode 100644
index 00000000..9414b7f7
--- /dev/null
+++ b/Week_01/id_1/LeetCode_49_1.java
@@ -0,0 +1,100 @@
+package week01;
+
+
+import java.util.*;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/5  14:18
+ * @描述 LeetCode: 49. 字母异位词分组   https://leetcode-cn.com/problems/group-anagrams/
+ */
+public class GroupAnagrams {
+    public static void main(String[] args) {
+        GroupAnagrams anagrams = new GroupAnagrams();
+        String[] strs = {"eat", "tea", "tan", "ate", "nat", "bat"};
+        final List<List<String>> lists = anagrams.groupAnagram3(strs);
+        for (List<String> list : lists) {
+            for (String s : list) {
+                System.out.print(s + ",");
+            }
+            System.out.println();
+        }
+    }
+
+    /**
+     * Method 1: 第一想法 对 数组当中的每一个元素的字母进行排序；然后使用map 来进行排序相同进行分组
+     * 时间复杂度： O(NKlogK) ; 空间复杂度： O(NK)
+     *
+     * @param strs
+     * @return
+     */
+    public List<List<String>> groupAnagrams(String[] strs) {
+        if (strs.length == 0) {
+            return null;
+        }
+        List<List<String>> lists = new ArrayList<>();
+        Map<String, List<String>> map = new HashMap<>();
+        for (int i = 0; i < strs.length; i++) {
+            final char[] chars = strs[i].toCharArray();
+            Arrays.sort(chars);
+            String temp = String.valueOf(chars);
+            List<String> list = new ArrayList<>();
+            if (map.get(temp) != null) {
+                list = map.get(temp);
+            }
+            list.add(strs[i]);
+            map.put(temp, list);
+        }
+        for (List<String> list : map.values()) {
+            lists.add(list);
+        }
+        return lists;
+    }
+
+    /**
+     * Method 2 : 在方法一的基础上面 进行简化；
+     * 直接在数据循环时处理 字母异位词
+     * 时间复杂度： O(N*KlonK) ; 空间复杂度： O(K)
+     */
+    public List<List<String>> groupAnagrams2(String[] strs) {
+        if (strs.length == 0) {
+            return new ArrayList<List<String>>();
+        }
+        Map<String, List<String>> map = new HashMap<>();
+        for (int i = 0; i < strs.length; i++) {
+            char[] chars = strs[i].toCharArray();
+            Arrays.sort(chars);
+            String temp = String.valueOf(chars);
+            if (map.get(temp) == null) { map.put(temp, new ArrayList<String>());}
+            map.get(temp).add(strs[i]);
+        }
+        return new ArrayList<>(map.values());
+
+    }
+
+    /**
+     * Method 3:  不使用字符串 转数组 排序； 用 26 个字母的数组 来存储 每个字母
+     *
+     * 时间复杂度： O(N*K) ; 空间复杂度：O(K)
+     *
+     */
+    public List<List<String>> groupAnagram3(String[] strs) {
+        if(strs.length==0){
+            return new ArrayList<List<String>>();
+        }
+        Map<String, List<String>> map = new HashMap<>();
+        for (String str : strs) {
+             int[] ints = new int[26];
+             char[] chars = str.toCharArray();
+            for(int i=0;i<chars.length;i++){
+                ints[chars[i]-'a']++;
+            }
+            String temp=Arrays.toString(ints);
+             List<String> mapOrDefault = map.getOrDefault(temp, new ArrayList<>());
+             mapOrDefault.add(str);
+             map.put(temp,mapOrDefault);
+        }
+        return new ArrayList<>(map.values());
+    }
+
+}

From a800b30591821e924be94a4e12a5f73de23cb2e1 Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Wed, 5 Jun 2019 16:25:38 +0800
Subject: [PATCH 12/22] Update NOTE.md

---
 Week_01/id_1/NOTE.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Week_01/id_1/NOTE.md b/Week_01/id_1/NOTE.md
index bfe00604..f00fabbd 100644
--- a/Week_01/id_1/NOTE.md
+++ b/Week_01/id_1/NOTE.md
@@ -16,3 +16,4 @@
 
 6.LeetCode 242： Four solutions came to mind. Simple but fun.
    
+7.LeetCode 49: First thought use Map to solve this problem. Three answers came up.

From ac25bf1c4bf3e88224d42b56548e10929e853e53 Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Thu, 6 Jun 2019 18:42:04 +0800
Subject: [PATCH 13/22] Two Ways to solve this problem

---
 Week_01/id_1/LeetCode_1_1.java | 53 ++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 Week_01/id_1/LeetCode_1_1.java

diff --git a/Week_01/id_1/LeetCode_1_1.java b/Week_01/id_1/LeetCode_1_1.java
new file mode 100644
index 00000000..245502ec
--- /dev/null
+++ b/Week_01/id_1/LeetCode_1_1.java
@@ -0,0 +1,53 @@
+package week01;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/6  10:20
+ * @描述     LeetCode: 1. 两数之和    https://leetcode-cn.com/problems/two-sum/
+ */
+public class TwoNum {
+    public static void main(String[] args) {
+        final TwoNum twoNum = new TwoNum();
+        int[] nums={3, 2, 4};
+        final int[] ints = twoNum.twoSum2(nums, 6);
+        for (int anInt : ints) {
+            System.out.print(anInt+",");
+        }
+    }
+
+    /**
+     * Method 1 : 暴力法， 两层循环解决
+     *  时间复杂度： O(N*N) ; 空间复杂度： O(N)
+     *
+     */
+    public int[] twoSum(int[] nums, int target) {
+        for(int i=0;i<nums.length-1;i++){
+            for(int j=i+1;j<nums.length;j++){
+                if(target-nums[i]==nums[j]){
+                    return new int[]{i,j};
+                }
+            }
+        }
+        return new int[1];
+    }
+
+    /**
+     * Method 2 :  使用Map来进行存储，key: 数组下标 ； value: 数组下标对应的值； 循环一遍，并把值存储到map中，后面的循环来进行比较；
+     *  时间复杂度： O(N) ;  空间复杂度： O(N) ；
+     */
+    public int[] twoSum2(int[] nums, int target) {
+        final Map<Integer, Integer> map = new HashMap<>();
+        for(int i=0;i<nums.length;i++){
+            int temp=target-nums[i];
+            if(map.containsKey(temp)){
+                return new int[]{map.get(temp),i};
+            }
+            map.put(nums[i],i);
+        }
+        return new int[0];
+    }
+
+    }

From 9eb3895faf030b649ec9f97028a15d3d54ed36a2 Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Thu, 6 Jun 2019 18:43:28 +0800
Subject: [PATCH 14/22] Two ways to solve this problem;Violence method timeout

---
 Week_01/id_1/LeetCode_15_1.java | 116 ++++++++++++++++++++++++++++++++
 1 file changed, 116 insertions(+)
 create mode 100644 Week_01/id_1/LeetCode_15_1.java

diff --git a/Week_01/id_1/LeetCode_15_1.java b/Week_01/id_1/LeetCode_15_1.java
new file mode 100644
index 00000000..e6398698
--- /dev/null
+++ b/Week_01/id_1/LeetCode_15_1.java
@@ -0,0 +1,116 @@
+package week01;
+
+import java.util.*;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/5  16:34
+ * @描述 LeerCode :  15. 三数之和 ; https://leetcode-cn.com/problems/3sum/
+ */
+public class ThreeSum {
+    public static void main(String[] args) {
+        final ThreeSum threeSum = new ThreeSum();
+        int[] ints = {-1, 0, 1};
+        int[] int2 = {-1, 0, 1, 2, -1, -4};
+        int[] int3 = {0, 0, 0, 0};
+        int[] int4 = {-4, -2, 1, -5, -4, -4, 4, -2, 0, 4, 0, -2, 3, 1, -5, 0};
+        final List<List<Integer>> lists = threeSum.threeSum(ints);
+        for (List<Integer> list : lists) {
+            for (Integer integer : list) {
+                System.out.print(integer + ",");
+            }
+            System.out.println();
+        }
+        System.out.println("-----------------------");
+        final List<List<Integer>> lists2 = threeSum.threeSum(int2);
+        for (List<Integer> list : lists2) {
+            for (Integer integer : list) {
+                System.out.print(integer + ",");
+            }
+            System.out.println();
+        }
+        System.out.println("-----------------------");
+        final List<List<Integer>> lists3 = threeSum.threeSum(int3);
+        for (List<Integer> list : lists3) {
+            for (Integer integer : list) {
+                System.out.print(integer + ",");
+            }
+            System.out.println();
+        }
+        System.out.println("-----------------------");
+        final List<List<Integer>> lists4 = threeSum.threeSum(int4);
+        for (List<Integer> list : lists4) {
+            for (Integer integer : list) {
+                System.out.print(integer + ",");
+            }
+            System.out.println();
+        }
+        System.out.println("----------------33333-------");
+        final List<List<Integer>> lists5 = threeSum.threeSum3(int4);
+        for (List<Integer> list : lists5) {
+            for (Integer integer : list) {
+                System.out.print(integer + ",");
+            }
+            System.out.println();
+        }
+    }
+
+
+    /**
+     * Method 1: 暴力法; 3 层循环  ——>  超时了......
+     * 时间复杂度 ： O(N*N*N+NlogN)   ;  空间复杂度 : O(N)
+     */
+    public List<List<Integer>> threeSum(int[] nums) {
+        Arrays.sort(nums);
+        List<List<Integer>> lists = new LinkedList<>();
+        for (int i = 0; i < nums.length - 2 && nums[i] <= 0; i++) {
+            if (i == 0 || i > 0 && nums[i] != nums[i - 1]) {
+                for (int j = i + 1; j < nums.length - 1 && nums[i] + nums[j] <= 0; j++) {
+                    if ( nums[j] != nums[j + 1]) {
+                        for (int k = j + 1; k < nums.length; k++) {
+//                    if (k > 2 && nums[k] == nums[k - 1]) continue;
+                            if (nums[i] + nums[j] + nums[k] == 0) {
+                                List<Integer> list = Arrays.asList(nums[i], nums[j], nums[k]);
+                                lists.add(list);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return lists;
+    }
+
+    /**
+     * 寻找新的解决方法
+     * Method 3 : 排序后 ，再循环里面 ，从两边往中间 查找
+     */
+    public List<List<Integer>> threeSum3(int[] nums) {
+        Arrays.sort(nums);
+        List<List<Integer>> lists = new LinkedList<>();
+        for (int i = 0; i < nums.length - 2; i++) {
+            if (i == 0 || (i > 0 && nums[i] != nums[i - 1])) {
+
+
+                int left = i + 1, right = nums.length - 1, needValue = 0 - nums[i];
+                while (left < right) {
+                    if (needValue == (nums[left] + nums[right])) {
+                        if (!lists.contains(Arrays.asList(nums[i], nums[left], nums[right]))) {
+                            lists.add(Arrays.asList(nums[i], nums[left], nums[right]));
+                        }
+                        while (left < right && nums[right] == nums[right - 1]) right--;
+                        while (left < right && nums[left] == nums[left + 1]) left++;
+                        right--;
+                        left++;
+                    } else if (needValue < (nums[left] + nums[right])) {
+                        right--;
+                    } else {
+                        left++;
+                    }
+                }
+            }
+        }
+        return lists;
+    }
+
+}

From 403cd5cffbc2d39ad41e9202be2bc3cceccaae65 Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Thu, 6 Jun 2019 18:45:00 +0800
Subject: [PATCH 15/22] Using and not using the stack

---
 Week_01/id_1/LeetCode_1047_1.java | 54 +++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 Week_01/id_1/LeetCode_1047_1.java

diff --git a/Week_01/id_1/LeetCode_1047_1.java b/Week_01/id_1/LeetCode_1047_1.java
new file mode 100644
index 00000000..9c520d0d
--- /dev/null
+++ b/Week_01/id_1/LeetCode_1047_1.java
@@ -0,0 +1,54 @@
+package week01;
+
+import java.util.Stack;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/6  12:41
+ * @描述 LeetCode : 1047. 删除字符串中的所有相邻重复项     https://leetcode-cn.com/problems/remove-all-adjacent-duplicates-in-string/
+ */
+public class RemoveAllAdjacent {
+    public static void main(String[] args) {
+        final RemoveAllAdjacent adjacent = new RemoveAllAdjacent();
+        System.out.println(adjacent.removeDuplicates2("abbaca"));
+    }
+
+    /**
+     * Method 1 :  使用堆栈 stack ;
+     * 时间复杂度 ： O(N*K*K) ; 空间复杂度：O(N)
+     */
+    public String removeDuplicates(String S) {
+        final Stack<Character> stack = new Stack<>();
+        for (Character item : S.toCharArray()) {
+            if (!stack.empty() && stack.peek() == item) {
+                stack.pop();
+            } else {
+                stack.push(item);
+            }
+        }
+        final StringBuilder builder = new StringBuilder();
+        while (!stack.empty()) {
+            builder.append(stack.pop());
+        }
+        return builder.reverse().toString();
+    }
+
+    /**
+     * Method 2 : 数组使用
+     *  时间复杂度： O(S.length()) —> O(N)   ；   空间复杂度： O(S.length) —> O(N)
+     */
+    public String removeDuplicates2(String S) {
+        final char[] chars = S.toCharArray();
+        int top = 0;
+        for (char c : chars) {
+            if (top > 0 && chars[top - 1] == c) {
+                top--;
+                continue;
+            }
+            chars[top++] = c;
+        }
+        return new String(chars, 0, top);
+    }
+
+
+}

From 67d8c50327fc01827a871374e6db5bb418630366 Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Thu, 6 Jun 2019 18:46:46 +0800
Subject: [PATCH 16/22] Using and not using the stack;It's faster not to use
 the stack

---
 Week_01/id_1/LeetCode_1021_1.java | 61 +++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 Week_01/id_1/LeetCode_1021_1.java

diff --git a/Week_01/id_1/LeetCode_1021_1.java b/Week_01/id_1/LeetCode_1021_1.java
new file mode 100644
index 00000000..d7869763
--- /dev/null
+++ b/Week_01/id_1/LeetCode_1021_1.java
@@ -0,0 +1,61 @@
+package week01;
+
+import java.util.Stack;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/6  18:00
+ * @描述 LeetCode : 1021. 删除最外层的括号    https://leetcode-cn.com/problems/remove-outermost-parentheses/
+ */
+public class RemoveOuterMostParenteses {
+
+    public static void main(String[] args) {
+        String str = "(()())(())";
+        String str2 = "(()())(())(()(()))";
+        String str3 = "()()";
+        System.out.println(new RemoveOuterMostParenteses().removeOuterParentheses2(str));
+        System.out.println(new RemoveOuterMostParenteses().removeOuterParentheses2(str2));
+        System.out.println(new RemoveOuterMostParenteses().removeOuterParentheses2(str3));
+    }
+
+    /**
+     * Method 1 ： 使用 stack 来进行操作 。
+     * ( 先判空,非空 则加入字符串中，在push;
+     * ) 先pop,再判空，非空则加入 字符串中;
+     * 时间复杂度 ： O(N)  ;    空间复杂度 ： O(N)
+     */
+    public String removeOuterParentheses(String S) {
+        final Stack<Character> stack = new Stack<>();
+        StringBuilder sb = new StringBuilder();
+        for (char c : S.toCharArray()) {
+            if (c == '(') {
+                if (!stack.empty()) sb.append(c);
+                stack.push(c);
+            } else {
+                stack.pop();
+                if (!stack.empty()) sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Method 2 :   用一个计数器 count 来保存； （ count++ ; ) count-- ;
+     *  时间复杂度 ： O(N)    ;   空间复杂度 : O(1)
+     */
+    public String removeOuterParentheses2(String S) {
+        StringBuilder sb = new StringBuilder();
+        int count = 0;
+        for (char c : S.toCharArray()) {
+            if (c == '(') {
+                count++;
+                if (count > 1) sb.append(c);
+            } else {
+                count--;
+                if (count != 0) sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+
+}

From 07338683530da8f9b18a781a64a43d16c943f204 Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Thu, 6 Jun 2019 18:50:27 +0800
Subject: [PATCH 17/22] 11 numbers

---
 Week_01/id_1/NOTE.md | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/Week_01/id_1/NOTE.md b/Week_01/id_1/NOTE.md
index f00fabbd..0a721e9a 100644
--- a/Week_01/id_1/NOTE.md
+++ b/Week_01/id_1/NOTE.md
@@ -1,12 +1,13 @@
 # 学习笔记
 
+## DAY 1：
 1.LeetCode 26 : I'm confused what is In situ sorting? Even if I looked up the answer in baike.
 
 2.LeetCode 189 :  The first idea is use two layers of circulation, the variable of first layer of circulation  is numbers of times K, next    ,the variable is  length of array;  Time complexity is O(k*n),space complexity is O(1);To be exact, time complexity is O(n* k%=n) ;
    Code review by refer to others , three of inversion ,the code is very clean , what's more the time complexity  is getting      shorter,O(n),exactly , O(2n).
 
 3.LeetCode 21: I can understand the way of solving problem, but don't understand why use a temporiry variable to next pointer? 
-
+## DAY 2:
 4.LeetCode 88 : At first, i can think of two ways to do it. 
       One: Add the second array directly to the first array, and then sort it; (time complexity is O(n+nlogn) , space complexity is O(1) )
       Two:  Before and after thoughts, compare the size of the preceding element int two arrays, the smaller element plus(+1)
@@ -17,3 +18,9 @@
 6.LeetCode 242： Four solutions came to mind. Simple but fun.
    
 7.LeetCode 49: First thought use Map to solve this problem. Three answers came up.
+
+## DAY 3 :
+8. LeetCode 1: 
+9. LeetCode 15:
+10. LeetCode 1021:
+11. LeetCode 1047:

From ae7cee6f23e3cb349cf28a16d46d77c254af2c01 Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Sun, 9 Jun 2019 18:50:57 +0800
Subject: [PATCH 18/22] Four ways of thinking by study algorithm

---
 ...5\255\246\344\271\240\346\200\273\347\273\223.md" | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 "Week_01/id_1/\345\255\246\344\271\240\346\200\273\347\273\223.md"

diff --git "a/Week_01/id_1/\345\255\246\344\271\240\346\200\273\347\273\223.md" "b/Week_01/id_1/\345\255\246\344\271\240\346\200\273\347\273\223.md"
new file mode 100644
index 00000000..be1093f5
--- /dev/null
+++ "b/Week_01/id_1/\345\255\246\344\271\240\346\200\273\347\273\223.md"
@@ -0,0 +1,12 @@
+一周自己的刷题，挺有意思，开始做点觉得有意义的事情。
+虽然刷题有时候比较枯燥，但当自己仔细思考题目与解法的时候，有在努力的做这一件事情，一开始都是脑海里闪出的第一想法，比如说暴力法。
+有第一种方法出现的时候，再思考第二种与第三种。
+每次提交代码时，都会非常的注意到执行完成的时间与使用的内存，再看看自己战胜了多少人。
+我给自己自己定的目标是，超过 80% 的提交者，这样的话我觉得这个代码算是比较好的。
+如果是只有超过 30% 及以下的提交者，那我会觉得这个代码会很low，往往是暴力法来解决的问题，会尝试着寻找新的满意的答案。
+当发现自己有时焦头烂额想不到好的办法的时候，阅读一下别人写的好的代码，那样的感觉 so cool. 
+代码简洁而优雅，像是欣赏一位美丽优雅的女子一样，自己表现的专注而有神。
+
+在学习数据结构与算法的过程当中，我觉得最重要的事情是 开拓了自己的思维。
+以前自己想问题都是从前往后的线性结构，通过学习算法之后，学到了另外三种思维的方式。
+1、从后往前；2、从中间向两端延伸；3、从两端向中间夹。

From afe1a0ee6cd79531ffe7e08537114b5dd4a71707 Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Sun, 9 Jun 2019 18:51:58 +0800
Subject: [PATCH 19/22] Create LeetCode_441_1.java

---
 Week_01/id_1/LeetCode_441_1.java | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 Week_01/id_1/LeetCode_441_1.java

diff --git a/Week_01/id_1/LeetCode_441_1.java b/Week_01/id_1/LeetCode_441_1.java
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/Week_01/id_1/LeetCode_441_1.java
@@ -0,0 +1 @@
+

From bd94ff375d8c7201c60c615f9d10c3426e0406c1 Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Sun, 9 Jun 2019 18:53:00 +0800
Subject: [PATCH 20/22] Mathematical thinking solution

---
 Week_01/id_1/LeetCode_441_1.java | 51 ++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/Week_01/id_1/LeetCode_441_1.java b/Week_01/id_1/LeetCode_441_1.java
index 8b137891..617e673d 100644
--- a/Week_01/id_1/LeetCode_441_1.java
+++ b/Week_01/id_1/LeetCode_441_1.java
@@ -1 +1,52 @@
 
+package week01;
+
+/**
+ *  LeetCode : 441. 排列硬币    https://leetcode-cn.com/problems/arranging-coins/
+ */
+
+public class ArrangingCoins {
+
+    public static void main(String[] args) {
+        System.out.println(new ArrangingCoins().arrangeCoins2(5));
+        System.out.println(new ArrangingCoins().arrangeCoins2(8));
+        System.out.println(new ArrangingCoins().arrangeCoins2(10));
+        System.out.println(new ArrangingCoins().arrangeCoins2(14));
+        System.out.println(new ArrangingCoins().arrangeCoins2(16));
+    }
+
+    /**
+     *
+     * Method 1 :  循环递减 count ;
+     *  时间复杂度 ： O(logN) ;   空间复杂度 ： O(1)    ;
+     */
+    public int arrangeCoins(int n) {
+        if(n==0){
+            return 0;
+        }
+        int count=1;
+        while(n>0){
+            n-=count;
+            if(n>count){
+                count++;
+            }
+        }
+        return count;
+    }
+
+    /**
+     *
+     * Method 2 : 纯数学题解法 ； 推导递推公式
+     */
+    public int arrangeCoins2(int n){
+        return (int)(Math.sqrt(2*(long)n+0.25)-0.5);
+    }
+    /**
+     *
+     * Method 3 : 纯数学题解法 ； 演变形式 ——> 推导递推公式
+     */
+
+    public int arrangeCoins3(int n){
+        return (int)((Math.sqrt(8*n+1)-1)/2);
+    }
+}

From b58a0f12dd21343ae734c940372680c80e356275 Mon Sep 17 00:00:00 2001
From: AALuoXiang <1533047354@qq.com>
Date: Sun, 9 Jun 2019 18:54:56 +0800
Subject: [PATCH 21/22] dichotomy

---
 Week_01/id_1/LeetCode_50_1.java | 87 +++++++++++++++++++++++++++++++++
 1 file changed, 87 insertions(+)
 create mode 100644 Week_01/id_1/LeetCode_50_1.java

diff --git a/Week_01/id_1/LeetCode_50_1.java b/Week_01/id_1/LeetCode_50_1.java
new file mode 100644
index 00000000..17e824cb
--- /dev/null
+++ b/Week_01/id_1/LeetCode_50_1.java
@@ -0,0 +1,87 @@
+package week01;
+
+/**
+ * LeetCode : 50. Pow(x, n)    https://leetcode-cn.com/problems/powx-n/
+ */
+public class PowXN {
+    public static void main(String[] args) {
+        int i=1;
+        System.out.println(i/2);
+        System.out.println(new PowXN().myPow(2, 10));
+        System.out.println(new PowXN().myPow(2.1, 3));
+        System.out.println(new PowXN().myPow(2.0, -2));
+        System.out.println("-------------");
+        System.out.println(new PowXN().myPow3(2, 5));
+        System.out.println(new PowXN().myPow3(2, 10));
+        System.out.println(new PowXN().myPow3(2.1, 3));
+        System.out.println(new PowXN().myPow3(2.0, -2));
+    }
+
+    /**
+     * Method 1 : 暴力破解法
+     * 时间复杂度： O(N)  ;   空间复杂度：  O(1)
+     */
+    public double myPow(double x, int n) {
+        long newN = n;
+        if (newN < 0) {
+            x = 1 / x;
+            newN = -newN;
+        }
+        double sum = 1;
+        for (int i = 0; i < newN; i++) {
+            sum *= x;
+        }
+        return sum;
+    }
+
+    /**
+     * Method 2 :   递归 二分法
+     *  时间复杂度:  O(logN) ;   空间复杂度：  O(logN)
+     */
+    public double myPow2(double x, int n) {
+        long newN = n;
+        if (newN < 0) {
+            x = 1 / x;
+            newN = -newN;
+        }
+        return fastPow(x, newN);
+
+    }
+
+    private double fastPow(double x, long newN) {
+        // 终止条件
+        if (newN == 0) {
+            return 1.0;
+        }
+        // 要做的事情
+        double fastPow = fastPow(x, newN / 2);
+        if (newN % 2 == 0) {
+            return fastPow * fastPow;
+        }
+        return fastPow * fastPow * x;
+        // 下一层
+    }
+
+    /**
+     *  Method 3 :  偶数时 进行 幂乘；奇数 之前的结果集 * 当前自己；
+     *  时间复杂度： O(logN)  ;   空间复杂度：  O(1)    ;
+     */
+    public double myPow3(double x, int n) {
+        long N = n;
+        if (N < 0) {
+            x = 1 / x;
+            N = -N;
+        }
+        double result=1;
+        double cur=x;
+        for(long i=N;i>0;i/=2){
+            if(i%2==1){
+                result*=cur;
+            }
+            cur*=cur;
+        }
+        return result;
+    }
+
+
+}

From f7389396cde1d61b6bd2163b6340f55c19947370 Mon Sep 17 00:00:00 2001
From: AALuoXiang <aaluoxiang@163.com>
Date: Sun, 9 Jun 2019 18:57:19 +0800
Subject: [PATCH 22/22] mind map

---
 ...227\346\263\225\347\220\206\350\247\243.pdf" | Bin 0 -> 26486 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "Week_01/id_1/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225\347\220\206\350\247\243.pdf"

diff --git "a/Week_01/id_1/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225\347\220\206\350\247\243.pdf" "b/Week_01/id_1/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225\347\220\206\350\247\243.pdf"
new file mode 100644
index 0000000000000000000000000000000000000000..485bd902ec87c1fa3779d931186d860c0cc8b098
GIT binary patch
literal 26486
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
bM%)fAu25&!zitM^b_av8n3$xLrLq1CcODqq

literal 0
HcmV?d00001