深入剖析01.02 题解：判定字符是否重排，精通 Java、C++ 与 Rust

2023-12-11 00:46:29

Java 题解

import java.util.HashMap;

class Solution {
    /**
     * 哈希表法
     *
     * @param s1 第一个字符串
     * @param s2 第二个字符串
     * @return 是否为字符重排
     */
    public boolean isAnagram(String s1, String s2) {
        if (s1.length() != s2.length()) {
            return false;
        }

        // 创建哈希表存储 s1 中每个字符出现的次数
        HashMap<Character, Integer> charCount = new HashMap<>();
        for (char c : s1.toCharArray()) {
            charCount.put(c, charCount.getOrDefault(c, 0) + 1);
        }

        // 检查 s2 中每个字符出现的次数是否与 s1 中相同
        for (char c : s2.toCharArray()) {
            int count = charCount.getOrDefault(c, 0);
            if (count == 0) {
                return false;
            } else {
                charCount.put(c, count - 1);
            }
        }

        return true;
    }
}

C++ 题解

#include <unordered_map>

class Solution {
public:
    /**
     * 哈希表法
     *
     * @param s1 第一个字符串
     * @param s2 第二个字符串
     * @return 是否为字符重排
     */
    bool isAnagram(string s1, string s2) {
        if (s1.length() != s2.length()) {
            return false;
        }

        // 创建哈希表存储 s1 中每个字符出现的次数
        unordered_map<char, int> charCount;
        for (char c : s1) {
            charCount[c]++;
        }

        // 检查 s2 中每个字符出现的次数是否与 s1 中相同
        for (char c : s2) {
            if (charCount.find(c) == charCount.end() || charCount[c] == 0) {
                return false;
            } else {
                charCount[c]--;
            }
        }

        return true;
    }
};

Rust 题解

use std::collections::HashMap;

struct Solution;

impl Solution {
    /**
     * 哈希表法
     *
     * @param s1 第一个字符串
     * @param s2 第二个字符串
     * @return 是否为字符重排
     */
    pub fn is_anagram(s1: String, s2: String) -> bool {
        if s1.len() != s2.len() {
            return false;
        }

        // 创建哈希表存储 s1 中每个字符出现的次数
        let mut char_count: HashMap<char, i32> = HashMap::new();
        for c in s1.chars() {
            *char_count.entry(c).or_insert(0) += 1;
        }

        // 检查 s2 中每个字符出现的次数是否与 s1 中相同
        for c in s2.chars() {
            if !char_count.contains_key(&c) || char_count[&c] == 0 {
                return false;
            } else {
                *char_count.get_mut(&c).unwrap() -= 1;
            }
        }

        true
    }
}

扩展思路

除了使用哈希表来判定字符是否重排，我们还可以使用排序的方法。排序后，如果两个字符串相等，则它们是字符重排。

import java.util.Arrays;

class Solution {
    /**
     * 排序法
     *
     * @param s1 第一个字符串
     * @param s2 第二个字符串
     * @return 是否为字符重排
     */
    public boolean isAnagram(String s1, String s2) {
        if (s1.length() != s2.length()) {
            return false;
        }

        // 将字符串转换为字符数组
        char[] s1Chars = s1.toCharArray();
        char[] s2Chars = s2.toCharArray();

        // 排序字符数组
        Arrays.sort(s1Chars);
        Arrays.sort(s2Chars);

        // 比较排序后的字符数组是否相等
        return Arrays.equals(s1Chars, s2Chars);
    }
}

#include <algorithm>

class Solution {
public:
    /**
     * 排序法
     *
     * @param s1 第一个字符串
     * @param s2 第二个字符串
     * @return 是否为字符重排
     */
    bool isAnagram(string s1, string s2) {
        if (s1.length() != s2.length()) {
            return false;
        }

        // 将字符串转换为字符数组
        char s1Chars[s1.length()];
        char s2Chars[s2.length()];
        for (int i = 0; i < s1.length(); i++) {
            s1Chars[i] = s1[i];
            s2Chars[i] = s2[i];
        }

        // 排序字符数组
        sort(s1Chars, s1Chars + s1.length());
        sort(s2Chars, s2Chars + s2.length());

        // 比较排序后的字符数组是否相等
        return equal(s1Chars, s1Chars + s1.length(), s2Chars);
    }
};

use std::collections::HashMap;

struct Solution;

impl Solution {
    /**
     * 排序法
     *
     * @param s1 第一个字符串
     * @param s2 第二个字符串
     * @return 是否为字符重排
     */
    pub fn is_anagram(s1: String, s2: String) -> bool {
        if s1.len() != s2.len() {
            return false;
        }

        // 将字符串转换为字符数组
        let s1_chars: Vec<char> = s1.chars().collect();
        let s2_chars: Vec<char> = s2.chars().collect();

        // 排序字符数组
        s1_chars.sort();
        s2_chars.sort();

        // 比较排序后的字符数组是否相等
        s1_chars == s2_chars
    }
}