Question

问题是

如何仅使用java中数组上的操作来获取数组中最大重复的String？

所以我在测试中遇到了这个问题并且无法理解。假设我们有一个字符串数组。

str1[] = { "abbey", "bob", "caley", "caley", "zeeman", "abbey", "bob", "abbey" }
str2[] = { "abbey", "bob", "caley", "caley", "zeeman", "abbey", "bob", "abbey", "caley" }

在str1 修道院中最多重复，因此应返回 abbey 并

str2

修道院

caley

都具有相同的重复次数，因此我们将最大字母作为获胜者并返回（ caley 在这里）。

c＆gt;一个

所以我试过

import java.util.*;
public class test {
    static String highestRepeated(String[] str) {
        int n = str.length, num = 0;
        String temp;
        String str2[] = new String[n / 2];

        for (int k = 0;k < n; k++) {  // outer comparision
            for (int l = k + 1; l < n; l++) { // inner comparision
                if (str[k].equals(str[l])) {
                    // if matched, increase count
                    num++;
                }
            }
             // I'm stuck here
        }

        return result;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("enter how many votes");
        int n = sc.nextInt();
        String[] str = new String[n];
        for (int i = 0; i < n; i++) {
            Str[i] = sc.nextLine();

        }
        String res = highestRepeated(str);
        System.out.println(res + " is the winner");
    }
}

所以，我应该如何计算每个字符串的出现次数，并将其附加到字符串本身。

所有这些，不使用地图和任何散列，只是使用数组？

Answer 1

这是一个（未抛光的）解决方案：

static String highestRepeated(String[] str) {
    String[] sorted = Arrays.copyOf(str, str.length);
    Arrays.sort(sorted, 0, sorted.length, Comparator.reverseOrder());
    String currentString = sorted[0];
    String bestString = sorted[0];
    int maxCount = 1;
    int currentCount = 1;
    for (int i = 1 ; i < sorted.length ; i++) {
        if (currentString.equals(sorted[i])) {
            currentCount++;
        } else {
            if (maxCount < currentCount) {
                maxCount = currentCount;
                bestString = currentString;
            }
            currentString = sorted[i];
            currentCount = 1;
        }
    }
    if (currentCount > maxCount) {
        return currentString;
    }
    return bestString;
}

说明：

按字典顺序将数组从最高到最低排序。这是Arrays.sort(sorted, 0, sorted.length, Comparator.reverseOrder());的作用。我们按此顺序排序，因为如果有多个字符串具有相同的重复次数，则需要最大的字符串。

现在我们可以通过循环遍历数组来计算字符串。我们不需要哈希映射或任何东西，因为我们知道当遇到不同的字符串时，数组的其余部分将不再有字符串。

currentString是我们正在使用currentCount计算重复次数的字符串。 maxCount是我们目前计算的最重复字符串bestString - 的出现次数。

if语句非常明显：如果它是相同的字符串，请对其进行计数，否则查看我们计算的前一个字符串（currentCount）是否出现的次数超过当前最大值。

最后，我检查计算的最后一个字符串是否大于最大值。如果数组中的最后一个字符串恰好是最重复的字符串，则bestString不会被分配给它，因为bestString仅在不同的字符串时分配遇到。

请注意，此算法不处理空数组或仅一个元素数组等边缘情况。我相信你会自己解决这个问题。

Answer 2

另一个版本

static String lastMostFrequent(String ... strs) {
    if (strs.length == 0) return null;
    Arrays.sort(strs);
    String str = strs[0];
    for (int longest=0, l=1, i=1; i<strs.length; i++) {
        if (!strs[i-1].equals(strs[i])) { l=1; continue; }
        if (++l < longest) continue;
        longest = l;
        str = strs[i];
    }
    return str;
}

改变

if (++l <= longest) continue;

for firstMostFrequent

Answer 3

你不能使用==检查两个字符串是否相同。试着改用：

if (str[k].equals(str[l])) {
                // if matched, increase count
                num++;
            }

数组中最大重复的String

3 个答案: