push all leetcode source to github

Author: zhangyu345293721

leetcode.iml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$/../leetcode">
+      <sourceFolder url="file://$MODULE_DIR$/../leetcode/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module-library">
+      <library name="JUnit4">
+        <CLASSES>
+          <root url="jar://$APPLICATION_HOME_DIR$/lib/junit-4.12.jar!/" />
+          <root url="jar://$APPLICATION_HOME_DIR$/lib/hamcrest-core-1.3.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+  </component>
+</module>

out/production/leetcode/BestTimetoBuyandSellStock.class

@@ -0,0 +1,37 @@
+import org.junit.Test;
+
+/**
+ * @author zhangyu
+ * @version V1.0
+ * @ClassName: BestTimetoBuyandSellStock
+ * @Description: TOTO
+ * @date 2018/12/6 15:28
+ **/
+/*
+   做这种题目时候，要先进行判断，然后再动手写算法，防止边界问题的出现
+ */
+
+public class BestTimetoBuyandSellStock {
+    @Test
+    public void fun() {
+        int[] nums = {7, 1, 5, 3, 6, 4};
+        int maxProfit = maxProfit(nums);
+        System.out.println(maxProfit);
+    }
+
+    private int maxProfit(int[] prices) {
+        if (prices.length < 1) {
+            return 0;
+        }
+        int maxProfit = 0;
+        for (int i = 0; i < prices.length - 1; i++) {
+            for (int j = i + 1; j < prices.length; j++) {
+                int profit = prices[j] - prices[i];
+                if (maxProfit < profit) {
+                    maxProfit = profit;
+                }
+            }
+        }
+        return maxProfit;
+    }
+}

out/production/leetcode/BestTimetoBuyandSellStock2.class

@@ -0,0 +1,44 @@
+import org.junit.Test;
+
+/**
+ * @author zhangyu
+ * @version V1.0
+ * @ClassName: BestTimetoBuyandSellStock
+ * @Description: TOTO
+ * @date 2018/12/6 15:28
+ **/
+
+
+public class BestTimetoBuyandSellStock2 {
+    @Test
+    public void fun() {
+        int[] nums = {7, 1, 5, 3, 6, 4};
+        int maxProfit = maxProfit(nums);
+        System.out.println(maxProfit);
+    }
+
+    // 找出最大的profit
+    private int maxProfit(int[] prices) {
+        // 如果数组的长度为0就直接返回
+        if (prices.length == 0) {
+            return 0;
+        }
+
+        // 定义一个非变量,数组的下标
+        final int pricesIndex = prices.length - 1;
+        // 记录一个标记位，把最后一个数设置为最大值
+        int maxPrice = prices[pricesIndex];
+        // 把最大收益设置为0
+        int maxProfit = 0;
+        for (int i = pricesIndex - 1; i >= 0; i--) {
+            if (prices[i] > maxPrice) {
+                // 更新maxPrice的值，把它更新
+                maxPrice = prices[i];
+            }
+            // 更新最大收益值
+            maxProfit = Math.max(maxProfit, maxPrice - prices[i]);
+           // maxProfit=maxProfit>(maxPrice-prices[i])?maxProfit:(maxPrice-prices[i]);
+        }
+        return maxProfit;
+    }
+}

out/production/leetcode/GenerateParentheses1.class

@@ -0,0 +1,42 @@
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author zhangyu
+ * @version V1.0
+ * @ClassName: GenerateParentheses1
+ * @Description: TOTO
+ * @date 2018/12/15 14:31
+ **/
+
+
+public class GenerateParentheses1 {
+    @Test
+    public void fun() {
+        int n = 3;
+        List<String> list = generateParentheses(n);
+        System.out.println(list);
+    }
+
+    private List<String> generateParentheses(int n) {
+        List<String> list = new ArrayList<>();
+        if (n < 1) {
+            return null;
+        }
+        bracketTrace(list, "", 0, 0, n);
+        return list;
+    }
+
+    private void bracketTrace(List<String> list, String s, int left, int right, int n) {
+        if (s.length() == n * 2) {
+            list.add(s);
+            return;
+        }
+        if (left < n)
+            bracketTrace(list, s + "(", left + 1, right, n);
+        if (right < left)
+            bracketTrace(list, s + ")", left, right + 1, n);
+    }
+}

out/production/leetcode/LongestValidParentheses.class

@@ -0,0 +1,45 @@
+import org.junit.Test;
+
+import java.util.Stack;
+
+/**
+ * @author zhangyu
+ * @version V1.0
+ * @ClassName: LongestValidParentheses
+ * @Description: TOTO
+ * @date 2018/12/17 19:29
+ **/
+
+
+public class LongestValidParentheses {
+    @Test
+    public void fun() {
+        String s = ")()())";
+        int length = longestValidParentheses(s);
+        System.out.println(length);
+    }
+
+    private int longestValidParentheses(String s) {
+        Stack<Character> stack = new Stack<>();
+        int count = 0;
+        int max = 0;
+        char chs[] = s.toCharArray();
+        for (int i = 0; i < s.length(); i++) {
+            stack.push(chs[i]);
+            if (!stack.isEmpty()) {
+                char c = stack.peek();
+                if (c == '(') {
+                    stack.pop();
+                    count++;
+                }
+            }
+            if (stack.isEmpty()) {
+                if (max < count) {
+                    max = count;
+                }
+                count = 0;
+            }
+        }
+        return max * 2;
+    }
+}

out/production/leetcode/WordBreak.class

@@ -0,0 +1,54 @@
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author zhangyu
+ * @version V1.0
+ * @ClassName: WrodBreak
+ * @Description: TOTO
+ * @date 2018/12/13 13:53
+ **/
+
+
+public class WordBreak {
+    @Test
+    public void fun() {
+        String s = "applepenapple";
+        List<String> wordDict = new ArrayList<>();
+        wordDict.add("apple");
+        wordDict.add("pen");
+        boolean flag = wordBreak2(s, wordDict);
+        System.out.println(flag);
+    }
+
+    // 这个有问题
+    /*private boolean wordBreak(String s, List<String> wordDict) {
+        for (String word : wordDict) {
+            if (s.contains(word)) {
+                // int index = s.indexOf(word);
+                //  s = s.substring(index, index + word.length());
+                s = s.replaceFirst(word, "");
+            }
+        }
+        if (s.equals("") || wordDict.contains(s)) {
+            return true;
+        }
+        return false;
+    }*/
+
+    private boolean wordBreak2(String s, List<String> wordDict) {
+        boolean[] f = new boolean[s.length() + 1];
+        f[0] = true;
+        for (int i = 1; i <= s.length(); i++) {
+            for (int j = 0; j < i; j++) {
+                if (f[j] && wordDict.contains(s.substring(j, i))) {
+                    f[i] = true;
+                    break;
+                }
+            }
+        }
+        return f[s.length()];
+    }
+}

out/production/leetcode/leetcode/ArrayTest.class

@@ -0,0 +1,30 @@
+package leetcode;
+
+import org.junit.Test;
+
+/**
+ * @author zhangyu
+ * @version V1.0
+ * @ClassName: ArrayTest
+ * @Description: TOTO
+ * @date 2018/12/17 21:28
+ **/
+
+
+public class ArrayTest {
+    @Test
+    public void fun() {
+        int sum1 = getSum(1, 2, 3, 4);
+        int sum2 = getSum(1, 2, 3);
+        System.out.println(sum1);
+        System.out.println(sum2);
+    }
+
+    private int getSum(int... arr) {
+        int sum = 0;
+        for (int num : arr) {
+            sum += num;
+        }
+        return sum;
+    }
+}

out/production/leetcode/leetcode/ArraysSortTest.class

@@ -0,0 +1,39 @@
+package leetcode;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * @author zhangyu
+ * @version V1.0
+ * @ClassName: ArraysSortTest
+ * @Description: 测试Arrays.sort的逆序排序
+ * @date 2018/12/10 14:06
+ **/
+
+// Arrays.sort()可以使用内部的比较器进行比较，也可以自己定义比较器进行逆序排序
+public class ArraysSortTest {
+    @Test
+    public void fun() {
+        Integer[] nums = {5, 2, 1, 3, 4, 9, 0, 7, 8, 6};
+        Comparator<Integer> comparator = new MyComparator();
+        Arrays.sort(nums, comparator);
+        System.out.println(Arrays.toString(nums));
+    }
+}
+
+class MyComparator implements Comparator<Integer> {
+    @Override
+    public int compare(Integer a, Integer b) {
+        if (a > b) {
+            return -1;
+        } else if (a == b) {
+            return 0;
+        } else {
+            return 1;
+        }
+    }
+
+}

out/production/leetcode/leetcode/ArraysSortTest2$1.class

@@ -0,0 +1,37 @@
+package leetcode;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * @author zhangyu
+ * @version V1.0
+ * @ClassName: ArraysSortTest
+ * @Description: 测试Arrays.sort的逆序排序
+ * @date 2018/12/10 14:06
+ **/
+
+// Arrays.sort()可以使用内部的比较器进行比较，也可以自己定义比较器进行逆序排序
+public class ArraysSortTest2 {
+    @Test
+    public void fun() {
+        Integer[] nums = {5, 2, 1, 3, 4, 9, 0, 7, 8, 6};
+        // Comparator<Integer> comparator = new MyComparator();
+        Arrays.sort(nums, new Comparator<Integer>() {
+            @Override
+            public int compare(Integer a, Integer b) {
+                if (a > b) {
+                    return -1;
+                } else if (a == b) {
+                    return 0;
+                } else {
+                    return 1;
+                }
+            }
+        });
+        System.out.println(Arrays.toString(nums));
+    }
+}
+

out/production/leetcode/leetcode/ArraysSortTest2.class

@@ -0,0 +1,30 @@
+package leetcode;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * @author zhangyu
+ * @version V1.0
+ * @ClassName: ArraysSortTest
+ * @Description: 测试Arrays.sort的逆序排序
+ * @date 2018/12/10 14:06
+ **/
+
+// Arrays.sort()可以使用内部的比较器进行比较，也可以自己定义比较器进行逆序排序
+public class ArraysSortTest3 {
+    @Test
+    public void fun() {
+        Integer[] nums = {5, 2, 1, 3, 4, 9, 0, 7, 8, 6};
+        Arrays.sort(nums, new Comparator<Integer>() {
+            @Override
+            public int compare(Integer a, Integer b) {
+                return b - a;
+            }
+        });
+        System.out.println(Arrays.toString(nums));
+    }
+}
+