Question

请在将其标记为重复之前阅读该问题

我编写了以下代码，以便在不使用Util类的情况下从数组中删除重复项，但现在我被卡住了

public class RemoveDups{
    public static void main(String[] args) {
        int[] a = { 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 3, 1, 4, 52, 1, 45, };

        int temp;
        for (int i : a) {
            for (int j = 0; j < a.length - 1; j++) {
                if (a[j] > a[j + 1]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
        a = removeDups(a);
        for (int i : a) {
            System.out.println(i);
        }

    }

    private static int[] removeDups(int[] a) {
        int[] result = new int[a.length];
        int j = 0;
        for (int i : a) {
            if (!isExist(result, i)) {
                result[j++] = i;
            }
        }

        return result;
    }

    private static boolean isExist(int[] result, int i) {
        for (int j : result) {
            if (j == i) {
                return true;
            }
        }
        return false;
    }

}

现在输出

我的问题是

我的代码在0s
我无法理解排序数组如何减少执行时间
有没有办法在不使用Util类的情况下从数组中删除元素我知道一种方法可以将转换数组删除到列表然后删除但是为此我们还需要Util类是否有任何方法可以自己实现。

Answer 1

由于您处理的数字仅限于较小的范围，您可以通过简单的“计数排序”删除重复项：在类似集合的数据结构中标记您找到的数字，然后查看数据结构。一个boolean数组工作正常，为了减少内存使用，您可以创建一个基本的bitset或哈希表。如果n是数组中元素的数量，m是范围的大小，则此算法将具有O（n + m）复杂度。

private static int[] removeDups(int[] a, int maxA) {
    boolean[] present = new boolean[maxA+1];
    int countUnique = 0;
    for (int i : a) {
        if (!present[i]) {
            countUnique++;
            present[i] = true;
        }
    }

    int[] result = new int[countUnique];
    int j = 0;
    for (int i=0; i<present.length; i++) {
        if (present[i]) result[j++] = i;
    }

    return result;
}

我无法理解排序数组如何减少执行时间

在排序数组中，您可以在单次扫描中检测重复项，花费O（n）时间。由于排序比检查每一对更快 - O（n log n）与O（n²）时间复杂度相比 - 对数组进行排序而不是使用朴素算法会更快。

Answer 2

在java中，数组具有固定长度。创建后，其大小无法更改。所以你创建了一个size18的数组。然后在应用逻辑后，一些元素被删除。但阵列大小不会改变。因此，即使重复删除后只有8个元素，其余10个元素将自动填充0以保持大小为18。

解决方案？

将新列表存储在另一个大小为8的数组中（或者其他任何数组，计算新数组应该有多大）
保持一个新变量指向最后一个有效元素的结尾，在这种情况下，索引为52.请注意，数组仍将具有0值，您将不会使用它们。

I am not able to understand how sorting an array can reduce time of execution 什么？如果需要对数组进行排序，则对数组进行排序。没有其他的。某些算法可能需要对数组进行排序，或者如果对数组进行排序可能会更好。取决于您使用阵列的位置。在您的情况下，排序将无济于事。

至于你的最后一个问题，你绝对可以通过搜索一个元素是否存在多次然后删除所有重复项来实现自己的重复删除。

Answer 3

在制作与数组a相同长度的结果数组时因此，即使您只在其中放入唯一的项目，其余的空白项目也会包含重复值，对于int数组为0。
排序对您没有多大帮助，因为您的代码一次又一次地搜索整个数组以获得重复项。你需要改变它的逻辑。
您可以在结果数组中首先为所有数组项添加一些负值-1，然后您可以通过从中删除所有负值来轻松地创建一个新的结果数组，例如finalResult数组，它也可以帮助您删除所有零。

Answer 4

我的代码在0
的情况下不起作用

在您的数组中没有开始的零。但是因为它是int[]，所以在删除重复项后，其余的索引都会填充0。这就是为什么你可以在阵列中看到很多零的原因。要摆脱那些0，你需要创建另一个较小的数组（大小应该等于你在数组中的唯一数字的数量，不包括0）。

如果你可以对数组进行排序（我看到它已经排序），那么你可以将所有的零带到前面或将它们推到最后。基于此，您可以迭代数组并从数组中的实际值开始处获取索引。然后，您可以使用Arrays.copyOfRange(array, from, to)仅使用所需元素创建数组的副本。

Answer 5

试试这个

 package naveed.workingfiles;



public class RemoveDups {
    public static void main(String[] args) {
        int[] a = { 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 3, 1, 4, 52, 1, 45, };
        removeDups(a);
    }

private static void removeDups(int[] a) {
    int[] result = new int[a.length];
    int j = 0;
    int count = 0;
    for (int i : a) {
        if (!isExist(result, i)) {
            result[j++] = i;
            count++;
        }
    }
    System.out.println(count + "_____________");
    for (int i=0;i<count;i++) {
        System.out.println(result[i]);
    }

    // return result;
}

private static boolean isExist(int[] result, int i) {
    for (int j : result) {
        if (j == i) {
            return true;
        }
    }
    return false;
}

}

Answer 6

public class RemoveDups {
    public static void main(String[] args) {
        int[] a = { 1, 2, 0, 3, 1,0, 3, 6, 2};
        removeDups(a);
    }

private static void removeDups(int[] a) {
    int[] result = new int[a.length];
    int j = 0;
    int count = 0;
    boolean zeroExist = false;
    for (int i : a) {
        if(i==0 && !zeroExist){
            result[j++] = i;
            zeroExist = true;
            count++;
        }
        if (!isExist(result, i)) {
            result[j++] = i;
            count++;
        }
    }
    System.out.println(count + "_____________");
    for (int i=0;i<count;i++) {
        System.out.println(result[i]);
    }

    // return result;
}

private static boolean isExist(int[] result, int i) {

    for (int j : result) {
        if (j == i) {
            return true;
        }
    }
    return false;
}
}
// It works even Array contains 'Zero'

Answer 7

class Lab2 {
public static void main(String[] args) {
    int[] a = { 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 3, 1, 4, 52, 1, 45 };
    removeDups(a);
}

private static void removeDups(int[] a) {
    int[] result = new int[a.length];
    int j = 0;
    int count = 0;
    for (int i : a) {
        if (!isExist(result, i)) {
            result[j++] = i;
            count++;
        }
    }
    System.out.println(count + "_____________");
    for (int i = 0; i < count; i++) {
        System.out.println(result[i]);
    }
}

private static boolean isExist(int[] result, int i) {
    for (int j : result) {
        if (j == i) {
            return true;
        }
    }
    return false;
}
}

在不使用Util类的情况下从数组中删除重复项

7 个答案: