Question

我正在尝试计算数组中有多少重复项。

示例：

[0, 2, 0] would return 2, [0, 0, 0] would return 3, [0, 1, 2] = 0

到目前为止，当所有三个项目都相同时我才能使用它，但是我不确定它为什么会返回一个比2个项目相同的值。

    int equal = 0;

    for(int i = 0; i < recent.length; i++) {
        for(int j = i; j < recent.length; j++) {
            if(i != j && recent[i].equals(recent[j])) {
                equal++;
            }
        }
    }

Answer 1

您的算法在以下方面存在缺陷：对于数组中的每个元素，您都会查看该元素之后的所有元素，如果它们恰好相同，则会增加计数器。但是当你有3个相同的元素时，你会计算最后一个元素 - 当你为第一个元素和第二个元素运行内部循环时。此外，你永远不会计算第一个元素。

因此[0, 0, 0]偶然起作用，但不适用于其他输入。

Answer 2

您提供的代码具有等价性，因此每次元素等于另一个元素时，它都会添加一个。

听起来你想要的是重复项目的数量，这与（长度 - 没有重复的项目数量）相同。我将后者称为“uniqueItems”。

我会推荐以下内容：

// set of every item seen
Set<Integer> allItems = new HashSet<Integer>();
// set of items that don't have a duplicate
Set<Integer> uniqueItems = new HashSet<Integer>();

for(int i = 0; i < recent.length; i++) {
    Integer val = i;
    if(allItems.contains(val)) {
        // if we've seen the value before, it is not a "uniqueItem"
        uniqueItems.remove(val); 
    } else {
        // assume the value is a "uniqueItem" until we see it again
        uniqueItems.add(val);
    }
    allItems.add(val);
}
return recent.length - uniqueItems.size();

Answer 3

我认为嵌套循环效率很低。你应该能够用o（n）而不是o（n ^ 2）来做。

如果你的时间与以下时间相符......

public void run() {
    int[] array = createRandomArray(2000000, 1000000);
    System.out.println(countNumDups1(array));
}


private int[] createRandomArray(int numElements, int maxNumExclusive) {
    int[] array = new int[numElements];
    Random random = new Random();
    for (int i = 0; i < array.length; i++) {
        array[i] = random.nextInt(maxNumExclusive);
    }
    return array;
}

private int countNumDups1(int[] array) {
    Map<Integer, Integer> numToCountMap = new HashMap<>();
    for (int i = 0; i < array.length; i++) {
        Integer key = array[i];
        if (numToCountMap.containsKey(key)) {
            numToCountMap.put(key, numToCountMap.get(key) + 1);
        }
        else {
            numToCountMap.put(key, 1);
        }
    }
    int numDups = 0;
    for (int i = 0; i < array.length; i++) {
        Integer key = array[i];
        if (numToCountMap.get(key) > 1) {
            numDups++;
        }
    }
    return numDups;
}

我认为即使考虑到自动装箱和对象创建的可怕效率低下，你也会发现上述速度要快得多。

Answer 4

以下代码可以完美地找到重复项

    int array[] = {1,2,3,4,5,2,3,4,5,3,4,5,4,5,5};

    HashMap<Integer,Integer> duplicates = new HashMap<Integer,Integer>();
    for(int i=0; i<array.length; i++)
    {
        if(duplicates.containsKey(array[i]))
        {
            int numberOfOccurances = duplicates.get(array[i]);
            duplicates.put(array[i], (numberOfOccurances + 1));
        }else{
            duplicates.put(array[i], 1);
        }
    }
    Iterator<Integer> keys = duplicates.keySet().iterator();
    System.out.print("Duplicates : " );
    while(keys.hasNext())
    {
        int k = keys.next(); 
        if(duplicates.get(k) > 1)
        {
            System.out.print(" "+k);
        }
    }

Answer 5

您正在计算具有相等值的索引对的数量。您声称需要的是包含多个元素的所有相等元素集的总大小。

我会使用Map或类似物来计算给定值的总出现次数。最后，迭代键值，为每个具有多个外观的键添加外观数。

Answer 6

int intArray[] = {5, 1, 2, 3, 4, 5, 3, 2};  

String val = "";

int c = 1;

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

for (int i = 0; i < intArray.length; i++) {

    Integer key = intArray[i];

        if(nwmap.get(key) != null && nwmap.containsKey(key)){

        val += " Duplicate: " +String.valueOf(key)+"\n";

    }else{

        nwmap.put(key, c);

            c++;

    }

}

LOG.debug("duplicate value:::"+val);

Answer 7

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;


public class ArrayDuplicateCount {

    /**
     * @author:raviteja katari
     */
    public static void main(String[] args) {
        int intArray[] = {5, 1,4,4,4,5,1,2,1,2,5,5};  


        //for counting duplicate items
        int c = 0;

        //creating map collection to hold integers as keys and Cont as value
        Map<Integer, Integer> nwmap = new LinkedHashMap<Integer, Integer>();  

        for (int i = 0; i <intArray.length; i++) {

            //Assigning array element to key 
            Integer key = intArray[i];

                //this code checks for elemnt if present updates count value else 
                //put the new Array elemnt into map and increment count

                if(nwmap.containsKey(key)){

                    //updating key value by 1 
                    nwmap.put(key, nwmap.get(key) + 1);

            }else{

                //Adding new array element to map and increasing count by 1
                  nwmap.put(key, c+1);


                   }

                           }
          //printing map
        System.out.println(nwmap);
    }

}

输出： {5 = 4,1 = 3,4 = 3 = 2}

Answer 8

    public void TotalduplicateNumbers {
    int a[] = {2,8,2,4,4,6,7,6,8,4,5};
    Map<Integer,Integer> m = new HashMap<Integer,Integer>();
    for(int i=0;i<a.length;i++){            

            if(!m.containsKey(a[i]))
            {
                m.put(a[i], 1);
            }
            else
            {
                m.put(a[i], (m.get(a[i])+1));
            }

    }

    for(Integer i:m.keySet()){
        System.out.println("Number "+i+" "+"Occours "+m.get(i)+" time,");
    }
}

我们有一个包含11个数字的数组，逻辑是使用这些数字来创建地图。其中地图的KEYS是用户必须输入的实际数字而不是。实际没有的事件。将是该KEY的价值。这里，containsKey（）方法检查映射是否已包含该键，并在应用时返回布尔值true或false。如果它不包含，则将该键添加到映射中，其对应的值应为1，否则键将已包含在map中，使用get（）获取该键的值，并将其递增1.最后打印地图。

输出： -

2号Occours 2次， 4号Occours 3次，第5次Occours 1次， 6号Occours 2次， 7号Occours 1次， 8号Occours 2次，

如何在java数组中查找重复项？

8 个答案: