双非本科准备秋招(8.1)——力扣哈希

LeetCode

1、49. 字母异位词分组

学到的知识:

1、String的toCharArray()方法能返回一个Char类型的数组,自己发现对String学的还不系统,于是重新学了下String。

2、new ArrayList()可以接收一个Collection对象

3、map的keySet和values方法,分别返回Set和Collection类型的对象。

分析:

字母异位词是乱序的,也就是说,如果排序的话,那么异位词就相等了,比如"ab"、"ba",排序之后都是"ab"。

所以,我们可以遍历这个字符串数组,把每个字符串先排序,然后用排序过后的字符串当作key,查找哈希表,将原先字符串添加进去。

哈希表是String-List<String>,key是排序后的字符串,value是链表,代表key的异位词。

java 复制代码
class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        HashMap<String, List<String>> map = new HashMap();

        for(String s : strs){
            char[] chars = s.toCharArray();
            Arrays.sort(chars);
            String temp = new String(chars);
            List<String> list = map.get(temp);

            if(list == null){
                list = new ArrayList<>();
                map.put(temp, list);
            }

            list.add(s);
        }
        return new ArrayList(map.values());
    }
}

2、217. 存在重复元素

纯纯水题,建个哈希表,找一遍就行了。

不过一开始我的思维固化了,见什么都用HashMap。

java 复制代码
class Solution {
    public boolean containsDuplicate(int[] nums) {
        HashMap<Integer, Integer> map = new HashMap<>();

        for(Integer x : nums){
            if(map.containsKey(x)){
                return true;
            }
            map.put(x, 1);
        }

        return false;
    }
}

用HashSet更好,set的add()方法返回boolean值,代表是否添加成功,如果有重复元素那就添加失败了,就返回false。

java 复制代码
class Solution {
    public boolean containsDuplicate(int[] nums) {
        HashSet<Integer> set = new HashSet<>();

        for(Integer x : nums){
            if(!set.add(x)){
                return true;
            }
        }

        return false;
    }
}

3、136. 只出现一次的数字

借鉴上一个题目的思路,出现过了就加入(add())失败,那么就删除这个值(remove())。

注意如何处理返回值,需要把set转成数组:通过set.toArray()方法,把set转成数组,需要把new Integer[set.size()]作为参数传进set.toArray()方法。因为答案只有一个,所以只需要返回下标为0的元素就行,这个方法里有个实例对象就行,大小任意。写成new Integer[0]也一样。

java 复制代码
class Solution {
    public int singleNumber(int[] nums) {
        HashSet<Integer> set = new HashSet<>();
        for(Integer x : nums){
            if(!set.add(x)){
               set.remove(x); 
            }
        }
        return set.toArray(new Integer[1])[0];       
    }
}

另一种用异或的思路,异或就是相同为0,不同为1。

结论1:那么一个数自己和自己异或,都相同,结果是0;

结论2:一个数和0异或,原数是0的地方还是0(相同),是1的地方还是1(不同),所以不变。

我们只需要用0和数组中每个数异或,那么结果就是唯一的那个数,还是很巧妙的。

java 复制代码
class Solution {
    public int singleNumber(int[] nums) {
        int ans = 0;
        for(int x : nums) ans ^= x;
        return ans;
    }
}

4、242. 有效的字母异位词

这个题比第一题简单,排个序,直接比较,思路和第一题是一样的。

java 复制代码
class Solution {
    public boolean isAnagram(String s, String t) {
        char[] c1 = s.toCharArray();
        char[] c2 = t.toCharArray();
        Arrays.sort(c1);
        Arrays.sort(c2);
        String s1 = new String(c1);
        String s2 = new String(c2);
        return s1.equals(s2);
    }
}

另一种方法,这个方法第一题也能用,不过我没写。

可以建立数组,因为题目说了小写字母,所以26位就够了,字母-'a'得到的就是数组中的下标,我们统计每个字母出现的次数(hashLoop方法)。

最后遍历这两个数组,看看出现的次数相不相等。

java 复制代码
class Solution {
    public boolean isAnagram(String s, String t) {
        int[] arr1 = new int[26];
        int[] arr2 = new int[26];
        hashLoop(s, arr1);
        hashLoop(t, arr2);
        for(int i = 0; i < 26; i++){
            if(arr1[i] != arr2[i]){
                return false;
            }
        }
        return true;
    }
    public void hashLoop(String s, int[] arr){
        for(int i = 0; i < s.length(); i++){
            arr[s.charAt(i)-'a']++;
        }
    }
}

5、387.字符串中的第一个唯一字符

第一次,想复杂了。

我想的是建立26个坑位的数组,还是字符-'a'代表数组下标。然后数组记录的是它第一次出现的位置。

初始化数组,赋值为-2,-2代表未赋值。-1代表元素重复了。

遍历数组,如果等于-2并且不等于-1,即未被赋值且不重复,那么就把元素下标赋值给这个坑位。

如果不等于-2,说明元素重复,那么就赋值-1

最后遍历一遍,找到最小的元素,就是下标最小的。

java 复制代码
class Solution {
    public int firstUniqChar(String s) {
        int[] arr = new int[26];
        for(int i = 0; i < 26; i++) arr[i] = -2;
        for(int i = 0; i < s.length(); i++){
            int index = s.charAt(i)-'a';
            if(arr[index] != -1 && arr[index] == -2){//没有值,赋值。
                arr[index] = i;
            }
            else if(arr[index] != -2){//有值了,-1
                arr[index] = -1;
            }
        }
        int ans = 1000000;
        for(int i = 0; i < 26; i++){
            if(arr[i] != -1 && arr[i] != -2 && arr[i] < ans)
                ans = arr[i];
        }
        return ans==1000000?-1:ans;
    }
}

改进一下,根本没必要记录下标啊,数组还是记录出现的次数。

然后再遍历一下原字符串不就行了,看看每个字符串在数组中是不是1,是1代表出现了1次,而且是字符串第一个不重复的元素,直接返回当前遍历的下标就行了。

java 复制代码
class Solution {
    public int firstUniqChar(String s) {
        int[] arr = new int[26];
        char[] chars = s.toCharArray();
        for(char c : chars){
            arr[c-'a']++;
        }
        for(int i = 0; i < chars.length; i++){
            if(arr[chars[i] - 'a'] == 1){
                return i;
            }
        }
        return -1;
    }
}

6、349. 两个数组的交集

思路:遍历第一个数组,加入哈希表(Set)中,遍历第二个数组,在哈希表中查找。

注意返回不能直接用 ans.toArray(new Integer[0]),因为这个返回的是Integer类型的数组,题目需要返回的是int类型的数组。Integer和int可以进行相互赋值,因为java做了自动拆箱和自动装箱的操作,数组不可以。

java 复制代码
class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        HashSet<Integer> set = new HashSet<>();
        HashSet<Integer> ans = new HashSet<>();
        for(int x : nums1){
            set.add(x);
        }
        for(int x : nums2){
            if(set.contains(x)){
                ans.add(x);
            }
        }
        //处理数据
        int[] arr = new int[ans.size()];
        int cnt = 0;
        for(int s : ans){
            arr[cnt++] = s;
        }
        return arr;
    }
}

7、202.快乐数

我一开始看到无限循环,以为暗示的是没有规律,后来想想,题目说的是循环但始终不到1,意味着一定会有一个重复的循环,所以暴力做就行了,把每次得到的结果都加入哈希中,如果发现重复了就说明会无限循环了,返回false,如果等于1了,就返回true。

java 复制代码
class Solution {
    public int sum(int n){
        int ans = 0;
        while(n != 0){
            ans += (n%10)*(n%10);
            n /= 10;
        }
        return ans;
    }
    public boolean isHappy(int n) {
        HashSet<Integer> set = new HashSet<>();
        while(true){
            if(n == 1) return true;
            n = sum(n);
            if(set.contains(n)){
                return false;
            }
            set.add(n);
        }
    }
}
相关推荐
kitesxian8 分钟前
Leetcode448. 找到所有数组中消失的数字(HOT100)+Leetcode139. 单词拆分(HOT100)
数据结构·算法·leetcode
VertexGeek1 小时前
Rust学习(八):异常处理和宏编程:
学习·算法·rust
石小石Orz1 小时前
Three.js + AI:AI 算法生成 3D 萤火虫飞舞效果~
javascript·人工智能·算法
jiao_mrswang2 小时前
leetcode-18-四数之和
算法·leetcode·职场和发展
qystca2 小时前
洛谷 B3637 最长上升子序列 C语言 记忆化搜索->‘正序‘dp
c语言·开发语言·算法
薯条不要番茄酱2 小时前
数据结构-8.Java. 七大排序算法(中篇)
java·开发语言·数据结构·后端·算法·排序算法·intellij-idea
今天吃饺子2 小时前
2024年SCI一区最新改进优化算法——四参数自适应生长优化器,MATLAB代码免费获取...
开发语言·算法·matlab
是阿建吖!2 小时前
【优选算法】二分查找
c++·算法
王燕龙(大卫)2 小时前
leetcode 数组中第k个最大元素
算法·leetcode
不去幼儿园3 小时前
【MARL】深入理解多智能体近端策略优化(MAPPO)算法与调参
人工智能·python·算法·机器学习·强化学习