refactor 3

Author: fishercoder1534

README.md

@@ -600,7 +600,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |6|[ZigZag Conversion](https://leetcode.com/problems/zigzag-conversion/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_6.java) | O(n) | O(n) | Easy | 
 |5|[Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_5.java) | O(n^2) | O(1) | Medium|
 |4|[Median of Two Sorted Arrays](https://leetcode.com/problems/median-of-two-sorted-arrays/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_4.java) | ? | ? | Hard | Divide and Conquer
-|3|[Longest Substring Without Repeating Characters](https://leetcode.com/problems/longest-substring-without-repeating-characters/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_3.java) | O(n) | O(1) | Medium | HashMap, Sliding Window
+|3|[Longest Substring Without Repeating Characters](https://leetcode.com/problems/longest-substring-without-repeating-characters/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_3.java) | O(n) | O(k) | Medium | HashMap, Sliding Window
 |2|[Add Two Numbers](https://leetcode.com/problems/add-two-numbers/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_2.java) | O(max(m,n)) | O(1) | Medium | LinkedList
 |1|[Two Sum](https://leetcode.com/problems/two-sum/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1.java)| O(n)| O(n) | Easy| HashMap
 

src/main/java/com/fishercoder/solutions/_3.java

@@ -1,38 +1,111 @@
 package com.fishercoder.solutions;
 
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 
-/**Given a string, find the length of the longest substring without repeating characters.
+/**
+ * 3. Longest Substring Without Repeating Characters
+ * Given a string, find the length of the longest substring without repeating characters.
 
  Examples:
 
  Given "abcabcbb", the answer is "abc", which the length is 3.
 
  Given "bbbbb", the answer is "b", with the length of 1.
 
- Given "pwwkew", the answer is "wke", with the length of 3. Note that the answer must be a substring, "pwke" is a subsequence and not a substring.*/
+ Given "pwwkew", the answer is "wke", with the length of 3.
+
+ Note that the answer must be a substring, "pwke" is a subsequence and not a substring.
+ */
+
 public class _3 {
 
-    public static int lengthOfLongestSubstring(String s) {
-        int result = 0;
-        Map<Character, Integer> map = new HashMap();
-        for (int i = 0, j = i; j < s.length(); ){
-            if (!map.containsKey(s.charAt(j)) || (map.containsKey(s.charAt(j)) && map.get(s.charAt(j)) == 0)){
-                map.put(s.charAt(j), 1);
-                result = Math.max(j-i+1, result);
-                j++;
-            } else {
-                map.put(s.charAt(i), map.get(s.charAt(i)) - 1);
-                i++;
+    public static class Solution1 {
+        public int lengthOfLongestSubstring(String s) {
+            int result = 0;
+            Map<Character, Integer> map = new HashMap();
+            for (int i = 0, j = i; j < s.length(); ) {
+                if (!map.containsKey(s.charAt(j)) || (map.containsKey(s.charAt(j)) && map.get(s.charAt(j)) == 0)) {
+                    map.put(s.charAt(j), 1);
+                    result = Math.max(j - i + 1, result);
+                    j++;
+                } else {
+                    map.put(s.charAt(i), map.get(s.charAt(i)) - 1);
+                    i++;
+                }
+            }
+            return result;
+        }
+    }
+
+    public static class Solution2 {
+        /**
+         * Sliding Window
+         * O(n) time
+         * O(min(m,n)) or O(k) space
+         */
+        public int lengthOfLongestSubstring(String s) {
+            int n = s.length();
+            Set<Character> set = new HashSet<>();
+            int result = 0;
+            int i = 0;
+            int j = 0;
+            while (i < n && j < n) {
+                /**Try to extend the range i, j*/
+                if (!set.contains(s.charAt(j))) {
+                    set.add(s.charAt(j++));
+                    result = Math.max(result, j - i);
+                } else {
+                    set.remove(s.charAt(i++));
+                }
+            }
+            return result;
+        }
+    }
+
+    public static class Solution3 {
+        /**Sliding Window
+         * O(n) time
+         * O(n) space
+         */
+        public int lengthOfLongestSubstring(String s) {
+            if (s.length() == 0) {
+                return 0;
+            }
+            int max = 0;
+            Map<Character, Integer> map = new HashMap<>();
+            /**Try to extend the range (i, j)*/
+            for (int i = 0, j = 0; i < s.length(); i++) {
+                if (map.containsKey(s.charAt(i))) {
+                    j = Math.max(j, map.get(s.charAt(i)) + 1);
+                }
+                map.put(s.charAt(i), i);
+                max = Math.max(max, i + 1 - j);
             }
+            return max;
         }
-        return result;
     }
 
-    public static void main(String...args){
-//        String s = "abcabcbb";
-        String s = "pwwkew";
-        System.out.println(lengthOfLongestSubstring(s));
+    public static class Solution4 {
+        /**Sliding Window Optimized
+         * O(n) time
+         * O(n) space
+         */
+        public int lengthOfLongestSubstring(String s) {
+            if (s.length() == 0) {
+                return 0;
+            }
+            int max = 0;
+            int[] index = new int[128];
+            /**Try to extend the range (i, j)*/
+            for (int i = 0, j = 0; j < s.length(); j++) {
+                i = Math.max(index[s.charAt(j)], i);
+                max = Math.max(max, j -i + 1);
+                index[s.charAt(j)] = j+1;
+            }
+            return max;
+        }
     }
 }