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();
+    }
+
+}
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);
+    }
+
+
+}
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;
+    }
+
+}
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--;
+        }
+    }
+
+}
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];
+    }
+
+    }
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;
+    }
+
+}
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;
+    }
+
+
+
+    }
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;
+    }
+}
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;
+    }
+}
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..617e673d
--- /dev/null
+++ b/Week_01/id_1/LeetCode_441_1.java
@@ -0,0 +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);
+    }
+}
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());
+    }
+
+}
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;
+    }
+
+
+}
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);
+        }
+    }
+
+
+}
diff --git a/Week_01/id_1/NOTE.md b/Week_01/id_1/NOTE.md
index 107ea7d6..0a721e9a 100644
--- a/Week_01/id_1/NOTE.md
+++ b/Week_01/id_1/NOTE.md
@@ -1 +1,26 @@
 # 学习笔记
+
+## 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)
+      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.
+   
+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:
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、从两端向中间夹。
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 00000000..485bd902
Binary files /dev/null and "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" differ