第一周作业#01

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();
+    }
+
+}

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);
+    }
+
+
+}

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;
+    }
+
+}

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--;
+        }
+    }
+
+}

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];
+    }
+
+    }