Java 哪种方法查找重复整数更有效？

通常情况下，问题有不同的解决方案。我的任务是找到重复的整数。我有两种方法

第一种方法是对整数数组进行排序并进行比较。第二种方法就是使用HashSet。你能告诉我哪种效率更高，为什么？请注意，不能覆盖原始数组

主类

public class Main {
    static DuplicateNumbers dn;
    static DuplicateNumbersHash dnh;

    public static void main(String[] args) {
        int[] arrayOfIntegers = {9, 7, 1, 3, 4, 2, 7, 5, 9};

        // 1st class test
        dn = new DuplicateNumbers(arrayOfIntegers);
        dn.searchForDuplicates();

        System.out.println("\n\n2nd test\n\n");

        // 2nd class test
        dnh = new DuplicateNumbersHash(arrayOfIntegers);
        dnh.searchForDuplicates();

    }
} // Main class

非哈希集方法

public class DuplicateNumbers {
    protected int[] arrayOfIntegers;

    public DuplicateNumbers(int[] arrayOfIntegers) {
        this.arrayOfIntegers = arrayOfIntegers;
    }

    public void searchForDuplicates() {
        // do not overwrite original array, so create a temp one instead
        int[] tempArray = new int[arrayOfIntegers.length];
        System.arraycopy(arrayOfIntegers, 0, tempArray, 0,
        arrayOfIntegers.length);

        // sorting temp array only
        Arrays.sort(tempArray);

        // now look for duplicates
        for (int i = 0; i < tempArray.length - 1; i++) {
            if (tempArray[i] == tempArray[i + 1]) {
                System.out.printf(
                    "Duplicates: tempArray[%d] and tempArray[%d]\n", i,
                    i + 1);
                System.out.printf("Repeated value: %d %d\n", tempArray[i],
                    tempArray[i + 1]);
                System.out.println();
            } // if
        } // for
    } // searchForDuplicates()
} // DuplicateNumbers class

公共类重复编号{
受保护的int[]阵列查找器；
公共重复编号（int[]arrayOfIntegers）{
this.arrayOfIntegers=arrayOfIntegers；
}
公共无效searchForDuplicates（）{
//不要覆盖原始数组，所以创建一个临时数组
int[]tempArray=new int[arrayOfIntegers.length]；
System.arraycopy（arrayOfIntegers，0，tempArray，0，
数组长度）；
//仅排序临时数组
排序（tempArray）；
//现在寻找重复的
for（int i=0；i

哈希集方法；继承上一个类以在此处粘贴较少的代码

public class DuplicateNumbersHash extends DuplicateNumbers {
    public DuplicateNumbersHash(int[] arrayOfIntegers)  {
        super(arrayOfIntegers);
    }

    @Override
    public void searchForDuplicates() {
        Set<Integer> s = new HashSet<Integer>();

        for (int i = 0; i < arrayOfIntegers.length; i++) {
                if (!s.add(arrayOfIntegers[i])) {
                    System.out.printf("Repeated value: %d\n", arrayOfIntegers[i]);
            }
        }

        s = null;
    }
}

公共类DuplicateNumbersHash扩展DuplicateNumbers{
公共DuplicateNumbersHash（int[]arrayOfIntegers）{
超级（arrayOfIntegers）；
}
@凌驾
公共无效searchForDuplicates（）{
Set s=新的HashSet（）；
for（int i=0；i

---

哪一个更好？有更好的解决方案吗？

在时间复杂度方面，最好的排序算法是

O（n logn）

，因此排序方法也是

O（n logn）

。HashSet方法的复杂性将是

O（n）

。因此，您最好使用哈希集方法。

哈希集实现的时间效率更高，而数组排序实现的内存使用效率更高

时间：向哈希集添加值具有恒定的复杂性，O（1）-哈希集有多大无关紧要。但是，arrayCopy具有线性复杂度O（n）。另外，根据您对数组的排序方式，这也需要一些时间

---

内存：数组实现只使用原始数组的两倍内存。您的散列集可能比原始数组大得多。

我建议您分析它们并检查最好的一个，但在我看来，您应该使用

集

方法（假设您没有使用

树集

）。如果您重视速度，那么我会同意Luiggi的建议并分析它。不过，从内存的角度来看，设置

更好，因为您不一定需要像所有元素的第二个副本那样多的空间。@DennisMeng排序方法在无条件下会更差。它将是O（nlogn），而set方法将是O（n）@DennisMeng-我想你已经把它倒过来了。
集合
需要包含所有数字（重复的数字除外）。然而，基于排序的方法需要排序，这是O（n log n），而基于
集的方法是O（n）。是的，我意识到我没有充分考虑它。现在已修复。+1是渐近复杂性的正确答案（当n变大时）。对于10个整数（这是OP的具体示例），不清楚哪一个具有最佳性能（这并不重要，除非在10个数字中查找重复项是某些性能关键的内部循环代码的一部分）。好吧，现在这更有意义了。我想知道为什么我的问题得了a-1。无论如何，谢谢你指出不同之处。