Question

我正在使用HashSet来查找已排序 Integer数组中值的最大重复次数。但我的算法似乎不起作用，没有返回所需的结果。

Set variables storing the number of duplicates found (0), and the maximum number of duplicates (0). 
Set a HashSet that stores the unique values of an array.
Sort the array to be ready for comparison.

Loop through each value of the array
    If the HashSet of unique values contains the current value:
        Increment the duplicate Count

    If the currentValue is not equal to the previous value:
        If the duplicateCount is greater than the maximum Count:
            maximumCount becomes duplicateCount
            Reset duplicateCount to 0

Java代码：

HashSet<Integer> uniqueValues = new HashSet<Integer>(valueSequenceList);

int duplicateCount = 0;
int maxCount = 0;
Arrays.sort(valueSequence);

for (int i = 0; i < valueSequence.length; i++)
{
    if (uniqueValues.contains(valueSequence[i]))
    {
        duplicateCount++;
    }
    if (i > 0 && valueSequence[i] != valueSequence[i-1])
    {
        if (duplicateCount > maxCount)
        {
            maxCount = duplicateCount;
            duplicateCount = 0;
        }
    }
}

示例：
输入：[4,4,10,4,10]
输出：4个重复（最多应该有3个重复项 - 相同的值总数）。

Answer 1

这是Element Distinctness Problem - 在帖子中详细解释：Find duplicates in an array。

提及线程讨论了问题的解决方案，并显示了下限（如果不使用哈希表，则不能比O(nlogn)更好。

因此，如果您的数据未排序 - 您可以排序和迭代（如下所示），或使用哈希集 - 然后您不需要对数组进行排序。

如果您首先对数组进行排序，或者数组已经排序，则单次迭代将执行：

对已排序数组进行单次迭代：

if (arr == null || arr.length == 0) return 0;
int last = arr[0];
int numDupes = 1;
for (int i = 1; i < arr.length; i++) { 
   if (arr[i] == last) numDupes++;
   last = arr[i];
}

使用HashSet（无需排序）：

if (arr == null) return 0;
Set<Integer> set = new HashSet<>();
int numDupes = 0;
for (int x : arr) { 
    if (set.contains(x)) numDupes++;
    set.add(x);
}

如果您正在查找某个元素重复的最大数字（而不是重复的总数），您可以使用相同的方法，但略有不同：

哈希解决方案 - 使用histogram：

Map<Integer,Integer> histogram = new HashMap<>();
for (int x : arr) { 
  if (!histogram.containsKey(x)) histogram.put(x,1); 
  else histogram.put(x,histogram.get(x) + 1);
}
int max = 0;
for (int x : histogram.values) max = max > x ? max : x;
return max;

排序数组解决方案：

if (arr == null || arr.length == 0) return 0;
int last = arr[0];
int max = 0;
int currNumDupes = 1;
for (int i = 1; i < arr.length; i++) { 
   if (arr[i] == last) currNumDupes++;
   else { 
        max = max > currNumDupes ? max : currNumDupes;
        currNumDupes = 1;
   }
   last = arr[i];
}
max = max > currNumDupes ? max : currNumDupes; //if the most dupes is from the highest element

Answer 2

编辑：我假设（基于您的代码）目标是找到数组中出现次数最多的出现次数。称其为“最大重复次数”具有误导性。

首先，HashSet是无用的。您预先将所有元素添加到其中，这意味着uniqueValues.contains(valueSequence[i])始终为真。

现在，如果你还没有移动到下一个元素，你只想增加duplicateCount：

for (int i = 0; i < valueSequence.length; i++)
{
    if (i == 0 || valueSequence[i] == valueSequence[i-1])
    {
        duplicateCount++;
    }
    else
    {
        if (duplicateCount > maxCount)
        {
            maxCount = duplicateCount;                
        }
        duplicateCount = 1; // another small fix
    }
}
if (duplicateCount > maxCount)
    maxCount = duplicateCount;
}

如果目标是找到重复的数量，你可以不带任何循环（因为重复的数量是元素的总数减去唯一元素的数量）：

HashSet<Integer> uniqueValues = new HashSet<Integer>(valueSequenceList);
int duplicateCount = valueSequenceList.size() - uniqueValues.size();

Answer 3

建议：

您可以使用简单的Map<Integer, Integer>，其中键是项目值，值是该项目的计数。

这会使代码变得简单 - 无需排序：

Map<Integer, Integer> count = new HashMap<Integer, Integer>();

for (Integer item : list){
    if (count.containsKey(item)){
        // increate count
        count.put(item, count.get(key) + 1);
    } else {
        // no item yet - set count to 1
        count.put(item, 1);
    }
}

您现在可以使用Collections.max之类的内容查找count.values()上的最大Integer值 - 甚至可以为条目写Comparator<Entry<Integer, Integer>>以查找最大值{{3} } {来自Map.Entry<Integer, Integer>（最好，可以与count.entrySet()一起使用）。

注意：您可以使用Collections.max（Apache commons）甚至MutableInt之类的内容来获取可变的地图值。我没有测试过差异，但可能更快。

Answer 4

检查以下代码，该代码返回重复的最大数量

 public static void main(String args[]) {
    int[] inputArray = { 4, 4, 10, 4, 10 };
    Map<Integer, Integer> hMap = new HashMap<Integer, Integer>();
    HashSet<Integer> hSet = new HashSet<Integer>();
    for (int i : inputArray) {
        if (hSet.add(i)) {
            hMap.put(i, 1);
        } else {
            hMap.put(i, hMap.get(i) + 1);
        }
    }
    Iterator<Integer> iter = hMap.values().iterator();
    int temp = 0;
    while (iter.hasNext()) {
        int max = iter.next();
        if (max > temp) {
            temp = max;
        }
    }
    System.out.println(temp);
}

Answer 5

String[] Csssplit = Css.split("====");
        HashMap<String,Integer> Spancsslist = new HashMap<String,Integer>();
        for(int c=0;c<Csssplit.length;c++){
            Css = Csssplit[c];
            //System.out.println("css::"+Css);
            int count = Spancsslist.getOrDefault(Css, 0);
            Spancsslist.put(Css,count+1);    
        }
        if(Spancsslist.size()==0){ continue; }

        Spancsslist = Spancsslist.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByValue())).collect(toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2,LinkedHashMap::new));
        Css = Spancsslist.keySet().stream().findFirst().get();

Answer 6

使用Integer.MIN_VALUE查找最大数组，然后计算重复的最大int数组。

public static int main(int[] ar) {
        int count = 0;
        int max = Integer.MIN_VALUE;
        int lastMax = 0;

        for(int i = 0; i < ar.length; i++) {
           if(ar[i] > max) {
            max = ar[i];
            if(lastMax != max){
              count = 0;
            }
            lastMax = max;
           } 

          if(ar[i] == max) {
          count += 1;
          }
        }
           return count;
    }

Java - 查找数组中的最大重复数

6 个答案: