-2

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

例子：

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

到目前为止，当所有三个项目都相等时，我已经让它工作了，但我不确定为什么它返回的结果比两个相同的项目少一个。

    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++;
            }
        }
    }
4

8 回答 8

1

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

    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);
        }
    }
于 2013-05-24T16:25:59.327 回答
1

I think that having nested loops is quite inefficient. You should be able to do it in o(n) rather than o(n^2).

If you time yours against the following...

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;
}

I think you'll find the above is much faster even considering the horrible inefficiency of autoboxing and object creation.

于 2012-12-01T10:02:25.180 回答
1

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

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

于 2012-12-01T09:27:00.250 回答
1

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

听起来您想要的是重复项目的数量，这与（长度 - 没有重复项目的数量）相同。我将把后者称为“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();
于 2012-12-01T09:28:34.900 回答
0 
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);
于 2013-03-26T17:48:12.297 回答
0 
    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 否则键将已被包含在地图中，因此使用 get() 获取该键的值并将其递增 1。最后打印地图。

输出： -

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

于 2014-09-17T10:11:38.230 回答
0 
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=2}

于 2014-08-10T08:34:04.613 回答
0

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

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

于 2012-12-01T09:33:27.443 回答