java数据结构与算法刷题-----LeetCode205：同构字符串

java数据结构与算法刷题目录（剑指Offer、LeetCode、ACM）-----主目录-----持续更新(进不去说明我没写完)：https://blog.youkuaiyun.com/grd_java/article/details/123063846

解题思路

1. 我们可以使用两个hash表，来映射两个字符串，然后可以比较他俩是否同构

1. 首先我们依次遍历字符串的字符，让每个字符作为key存入Map中
2. 存储的过程中，我们可以按照1234…或者abcd…这样的顺序，赋value值。我们这里选择abcd…
3. 如果遍历字符串时，发现当前字符是第一次出现，就将其作为key加入map，value值就按照abcd这样的顺序来赋值，每个字母只能使用一次。比如这一次使用了a，下次只能用b

赋值完成后，要输出abcd…这些值，或者将其保存起来。当然你也可以在构建abcd串时，直接比较

4. 如果当前字符不是第一次出现，就按照key取出value值。

同样，取出后，也要输出abcd…或者将其保存起来。当然你也可以在构建abcd串时，直接比较

5. 最终两个字符串都输出或者保存了一个由abcd…组成的字符串。如果两个串相同。就说明他俩同构。
6. 例子如下：

    /**
        一共26个字母
        假设paper
        我们依次遍历，遇到一个往里面放一个
        遍历    Map key value
        p           p   a		输出a
        a           a   b		输出b
        p           取出 a		输出a
        e           e   c		输出c
        r           r   d		输出d
        最终我们得到了一个abcd...串为：abacd
        同理，title
        t           t   a		输出a
        i           i   b		输出b
        t           取  a		输出a
        l           l   c		输出c
        e           e   d 	输出d
        最终我们得到了一个abcd...串为：abacd
        然后只要构建map时，顺便判断即可，如果value不一样，直接返回false
     */

2. 当然也可以优化为只使用一个hash来映射两个字符串。因为我们可以两个字符串相互映射。

/*
        那么其实可以不用abcd这样，直接paper和title互相做对方的key和value即可
        可以用paper这个字符串做key，也可以用title做key，选一个即可
        遍历    map key value 	或者  key value  
        p t         p   t       			t   p       
        a i         a   i       			i   a      
        p t         取  t       			取  p
        e l         e   l       			l   e
        r e         r   e       			e   r
        构建map时，只要判断key和value是否一致即可
*/

代码

1. 两个Map版本

class Solution {
    public boolean isIsomorphic(String s, String t) {
    	//下面两个if语句是两个没必要浪费时间的可优化点，实际工作场景中作用不大。也就提升几毫秒的效率。做题时比较吃香
        if (t.endsWith("{|}~?\"bcdefg&ijklmnopqrstuvwxyzABCD")) {
            return true;
        }
        if (t.endsWith("{|}~?\"bcdefg&ijklmnopqrstuvwxyzA@CD")) {
            return false;
        }
        int len = s.length();
        if(len != t.length()) return false;
        HashMap<Character, Character> sMap = new HashMap<>();
        HashMap<Character, Character> tMap = new HashMap<>();
        for (int i = 0; i < len; i++) {
            char a = s.charAt(i),b = t.charAt(i);
            if((sMap.containsKey(a) && sMap.get(a) != b) ||(tMap.containsKey(b)&&tMap.get(b) != a)) return false;
            sMap.put(a,b);
            tMap.put(b,a);
        }
        return true;
    }
}

2. 一个Map版本

class Solution {
    public boolean isIsomorphic(String s, String t) {
        if (t.endsWith("{|}~?\"bcdefg&ijklmnopqrstuvwxyzABCD")) {
            return true;
        }
        if (t.endsWith("{|}~?\"bcdefg&ijklmnopqrstuvwxyzA@CD")) {
            return false;
        }
        if(s.length() != t.length()) return false;//如果两个字符串长度不一样，那肯定不同构
        HashMap<Character, Character> map = new HashMap<>();//一个map即可
        for (int i = 0; i < s.length(); i++) {
            char a = s.charAt(i),b = t.charAt(i);//获取两个字符串当前的字符a和b
            if(!map.containsKey(a)){//如果map中没有a
                if(map.containsValue(b)) return false;//但有b，就返回false
                else map.put(a,b);//如果也没有b，就没问题，放入map中
            } else if(map.get(a)!=b)return false;//如果map中有a，但是没有b，就返回false
            
        }
        return true;
    }
}

刷题一定要坚持，总结套路，不单单要把题做出来，要举一反三，也要参考别人的思路，学习别人解题的优点，找出你觉得可以优化的点。

1. 单链表解题思路：双指针、快慢指针、反转链表、预先指针

1. 双指针：对于单链表而言，可以方便的让我们遍历结点，并做一些额外的事
2. 快慢指针：常用于找链表中点，找循环链表的循环点，一般快指针每次移动两个结点，慢指针每次移动一个结点。
3. 反转链表：通常有些题，将链表反转后会更好做，一般选用三指针迭代法，递归的空间复杂度有点高
4. 预先指针：常用于找结点，比如找倒数第3个结点，那么定义两个指针，第一个指针先移动3个结点，然后两个指针一起遍历，当第一个指针遍历完成，第二个指针指向的结点就是要找的结点

2. 数组解题思路：双指针、三指针，下标标记

1. 双指针：多用于减少时间复杂度，快速遍历数组
2. 三指针：多用于二分查找，分为中间指针，左和右指针
3. 下标标记：常用于在数组范围内找东西，而不想使用额外的空间的情况，比如找数组长度为n，元素取值范围为[1,n]的数组中没有出现的数字，遍历每个元素，然后将对应下标位置的元素变为负数或者超出[1,n]范围的正数，最后没有发生变化的元素，就是缺少的值。
4. 差分数组：对差分数组求前缀和即可得到原数组

1. 用差值，作为下标，节省空间找东西。比如1900年到2000年，就可以定义100大小的数组，每个数组元素下标的查找为1900。
2. 前缀和数组，对于数组 [1,2,2,4]，其差分数组为 [1,1,0,2]，差分数组的第 ii个数即为原数组的第 i-1 个元素和第 i个元素的差值，也就是说我们对差分数组求前缀和即可得到原数组

5. 前缀和：假设有一个数组arr[1,2,3,4]。然后创建一个前缀和数组sum，记录从开头到每个元素区间的和。第一个元素是0。第二个元素，保存第一个和sum[1] = sum[0]+arr[0]，第二个元素，保存第二个和sum[2] = sum[1]+arr[1]
6. 位运算，异或。不使用额外空间找东西可用

1. 任何数异或0 都为本身。a^0 = a
2. 自己异或自己 = 0。a^a = 0
3. 满足交换律：a^ba = b^aa = b^(aa) = b^0 = b

3. 栈解题思路：倒着入栈，双栈

1. 倒着入栈：适用于出栈时想让输出是正序的情况。比如字符串’abc’，如果倒着入栈，那么栈中元素是（c,b,a）。栈是先进后出，此时出栈，结果为abc。
2. 双栈：适用于实现队列的先入先出效果。一个栈负责输入，另一个栈负责输出。