第三章 哈希表part01

242.有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true

示例 2: 输入: s = “rat”, t = “car” 输出: false

说明: 你可以假设字符串只包含小写字母。
链接

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

总结，使用数组去解这道题最方便，因为给定了数组的大小是26，所以可以使用数组去模拟set的实现过程
注意字符串的常用函数

public class StringMethodsDemo {
    public static void main(String[] args) {
        String str = "Hello, World!";

        // 返回指定索引处的字符
        char charAtExample = str.charAt(1); // 'e'

        // 返回字符串的长度
        int lengthExample = str.length(); // 13

        // 返回从指定位置开始到末尾的子字符串
        String substringExample1 = str.substring(7); // "World!"

        // 返回指定起始和结束位置之间的子字符串
        String substringExample2 = str.substring(0, 5); // "Hello"

        // 返回指定子字符串在字符串中第一次出现的索引
        int indexOfExample = str.indexOf("o"); // 4

        // 返回指定子字符串在字符串中最后一次出现的索引
        int lastIndexOfExample = str.lastIndexOf("o"); // 8

        // 判断字符串是否包含指定的字符序列
        boolean containsExample = str.contains("World"); // true

        // 替换字符串中的所有指定字符
        String replaceExample = str.replace('o', 'a'); // "Hella, Warld!"

        // 去除字符串两端的空白字符
        String trimExample = "  Hello  ".trim(); // "Hello"

        // 将字符串转换为小写
        String toLowerCaseExample = str.toLowerCase(); // "hello, world!"

        // 将字符串转换为大写
        String toUpperCaseExample = str.toUpperCase(); // "HELLO, WORLD!"

        // 根据指定的正则表达式拆分字符串
        String[] splitExample = str.split(", "); // ["Hello", "World!"]

        // 比较两个字符串的内容是否相同
        boolean equalsExample = str.equals("Hello, World!"); // true

        // 比较两个字符串（忽略大小写）是否相同
        boolean equalsIgnoreCaseExample = str.equalsIgnoreCase("hello, world!"); // true

        // 检查字符串是否为空（长度为 0）
        boolean isEmptyExample = str.isEmpty(); // false

 
    }
}

349. 两个数组的交集

链接

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> s1 = new HashSet<>();
        Set<Integer> s2 = new HashSet<>();
        for(int i : nums1){
            s1.add(i);
        }
        for(int i :nums2){
            if(s1.contains(i)){
                s2.add(i);
            }
        }
        int[] result = new int[s2.size()];
        int j = 0;
        for(int i : s2){
            result[j++] = i;
        }

        return result;
    }
}

两个set，一个先加数据，另外一个再根据此set进行判断

第202题. 快乐数

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环
但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。

如果 n 是快乐数就返回 True ；不是，则返回 False 。 示例：

输入：19 输出：true 解释： 1^2 + 9^2 = 82 8^2 + 2^2 = 68 6^2 + 8^2 = 100 1^2 +
0^2 + 0^2 = 1

链接

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> s = new HashSet<>();
        while(!s.contains(n)){
            s.add(n);
            if(n == 1) return true;
            else n =getnextn(n);
        }
        return false;
    }

    public int getnextn(int n){
        int temp;
        int result=0;
        while(n!=0){
            temp = n%10;
            result += temp*temp;
            n/=10;
        }
        return result;
    }
}

1. 两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] res = new int[2];
        if(nums == null || nums.length == 0){
            return res;
        }
        Map<Integer,Integer> map = new HashMap<>();
        for(int i = 0 ; i< nums.length;i++){
            int temp = target -nums[i];
            if(map.containsKey(temp)){
                res[1] = i;
                res[0] = map.get(temp);
                break;
            }
            map.put(nums[i],i);
        }
        return res;
    }
}

注意hashmap的key和value，理解为什么可以一个循环就可以实现
补充一点关于hashmap的操作
`

import java.util.HashMap;

public class HashMapMethodsDemo {
    public static void main(String[] args) {
        // 创建一个 HashMap 实例
        HashMap<Integer, String> map = new HashMap<>();

        // put() 方法 - 添加键值对
        map.put(1, "Apple");
        map.put(2, "Banana");
        map.put(3, "Cherry");

        // get() 方法 - 根据键获取值
        String value1 = map.get(1); // "Apple"

        // remove() 方法 - 根据键删除键值对
        map.remove(2);

        // containsKey() 方法 - 检查是否包含某个键
        boolean containsKey = map.containsKey(3); // true

        // containsValue() 方法 - 检查是否包含某个值
        boolean containsValue = map.containsValue("Banana"); // false

        // size() 方法 - 获取键值对数量
        int size = map.size(); // 2

        // isEmpty() 方法 - 检查是否为空
        boolean isEmpty = map.isEmpty(); // false

        // keySet() 方法 - 获取所有键的集合
        java.util.Set<Integer> keys = map.keySet();

        // values() 方法 - 获取所有值的集合
        java.util.Collection<String> values = map.values();

        // entrySet() 方法 - 获取所有键值对的集合
        java.util.Set<java.util.Map.Entry<Integer, String>> entries = map.entrySet();

        // 遍历键值对
        for (java.util.Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}