以上这篇JS中判断字符串中出现次数最多的字符及出现的次数的简单实例就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持小编。

2022-09-01：字符串的 波动 定义为子字符串中出现次数 最多 的字符次数与出现次数 最少 的字符次数之差。 给你一个字符串 s ，它只包含小写英文字母。请你返回 s 里所有 子字符串的 最大波

2022-09-01：字符串的 波动 定义为子字符串中出现次数 最多 的字符次数与出现次数 最少 的字符次数之差。 给你一个字符串 s ，它只包含小写英文字母。请你返回 s 里所有 子字符串的 最大波动 值。 子字符串 是一个字符串的一段连续字符序列。 注意：必须同时有，最多字符和最少字符的字符串才是有效的。 输入：s = "aababbb"。 输出：3。

答案2022-09-01：

方法一：自然智慧，3个for循环。 方法二：动态规划。

代码用rust编写。代码如下：

fn main() {
    let s = "aababbb";
    let ans = largest_variance1(s);
    println!("ans = {}", ans);
    let ans = largest_variance2(s);
    println!("ans = {}", ans);
}

fn largest_variance1(s: &str) -> i32 {
    if s.len() == 0 {
        return 0;
    }
    let n = s.len() as i32;
    // a b a c b b a
    // 0 1 0 2 1 1 0
    let mut arr: Vec<i32> = vec![];
    for _ in 0..n {
        arr.push(0);
    }
    let sbytes=s.as_bytes();
    for i in 0..n {
        arr[i as usize] = (sbytes[i as usize] - ''a'' as u8) as i32;
    }
    let mut ans = 0;
    // 26 * 26 * n O(N)
    for more in 0..26 {
        for less in 0..26 {
            if more != less {
                let mut continuous_a = 0;
                let mut appear_b = false;
                let mut max = 0;
                // 从左到右遍历，
                for i in 0..n {
                    if arr[i as usize] != more && arr[i as usize] != less {
                        continue;
                    }
                    if arr[i as usize] == more {
                        // 当前字符是more
                        continuous_a += 1;
                        if appear_b {
                            max += 1;
                        }
                    } else {
                        // 当前字符是B
                        max = get_max(max, continuous_a) - 1;
                        continuous_a = 0;
                        appear_b = true;
                    }
                    ans = get_max(ans, max);
                }
            }
        }
    }
    return ans;
}

fn get_max<T: Clone + Copy + std::cmp::PartialOrd>(a: T, b: T) -> T {
    if a > b {
        a
    } else {
        b
    }
}

fn largest_variance2(s: &str) -> i32 {
    if s.len() == 0 {
        return 0;
    }
    let n = s.len() as i32;
    // a b a c b b a
    // 0 1 0 2 1 1 0
    let mut arr: Vec<i32> = vec![];
    for _ in 0..n {
        arr.push(0);
    }
    for i in 0..n {
        arr[i as usize] = (s.as_bytes()[i as usize] - ''a'' as u8) as i32;
    }
    // dp[a][b] = more a less b max
    // dp[b][a] = more b less a max
    let mut dp: Vec<Vec<i32>> = vec![];
    // continuous[a][b] more a less b 连续出现a的次数
    // continuous[b][a] more b less a 连续出现b的次数
    let mut continuous: Vec<Vec<i32>> = vec![];
    // appear[a][b] more a less b b有没有出现过
    // appear[b][a] more b less a a有没有出现过
    let mut appear: Vec<Vec<bool>> = vec![];
    for i in 0..26 {
        dp.push(vec![]);
        continuous.push(vec![]);
        appear.push(vec![]);
        for _ in 0..26 {
            dp[i].push(0);
            continuous[i].push(0);
            appear[i].push(false);
        }
    }
    let mut ans = 0;
    // 26 * N
    for i in arr.iter() {
        let i = *i;
        for j in 0..26 {
            if j != i {
                // i,j
                // more i less j 三个变量 连续出现i，j有没有出现过，i-j max
                // more j less i 三个变量 连续出现j，i有没有出现过，j-i max
                continuous[i as usize][j as usize] += 1;
                if appear[i as usize][j as usize] {
                    dp[i as usize][j as usize] += 1;
                }
                if !appear[j as usize][i as usize] {
                    appear[j as usize][i as usize] = true;
                    dp[j as usize][i as usize] = continuous[j as usize][i as usize] - 1;
                } else {
                    dp[j as usize][i as usize] = get_max(
                        dp[j as usize][i as usize],
                        continuous[j as usize][i as usize],
                    ) - 1;
                }
                continuous[j as usize][i as usize] = 0;
                ans = get_max(
                    ans,
                    get_max(dp[j as usize][i as usize], dp[i as usize][j as usize]),
                );
            }
        }
    }
    return ans;
}

执行结果如下：

左神java代码

c# – 查找字符串中出现次数最多的字符？

"abbbbccd"

input.GroupBy(x => x).OrderByDescending(x => x.Count()).First().Key

JavaScript实现计算字符串中出现次数最多的字符和出现的次数

“计算出字符串中出现次数最多的字符是什么，出现了多少次？”

看到这个需求，我想大多数人应该首先想到的是转换成数组，再做处理，当然是可以解决问题的，然后这里提供一个巧妙的算法设计，无需转数组，可以很快解决问题，代码如下：