Java 数组中唯一元素的数量

这是作业

我只是想知道错误是什么。 我试图比较数组中的每个元素，并返回唯一元素的数量。我得到一个错误？ 有人能帮我找出错误是什么吗

public static int numUnique (double[] list) {
    int index = 1;
    int result = 0;
    if(list.length == 0){return 0;}

    while(index < list.length) {
        if(list[index] != list[index - 1]) {
            result = result + 1;
        }
        index++;
    }
    return result;
}

---

通过将

index

的初始值设置为1，您的循环将跳过0元素，因为您可以保证它是唯一的（因为您尚未查看任何元素）。既然如此，您也应该将

result

初始化为1。

通过将

index

的初始值设置为1，您的循环将跳过0元素，因为您可以保证它是唯一的（因为您还没有查看任何元素）。既然是这样，您也应该将

结果
初始化为1。
逻辑有缺陷，您只需将每个元素与之前的元素进行比较，并计算它们的差异次数

在您的示例中，这似乎是可行的，因为所有重复项都是相邻的，但您的描述并没有指定始终是这种情况

您希望将每个元素与之前的所有其他元素进行比较，并计算它们唯一的次数：

int uniques = 0;
for(int i = 0 ; i < list.length ; i++) {
    boolean found = false;
    for(int j = 0 ; j < i ; j++) {
        if(list[i] == list[j]) {
            found = true;
            break;
        }
    }
    uniques += found ? 0 : 1;
}

int uniques=0；
for（int i=0；i
逻辑有缺陷，您只需将每个元素与之前的元素进行比较，并计算它们的差异次数

在您的示例中，这似乎是可行的，因为所有重复项都是相邻的，但您的描述并没有指定始终是这种情况

您希望将每个元素与之前的所有其他元素进行比较，并计算它们唯一的次数：

int uniques = 0;
for(int i = 0 ; i < list.length ; i++) {
    boolean found = false;
    for(int j = 0 ; j < i ; j++) {
        if(list[i] == list[j]) {
            found = true;
            break;
        }
    }
    uniques += found ? 0 : 1;
}

int uniques=0；
for（int i=0；i
试试这个：

代码：

Failed numUnique([11]): Expecting (1) Actual (0)

Failed numUnique([11 11 11 11]): Expecting (1) Actual (0)

Failed numUnique([11 21 31 41]): Expecting (4) Actual (3)

Failed numUnique([11 11 11 21 31 31 31 31 41]): Expecting (4) Actual (3)

Failed numUnique([11 21 21 21 31 41 41 41 41]): Expecting (4) Actual (3)

Failed numUnique([11 11 21 21 21 31 31 41 41 41 41]): Expecting (4) Actual (3)

public class uniqueElements {
    public static void main(String args[]){
        double[] list = new double[8];
        list[0] = 1.1;
        list[1] = 2.4;
        list[2] = 3.5;
        list[3] = 1.1;
        list[4] = 2.4;
        list[5] = 2.4;
        list[6] = 3.3;
        list[7] = 3.5;
        System.out.println(numUnique(list));
    }

    public static int numUnique (double[] list) {
        int numUniqueCounter = 0;
        A: 
            for(int i=0;i<list.length;i++){
                double currentNumber = list[i];         
                for(int j=i+1;j<list.length;j++){
                    if(list[j] == currentNumber){                               
                        continue A;                     
                    }
                }               
                numUniqueCounter++;
            }
        return numUniqueCounter;
    }
}

4

试试这个：

代码：

Failed numUnique([11]): Expecting (1) Actual (0)

Failed numUnique([11 11 11 11]): Expecting (1) Actual (0)

Failed numUnique([11 21 31 41]): Expecting (4) Actual (3)

Failed numUnique([11 11 11 21 31 31 31 31 41]): Expecting (4) Actual (3)

Failed numUnique([11 21 21 21 31 41 41 41 41]): Expecting (4) Actual (3)

Failed numUnique([11 11 21 21 21 31 31 41 41 41 41]): Expecting (4) Actual (3)

public class uniqueElements {
    public static void main(String args[]){
        double[] list = new double[8];
        list[0] = 1.1;
        list[1] = 2.4;
        list[2] = 3.5;
        list[3] = 1.1;
        list[4] = 2.4;
        list[5] = 2.4;
        list[6] = 3.3;
        list[7] = 3.5;
        System.out.println(numUnique(list));
    }

    public static int numUnique (double[] list) {
        int numUniqueCounter = 0;
        A: 
            for(int i=0;i<list.length;i++){
                double currentNumber = list[i];         
                for(int j=i+1;j<list.length;j++){
                    if(list[j] == currentNumber){                               
                        continue A;                     
                    }
                }               
                numUniqueCounter++;
            }
        return numUniqueCounter;
    }
}

4

改用这种方法，效率高，并且通过单次传递，您可以确定唯一的元素

public static int numUnique(double[] list) {
        Set<Double> uniqueSet = new HashSet<>();
        for (int i = 0; i < list.length; i++) {
            uniqueSet.add(list[i]);
        }
        return uniqueSet.size();
    }

public static int numUnique（双[]列表）{
Set uniqueSet=new HashSet（）；
for（int i=0；i
使用此选项，效率更高，通过单次传递，您可以确定唯一的元素

public static int numUnique(double[] list) {
        Set<Double> uniqueSet = new HashSet<>();
        for (int i = 0; i < list.length; i++) {
            uniqueSet.add(list[i]);
        }
        return uniqueSet.size();
    }

public static int numUnique（双[]列表）{
Set uniqueSet=new HashSet（）；
for（int i=0；i
我无法抗拒：

   public static int numUnique (Double[] list) {
    return new HashSet<>(Arrays.asList(list)).size();
   }

public static int numUnique（双[]列表）{
返回新的HashSet（Arrays.asList（list））.size（）；
}

不是从double[]到double[]的更改

您应该尽量避免手动循环。正如您所发现的，循环是有缺陷的。学会使用收藏。
我无法抗拒：

   public static int numUnique (Double[] list) {
    return new HashSet<>(Arrays.asList(list)).size();
   }

public static int numUnique（双[]列表）{
返回新的HashSet（Arrays.asList（list））.size（）；
}

不是从double[]到double[]的更改

您应该尽量避免手动循环。正如您所发现的，循环是有缺陷的。学习使用集合。
如果为0，为什么不简单地用1初始化
结果
？哦，它起作用了！但是为什么呢？因为你基本上是在计算不同值之间的转换，转换的数量总是比不同值的数量少一个。为什么不简单地初始化
结果
，如果是0，那么就用1来代替呢？哦，这很有效！但是为什么？因为基本上是计算不同值之间的转换，所以转换的数量总是比不同值的数量少一个。更好的解决方案是预先对数组进行排序，这样就可以使用O（n）而不是O（n^2）算法。这将是O（n log n）计算排序。但我试图尊重OP的策略：“我试图将数组中的每个元素相互比较，并返回唯一元素的数量。”更好的解决方案是预先对数组进行排序，这样就可以使用O（n）而不是O（n^2）算法。这将是O（n logn）计算排序。但是我试着尊重OP的策略：“我试着比较数组中的每个元素，并返回唯一元素的数量。”。。。我不能使用任何集合！这是做家庭作业的唯一方法。谢谢分享！哎哟那么你注定要做一个双循环。问题中的代码仅与前面的元素进行比较。你需要检查每一个元素。嗯。。。我不能使用任何集合！这是做家庭作业的唯一方法。谢谢分享！哎哟那么你注定要做一个双循环。问题中的代码仅与前面的元素进行比较。您需要检查每个元素。谢谢您的回答！现在有道理了，谢谢。谢谢你的回答！现在有道理了，谢谢。