LeetCode: Tags-[Hash Table]

Tags: Hash Table

3. Longest Substring Without Repeating Characters：https://leetcode.com/problems/longest-substring-without-repeating-characters/

没有重复字符的最长子字符串：<Hash Table><Two Pointers>

解法: (使用HashMap保存字符key为字符, value为位置, 并且保持更新; 因为遇到重复字符后, 前面的最大长度就已经保存到max中了, 所以可以更换字符的的位置了; 利用两个指针i和j, i用于遍历, j指向不含重复字符的subString的首位, 当i遍历到重复字符containsKey时, 就比较map里的重复字符的后一位与当前j位置, 取最大值作为j的位置; max记录最大长度, 比较max和(i-j+1);  )

(示例：adbccba 首先i和j都指向a, 然后i遍历到c时,此时max=4, map里有四个键值对(i=3,j=0); 然后i指向第2个c, 已经contain了, 所以j的位置指向重复元素的后一位, 即相当于新subString的第一位(i=4,j=4); i=5,比较j的位置和b后的位置,保留j;比较max与i-j+1; put覆盖重复字符;)

(1.map,max;  2.for(i,j,s.length());   3.if(csKey(s.charAt(i))) j=max(j,get(s.cAt())+1);  4.put(At,i),max=(max,i-j+1);  5.return max;)

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        HashMap<Character, Integer> map = new HashMap<>();
        int max = 0;
        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 - j + 1);
        }
        return max;
    }
}

49. Group Anagrams: https://leetcode.com/problems/anagrams/

含有相同字母的字符串分为一组：<HashMap>

解法：(HashMap<String,List<String>>, 遍历数组str, 将字符串转为字符数组,  排序字符数组, 获取字符数组的值keyStr; 如果不含keyStr, 那么put; add对应字符串str)

(用到的method: 1.containsKey();  2.str.toCharArray()--将字符串转为字符数组;  3.String.valueOf(ch)--将字符数组转为字符串;  4.map.values()--获取所有map值)

(1.if;  2.<Str, List<Str>>map;  3.for(str)char[] ch, sort, keyStr, if(!csKey)put, get.add;  4.return new A<<>>(values());)

public class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        if (strs == null || strs.length == 0) return new ArrayList<List<String>>();
        Map<String, List<String>> map = new HashMap<>();
        for (String str : strs) {
            char[] ch = str.toCharArray();
            Arrays.sort(ch);
            String keyStr = String.valueOf(ch);
            if (!map.containsKey(keyStr)) map.put(keyStr, new ArrayList<String>());
            map.get(keyStr).add(str);
        }
        return new ArrayList<List<String>>(map.values());
    }
}

94. Binary Tree Inorder Traversal: https://leetcode.com/problems/binary-tree-inorder-traversal/

二叉树的中序遍历： (todo)

136. Single Number: https://leetcode.com/problems/single-number/

数组中只有一个数出现一次, 其他都出现两次, 获取Single Number: 

我的解法：(HashMap, !containsKey时,put<nums[i],1>; 否则remove; 所以遍历后map里只剩下一个对<tar, 1>; 利用遍历keySet(), rst=num;  return rst)

public class Solution {
    public int singleNumber(int[] nums) {
        HashMap<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (!map.containsKey(nums[i])) map.put(nums[i],1);
            else map.remove(nums[i]);
        }
        int rst = 0;
        for (int num : map.keySet()) {
            rst = num;
        }
        return rst;
    }
}

解法2：<Bit>(XOR--异或,符号是^;1. 0 XOR A = A;  2. A XOR A = 0;  3.XOR可以交换; )(discuss里都是bit解法的……不知道题目还用hashmap标签干啥- -!!)

(1.rst;  2.for()rst^=[i];  3.return)

public class Solution {
    public int singleNumber(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int rst = 0;
        for (int i = 0; i < nums.length; i++) {
            rst ^= nums[i];
        }
        return rst;
    }
}

解法3：<HashSet>(利用set的不可重复, !add则remove; 最后set里只剩下target; 用set方法iterator的属性next()获取set的值;)

public int singleNumber(int[] A) {
        
       Set<Integer> s = new HashSet<Integer>();
        for (int i: A){
            if(!s.add(i)){
                s.remove(i);
            }
        }
        return s.iterator().next();
        
    }

202. Happy Number：https://leetcode.com/problems/happy-number/

各个数平方和相加最终结果为1的数：

我的解法：(虽然AC了速度还挺快,但是无限循环部分有问题,用了20次循环作为最大值; i%10--一个数的个位; i=i/10来递归扫描)

public class Solution {
    public boolean isHappy(int n) {
        if (n == 0) return false;
        int rst = helper(n);
        for (int i = 0; i <= 20; i++) {
            rst = helper(rst);
            if (rst == 1) return true;
        }
        return false;
    }
    public int helper(int n) {
        int rst = 0;
        while (n != 0) {
            rst += (n % 10) * (n % 10);
            n /= 10;
        }
        return rst;
    }
}

解法1: <HashSet> (将每次的rst存在set里, 如果！rst=1, return true;  如果不能add了, 说明已经进入endless loop;  基于事实：no-happy number最后都会进入循环)

(1.set,rst;  2.while(add)if(=)true, helper(rst);  3.helper() rst,while(!0),rst+=^2,n/=10;)

public class Solution {
    public boolean isHappy(int n) {
        HashSet<Integer> set = new HashSet<>();
        int rst = helper(n);
        while (set.add(rst)) {
            if (rst == 1) return true;
            rst = helper(rst);
        }
        return false;
    }
    public int helper(int n) {
        int rst = 0;
        while (n != 0) {
            rst += (n % 10) * (n % 10);
            n /= 10;
        }
        return rst;
    }
}

public class Solution {
    private int getNextHappy(int n) {
        int sum = 0;
        while (n != 0) {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return sum;
    }
    
    public boolean isHappy(int n) {
        HashSet<Integer> hash = new HashSet<Integer>();
        while (n != 1) {
            if (hash.contains(n)) {
                return false;
            }
            hash.add(n);
            n = getNextHappy(n);
        }
        return true;
    }
}

public boolean isHappy(int n) {
    Set<Integer> inLoop = new HashSet<Integer>();
    int squareSum,remain;
    while (inLoop.add(n)) {
        squareSum = 0;
        while (n > 0) {
            remain = n%10;
            squareSum += remain*remain;
            n /= 10;
        }
        if (squareSum == 1)
            return true;
        else
            n = squareSum;

    }
    return false;

}

205. Isomorphic Strings: https://leetcode.com/problems/isomorphic-strings/

同构字符串：

 我的解法：<HashMap>(s记为key, t记作value; 遍历s.length(), 如果!containsKey, 那么判断是否containsValue--false, 否则put; else get(s.charAt)!=(t)那么false)(注意要不要漏了不包含key但是已经包含了value的情况；示例"abca""defg"--key同value不同; "ab""aa"--key不同但是还要判断value,如果value已经contain 那么false)

(1.map;  2.for(s.length())  3.if(!key) if(value)-false,put;  4.esle if(get !=) false;)

public class Solution {
    public boolean isIsomorphic(String s, String t) {
        HashMap<Character, Character> map = new HashMap<>();
        for (int i = 0; i <s.length(); i++) {
            if (!map.containsKey(s.charAt(i))) {
                if (map.containsValue(t.charAt(i))) return false;
                map.put(s.charAt(i), t.charAt(i));
            }
            else 
                if (map.get(s.charAt(i)) != t.charAt(i)) return false;
        }
        return true;
    }
}

242. Valid Anagram: https://leetcode.com/problems/valid-anagram/

 判断是否由相同字母组成: 

我的解法: <sort>(将字符排序, 遍历字符数组, 有不同的则false; 用到method: char[] cs = s.toCharArray();)

(1.if;  2.cs,ct,sort;  3.for()!=-false;  4.true)

public class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) return false;
        char[] cs = s.toCharArray();
        char[] ct = t.toCharArray();
        Arrays.sort(cs);
        Arrays.sort(ct);
        for (int i = 0; i < cs.length; i++)
            if (cs[i] != ct[i]) return false;
        return true;
    }
}

类似的：(用了Arrays.equals(char1,char2))

public class Solution {
public boolean isAnagram(String s, String t) 
{
    char[] sChar = s.toCharArray();
    char[] tChar = t.toCharArray();
    
    Arrays.sort(sChar);
    Arrays.sort(tChar);
    
    return Arrays.equals(sChar, tChar);   
}

解法2: (创建26的数组; 首先判断长度; s包含某个字母则对应位置s.charAt[i]-'a'增一, t包含则减一; 最后遍历数组,!0则false;)

(1.if,tmp;  2.for()[s-'a']++,[t-'a']--;  3.for()!=false;  4.true)

public class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) return false;
        int[] tmp = new int[26];
        for (int i = 0; i < s.length(); i++) {
            tmp[s.charAt(i) - 'a']++;
            tmp[t.charAt(i) - 'a']--;
        }
        for (int i = 0; i < 26; i++) {
            if (tmp[i] != 0) return false;
        }
        return true;
    }
}

290. Word Pattern：https://leetcode.com/problems/word-pattern/

字符模版和字符串的匹配：(pattern = "abba", str = "dog cat cat dog" should return true.)

我的解法: (和205解法相同, 注意判断字符串内容是否相同: str1.equals(str2), 字符串按空格分隔: str.split(" ");)

(1.s-split,map,if;  2.for(),if(!key),if(value)-false,put;  3.else if(!equals)-false;  4.true)

public class Solution {
    public boolean wordPattern(String pattern, String str) {
        String[] s = str.split(" ");
        Map<Character, String> map = new HashMap<>();
        if (pattern.length() != s.length) return false;
        for (int i = 0; i < pattern.length(); i++) {
            if (!map.containsKey(pattern.charAt(i))) {
                if (map.containsValue(s[i])) return false;
                map.put(pattern.charAt(i), s[i]);
            } else {
                if (!map.get(pattern.charAt(i)).equals(s[i])) return false;
            }
        }
        return true;
    }
}

349. Intersection of Two Arrays：https://leetcode.com/problems/intersection-of-two-arrays/

找出两个数组交叉部分(原数组含重复,结果不含重复)：

解法1：<HashSet>(第一个set保存a中的数据, 第二个set保存结果; 遍历2,如果set含num2[i]而rstSet不含,那么add; 最后遍历rstSet,把数据复制到数组中)

(1.if,set,for()add;  2.rstSet,for,if(&&)add;  3.rst-[size()],index,for(),[++];  4.return;)

public class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        if (nums1 == null || nums2 == null) return null;
        HashSet<Integer> set = new HashSet<>();
        for (int num : nums1) {
            set.add(num);
        }
        HashSet<Integer> rstSet = new HashSet<>();
        for (int num : nums2) {
            if (set.contains(num) && !rstSet.contains(num)) {
                rstSet.add(num);
            }
        }
        int[] rst = new int[rstSet.size()];
        int index = 0;
        for (Integer num : rstSet) {
            rst[index++] = num;
        }
        return rst;
    }
}

350. Intersection of Two Arrays II: https://leetcode.com/problems/intersection-of-two-arrays-ii/

找出两个数组交叉部分(原数组含重复,结果含重复)：

解法：<HashMap>(将数组1保存到map里并用value计数; 创建ArrayList, 遍历2, 如果containsKey并且value>0; 那么add, 并且value-1; 最后遍历list,复制到数组中)

(1.if,map;  2.for()if()put,else(get+1);  3.list,for(),if(&&>0)add,get-1;  4.rst,index,for(),[++];  5.return;)

public class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        if (nums1 == null || nums2 == null) return null;
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums1.length; i++) {
            if (!map.containsKey(nums1[i]))
                map.put(nums1[i], 1);
            else 
                map.replace(nums1[i], map.get(nums1[i]) + 1);
        }
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < nums2.length; i++) {
            if (map.containsKey(nums2[i]) && map.get(nums2[i]) > 0){
                list.add(nums2[i]);
                map.replace(nums2[i], map.get(nums2[i]) - 1);
            }
        }
        int[] rst = new int[list.size()];
        int index = 0;
        for (Integer num : list) {
            rst[index++] = num;
        }
        return rst;
    }
}

389. Find the Difference: https://leetcode.com/problems/find-the-difference/

找出字符串二比字符串一多的一个字符(含重复)：

我的解法: <HashMap>(字符串1保存到map里并用value计数; 遍历2: 如果不含key或者含key但是value<=0, 那么就是tar; 否则value-1)

(1.map,for(),if(!)put,else-replace;  2.rst,for(),if(!||(contains&&<=0))rst, else-replace(-1);  3.return)

public class Solution {
    public char findTheDifference(String s, String t) {
        Map<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            if (!map.containsKey(s.charAt(i)))
                map.put(s.charAt(i), 1);
            else
                map.replace(s.charAt(i), map.get(s.charAt(i)) + 1);
        }
        char rst = ' ';
        for (int i = 0; i < t.length(); i++) {
            if (!map.containsKey(t.charAt(i)) || (map.containsKey(t.charAt(i)) && map.get(t.charAt(i)) <= 0))
                rst = t.charAt(i);
            else if (map.containsKey(t.charAt(i)) && map.get(t.charAt(i)) > 0)
                map.replace(t.charAt(i), map.get(t.charAt(i)) - 1);
        }
        return rst;
    }
}

解法2：<Bit> (遍历s和t, c^, 一直取异或, 最后剩下的就是tar;  x^0=x, x^x=0)

(1.char;  2.for()^=;  3.for()^=;  4.return;)

public char findTheDifference(String s, String t) {
    char c = 0;
    for (int i = 0; i < s.length(); ++i) {
        c ^= s.charAt(i);
    }
    for (int i = 0; i < t.length(); ++i) {
        c ^= t.charAt(i);
    }
    return c;
}

public char findTheDifference(String s, String t) {
    int n = t.length();
    char c = t.charAt(n - 1);
    for (int i = 0; i < n - 1; ++i) {
        c ^= s.charAt(i);
        c ^= t.charAt(i);
    }
    return c;
}

409. Longest Palindrome: https://leetcode.com/problems/longest-palindrome/

最长的回文字符串(顺读和倒读相同)：

我的解法: <HashMap> (回文字符串的长度=偶数个数的字符*偶数个数 + 奇数个数的字符 * (奇数 - 1) ; 如果存在奇数个数字符,则+1,不存在则不加; 示例:"aaaabb"-"aabbaa"-6, "abcccc"-5; map不包含则put, 包含了value为1则count+2(表明个数由奇数个变成偶数个)value置零, 包含了value=0则置一,count不变)

(1.map,count;  2.for()if(!)put(1),elseif(contains&value=1)count+2 value0, else()value1;  3.if(containsValue1)count+1,else count;)

public class Solution {
    public int longestPalindrome(String s) {
        HashMap<Character, Integer> map = new HashMap<>();
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            if (!map.containsKey(s.charAt(i)))
                map.put(s.charAt(i), 1);
            else if (map.containsKey(s.charAt(i)) && (map.get(s.charAt(i)) % 2) != 0) {
                count = count + 2;
                map.replace(s.charAt(i), 0);
            }
            else if (map.containsKey(s.charAt(i)) && (map.get(s.charAt(i)) % 2) == 0)
                map.replace(s.charAt(i), 1);   
        }
        if (map.containsValue(1)) return count + 1;
        else return count;
    }
}

 可以用set简化: <HashSet>(每出现偶数次数时,就把count+2,并remove掉; 相当与每两个一对; 最后判断size>0, 那么count+1,否则count)

(1.set,count;  2.for()if(!)add,else count+2,remove;  3.if(size()>0)count+1,else-count;)

public class Solution {
    public int longestPalindrome(String s) {
        HashSet<Character> set = new HashSet<>();
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            if (!set.contains(s.charAt(i)))
                set.add(s.charAt(i));
            else {
                count = count + 2;
                set.remove(s.charAt(i));
            }
        }
        if (set.size() > 0) return count + 1;
        else return count;
    }
}

438. Find All Anagrams in a String: https://leetcode.com/problems/find-all-anagrams-in-a-string/

找出字符串2在字符串1中所有相同字符的起始位置：(Input: s: "cbaebabacd" p: "abc" Output: [0, 6]) (Input: s: "abab" p: "ab" Output: [0, 1, 2])

错误代码：(map记录字符串2的key和count, 遍历字符串1; 错误原因：map被改动了,只能得到第一个位置; PS:还有for(j)的范围也写错了orz...)(一个难点是含重复字符,不然就不用修改map或者可以用set来完成了)

public class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        HashMap<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < p.length(); i++) {
            if (!map.containsKey(p.charAt(i)))
                map.put(p.charAt(i), 1);
            else
                map.replace(p.charAt(i), map.get(p.charAt(i)) + 1);
        }
        List<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < s.length() - p.length(); i++) {
            if (map.containsKey(s.charAt(i))) {
                int j = i;
                for (; j < p.length(); j++) {
                    if (!map.containsKey(s.charAt(j)) || (map.containsKey(s.charAt(j)) && map.get(s.charAt(j)) <= 0))
                        break;
                    else 
                        map.replace(s.charAt(j), map.get(s.charAt(j)) - 1);
                }
                if (j == i + p.length()) list.add(i);
            }
        }
        return list;
    }
}

修改后的TLE代码: (利用map的putAll方法,每遍历一个字符串1都copy一个map; pass了33/35个case; 大数据测试TLE……)

(1.map,for;  2.list,for(s-p+1) if(contains),tmpMap,putAll;  3.j,for(i,i+p),if(!||(&&<=0))-break,else-1;  4.if(j=i+p())list.add(i);  5.return)

public class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        HashMap<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < p.length(); i++) {
            if (!map.containsKey(p.charAt(i)))
                map.put(p.charAt(i), 1);
            else
                map.replace(p.charAt(i), map.get(p.charAt(i)) + 1);
        }
        List<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < s.length() - p.length() + 1; i++) {
            if (map.containsKey(s.charAt(i))) {
                HashMap<Character, Integer> tmpMap = new HashMap<>();
                tmpMap.putAll(map);
                int j = i;
                for (; j < i + p.length(); j++) {
                    if (!tmpMap.containsKey(s.charAt(j)) || (tmpMap.containsKey(s.charAt(j)) && tmpMap.get(s.charAt(j)) <= 0))
                        break;
                    else 
                        tmpMap.replace(s.charAt(j), tmpMap.get(s.charAt(j)) - 1);
                }
                if (j == i + p.length()) list.add(i);
            }
        }
        return list;
    }
}

解法2: <Sliding Window>(初始化字符数组hash[256], 用来记录string2的字符和滑动窗口后字符串的变化情况;  示例[cdabbaa]-[aab]: 首先初始化的hash里保存数据为a-2,b-1; 定义两个指针left和right, right向右遍历; 扫描到c/d时,c/d对应位置-1;扫描到a,count--,对应a-1,b-1; right指向b,count--,a-1,b-0;此时left指向d, r-l=3时, d<0, 所以count不变,left++; 指向第二个b,count=1不变a-1,b-(-1);  right指向a,left指向b,此时count=1, ……)

(hash数组长度256是ASCII所有值的长度, 也可以用26, 不过对应的char的位置要用char-'a')

(第一个>=1表明hash数组里还存有改数, 第二个>=0表明该数被right遍历前是1,是原数组里的数;case:[a-2,b-1] [bbbaaa]count的变化和hash的变化;)

(1.list,if,hash,for(),++;  2.left,right,count;  3.while(<),if(>=1)--,--,++;  4.if(0)add;  5.if(=)if(>=0)++,++,++;  6.return)

public class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> list = new ArrayList<>();
    if (s == null || s.length() == 0 || p == null || p.length() == 0) return list;
    
    int[] hash = new int[256]; //character hash
    
    //record each character in p to hash
    for (char c : p.toCharArray()) {
        hash[c]++;
    }
    //two points, initialize count to p's length
    int left = 0, right = 0, count = p.length();
    
    while (right < s.length()) {
        //move right everytime, if the character exists in p's hash, decrease the count
        //current hash value >= 1 means the character is existing in p
        if (hash[s.charAt(right)] >= 1) {
            count--;
        }
        hash[s.charAt(right)]--;
        right++;
        
        //when the count is down to 0, means we found the right anagram
        //then add window's left to result list
        if (count == 0) {
            list.add(left);
        }
        //if we find the window's size equals to p, then we have to move left (narrow the window) to find the new match window
        //++ to reset the hash because we kicked out the left
        //only increase the count if the character is in p
        //the count >= 0 indicate it was original in the hash, cuz it won't go below 0
        if (right - left == p.length() ) {
           
            if (hash[s.charAt(left)] >= 0) {
                count++;
            }
            hash[s.charAt(left)]++;
            left++;
        }
    }
        return list;
    }
}

451. Sort Characters By Frequency: https://leetcode.com/problems/sort-characters-by-frequency/