Merge pull request #1 from momo1314/master

update

Author: momo1314

.gitignore

@@ -0,0 +1,36 @@
+# Created by .ignore support plugin (hsz.mobi)
+### Example user template template
+### Example user template
+
+# IntelliJ project files
+.idea
+*.iml
+out
+gen
+### Java template
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+.gitignore
+.idea/

DP/edit-distance-72.java

@@ -0,0 +1,32 @@
+//建立数组dp[][]来存储 以word1[i]为结尾的字符串 转换成 以word2[j]为结尾的字符串 所需的最小操作数
+    //当新遍历一对来自word1，word2的字符
+    //若 word1[i] == word2[j] 表示不需要操作，则dp[i][j]=dp[i-1][j-1]
+    //若 word1[i] != word2[j] 则可以有三种情况
+    //   1、替换 word1[i] 把 word1[i] 替换成 word2[j] 需要 dp[i-1][j-1]+1步
+    //   2、删除 word1[i] 把 word1[i] 删除成 word1[i-1] 需要 dp[i][j-1]+1步
+    //   3、删除 word2[j] 把 word2[j] 删除成 word2[j-1] 需要 dp[i-1][j]+1步(增加word1和删除word2一个效果)
+    // 取这三个中最小值 
+class Solution {
+    public int minDistance(String word1, String word2) {
+        int len1 = word1.length();
+        int len2 = word2.length();
+        int[][] dp  = new int[len1+1][len2+1];
+
+        for(int i = 1 ; i <= len1 ; i++) {
+            dp[i][0] = i;
+        }
+        for(int i = 1 ; i <= len2 ;i++) {
+            dp[0][i] = i;
+        }
+        for(int i = 1 ; i <= len1 ; i++) {
+            for(int j = 1; j <= len2 ; j++) {
+                if(word1.charAt(i-1) == word2.charAt(j-1)) {
+                    dp[i][j] = dp[i-1][j-1];
+                } else {
+                    dp[i][j] = Math.min(dp[i-1][j-1] , Math.min(dp[i-1][j],dp[i][j-1])) + 1;
+                }
+            }
+        }
+        return dp[len1][len2];
+    }
+}

magical&Double pointer/find-all-anagrams-in-a-string-438.java

@@ -0,0 +1,41 @@
+/**
+ * 滑动窗口解法，双指针
+ */
+class Solution {
+    public List<Integer> findAnagrams(String s, String p) {
+        if(s == null || s.length() == 0) return new ArrayList<>();
+        List<Integer> res = new ArrayList<>();
+        int[] needs = new int[26];
+        int[] windows = new int[26];
+        int left = 0 , right = 0 , total = p.length();
+
+        for(char a : p.toCharArray()) {
+            needs[a - 'a']++;
+        }
+
+        while(right < s.length()) {
+            char now = s.charAt(right);
+            if(needs[now - 'a'] > 0) {
+                windows[now - 'a']++;
+                if(windows[now - 'a'] <= needs[now - 'a']) {
+                    total -= 1;
+                }
+            }
+            while(total == 0) {
+                if(right-left+1 == p.length()){
+                    res.add(left);
+                }
+                char c = s.charAt(left);
+                if(needs[c - 'a'] > 0) {
+                    windows[c - 'a']--;
+                    if(windows[c - 'a'] < needs[c - 'a']) {
+                        total++;
+                    }
+                }
+                left++;
+            }
+            right++;
+        }
+        return res;
+    }
+}

stack/basic-calculator-ii-227.java

@@ -0,0 +1,32 @@
+/**
+ * 简单计算器2 简单用栈实现，未使用后缀表达式。
+ */
+class Solution {
+    public int calculate(String s) {
+        Stack<Integer> stack = new Stack<>();
+        int num = 0 , res = 0;
+        char op = '+';
+        for(int i = 0 ; i < s.length() ; i++) {
+            if(s.charAt(i) >='0'){
+                num = num*10+(s.charAt(i)-'0');
+            }
+            if( (s.charAt(i)<'0'&& s.charAt(i)!=' ') || i==s.length()-1) {
+                if(op=='+') stack.push(num);
+                if(op=='-') stack.push(-num);
+                if(op=='*'||op=='/'){
+                    int temp = (op=='*')? stack.peek()*num:stack.peek()/num;
+                    stack.pop();
+                    stack.push(temp);
+                }
+                op=s.charAt(i);
+                num=0;
+            }
+
+        }
+        while(!stack.isEmpty()) {
+            res += stack.peek();
+            stack.pop();
+        }
+        return res;
+    }
+}

stack/mini-parser-385.java

@@ -0,0 +1,62 @@
+/**
+ * 简单入栈出栈操作
+ * // This is the interface that allows for creating nested lists.
+ * // You should not implement it, or speculate about its implementation
+ * public interface NestedInteger {
+ *     // Constructor initializes an empty nested list.
+ *     public NestedInteger();
+ *
+ *     // Constructor initializes a single integer.
+ *     public NestedInteger(int value);
+ *
+ *     // @return true if this NestedInteger holds a single integer, rather than a nested list.
+ *     public boolean isInteger();
+ *
+ *     // @return the single integer that this NestedInteger holds, if it holds a single integer
+ *     // Return null if this NestedInteger holds a nested list
+ *     public Integer getInteger();
+ *
+ *     // Set this NestedInteger to hold a single integer.
+ *     public void setInteger(int value);
+ *
+ *     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
+ *     public void add(NestedInteger ni);
+ *
+ *     // @return the nested list that this NestedInteger holds, if it holds a nested list
+ *     // Return null if this NestedInteger holds a single integer
+ *     public List<NestedInteger> getList();
+ * }
+ */
+class Solution {
+    public NestedInteger deserialize(String s) {
+        if(s.charAt(0) != '[') return new NestedInteger(Integer.valueOf(s));
+        Stack<NestedInteger> stack = new Stack<>();
+        NestedInteger result = new NestedInteger();
+        for(int i = 0 ; i < s.length() ; i ++){
+            char c = s.charAt(i);
+            if(c == '[') {
+                NestedInteger node = new NestedInteger();
+                if(!stack.isEmpty()) {
+                    stack.peek().add(node);
+                }
+                stack.push(node);
+            }
+            if(c >= '0' && c <= '9' || c == '-') {
+                String num = c+"";
+                while(i+1 < s.length() && s.charAt(i+1) >= '0' && s.charAt(i+1)<='9') {
+                    num = num+s.charAt(++i);
+                }
+                NestedInteger node = new NestedInteger(Integer.valueOf(num));
+                if(stack.isEmpty()) {
+                    stack.push(node);
+                } else {
+                    stack.peek().add(node);
+                }
+            }
+            if(c == ']') {
+                result = stack.pop();
+            }
+        }
+        return result;
+    }
+}