返回java数组中的唯一数字

我一直在尝试编写代码，在同样具有重复项的排序数组中查找唯一值

到目前为止，我写了：

public static int numUnique (double[] list) {
    int counter = 0;

    if (Array.getLength(list) < 1) {
            return Length.list);
        }
    else{
        for (int i=0; i < Length.list); i++){
            for (int j=i+1; j< Length.list); j++){
                if (list[i] != list[j]){
                    newrArray[i] = list[i];
                    counter++;

                }
            }
        }
    }

    return counter;
}

预期产出：

8

---

我不能使用

HashSet

s或

ArrayList

s。我认为唯一可行的选择是从一个数组复制到另一个数组，然后计算新数组中的内容（假设只有唯一的值复制到新数组中）。

您知道此数组中的最大值吗？如果它足够小，可以创建一个该大小的布尔数组，如果在原始数组中找到该值，则可以将该值设置为true

这就是所谓的

例如：

boolean[] found = new boolean[max];

for(int i : list)
    found[i] = true;
    
int unique = 0;
for(int i = 0; i < found; i++)
    if(found[i]) unique++;

boolean[]found=新的boolean[max]；
用于（int i:列表）
发现[i]=正确；
int unique=0；
for（int i=0；i

如果没有，请计算唯一元素的数量并插入它们

public int uniqueAmount(double[] list) {
    double last = Double.NaN;
    int unique = 0;
    for(int i = 0; i < list.length; i++)
        if(last != (last = list[i]))
            unique++;
    return unique;
}

public double[] uniqueValues(double[] list) {
    int unique = uniqueAmount(list);
    double[] found = new double[unique];
    double last = Double.NaN;
    last = list[0];
    found[0] = last;
    for(int i = 0, index = 1; i < list.length; i++)
        if(last != list[i]) {
            found[index++] = list[i];
            last = list[i];
        }
    return found;
}

public int uniqueAmount（双[]列表）{
double last=double.NaN；
int unique=0；
for（int i=0；i

经过测试，效果良好。

---

如果调用

uniqueAmount

，则返回8；如果调用

uniqueValues

（编辑时要求），则返回数组

[31.0,33.0,46.0,52.0,65.0,66.0,75.0,98.0]

。

您知道此数组中的最大值吗？如果它足够小，可以创建一个该大小的布尔数组，如果在原始数组中找到该值，则可以将该值设置为true

这就是所谓的

例如：

boolean[] found = new boolean[max];

for(int i : list)
    found[i] = true;
    
int unique = 0;
for(int i = 0; i < found; i++)
    if(found[i]) unique++;

boolean[]found=新的boolean[max]；
用于（int i:列表）
发现[i]=正确；
int unique=0；
for（int i=0；i

如果没有，请计算唯一元素的数量并插入它们

public int uniqueAmount(double[] list) {
    double last = Double.NaN;
    int unique = 0;
    for(int i = 0; i < list.length; i++)
        if(last != (last = list[i]))
            unique++;
    return unique;
}

public double[] uniqueValues(double[] list) {
    int unique = uniqueAmount(list);
    double[] found = new double[unique];
    double last = Double.NaN;
    last = list[0];
    found[0] = last;
    for(int i = 0, index = 1; i < list.length; i++)
        if(last != list[i]) {
            found[index++] = list[i];
            last = list[i];
        }
    return found;
}

public int uniqueAmount（双[]列表）{
double last=double.NaN；
int unique=0；
for（int i=0；i

经过测试，效果良好。

---

如果调用

uniqueAmount

返回8，如果调用

uniqueValues

（根据编辑中的要求），则返回数组

[31.0,33.0,46.0,52.0,65.0,66.0,75.0,98.0]

。

您的操作太复杂了：

由于数组已排序，因此只需检查数组中某个值和它前面的值是否相等。如果不增加计数，则继续下一个值：

int uniqueNum(double[] d){
    if(d.length < 2)
        return d.length;

    int count = 0;

    //choose an initial previous value that differs from the first element in the array
    double prev = (d[0] == 1.0 ? 2.0 : 1.0);
    for(double v : d){
        //ignore duplicate values
        if(v == prev)
            continue;

        count++;
        prev = v;
    }

    return count;
}

int uniqueNum（双[]d）{
如果（d.长度<2）
返回d.length；
整数计数=0；
//选择与数组中第一个元素不同的上一个初始值
双上指数=（d[0]==1.0-2.0:1.0）；
用于（双v:d）{
//忽略重复的值
如果（v==prev）
继续；
计数++；
prev=v；
}
返回计数；
}

这是因为在排序数组中，重复的值总是会形成一个序列

代码不起作用的原因：

for (int i=0; i < Array.getLength(list); i++){
    for (int j=i+1; j< Array.getLength(list); j++){
        if (list[i] != list[j]){
            catcherArray[i] = list[i];
            counter++;
        }
    }
}

for（int i=0；i

---

这段代码不会计算数组中不同值的数量，但对于数组中的任何索引，都会计算与该索引中的值不同的值的数量。

您将事情复杂化了很多：

由于数组已排序，因此只需检查数组中某个值和它前面的值是否相等。如果不增加计数，则继续下一个值：

int uniqueNum(double[] d){
    if(d.length < 2)
        return d.length;

    int count = 0;

    //choose an initial previous value that differs from the first element in the array
    double prev = (d[0] == 1.0 ? 2.0 : 1.0);
    for(double v : d){
        //ignore duplicate values
        if(v == prev)
            continue;

        count++;
        prev = v;
    }

    return count;
}

int uniqueNum（双[]d）{
如果（d.长度<2）
返回d.length；
整数计数=0；
//选择与数组中第一个元素不同的上一个初始值
双上指数=（d[0]==1.0-2.0:1.0）；
用于（双v:d）{
//忽略重复的值
如果（v==prev）
继续；
计数++；
prev=v；
}
返回计数；
}

这是因为在排序数组中，重复的值总是会形成一个序列

代码不起作用的原因：

for (int i=0; i < Array.getLength(list); i++){
    for (int j=i+1; j< Array.getLength(list); j++){
        if (list[i] != list[j]){
            catcherArray[i] = list[i];
            counter++;
        }
    }
}

for（int i=0；i

---

此代码不计算数组中不同值的数量，但对于数组中的任何索引，则计算与该索引处的值不同的值的数量。

无需复制任何数组或使用额外的数据结构，因为数组是按排序顺序提供的。这意味着当列表[i]！=列表[i+1]阵列中将不再出现任何事件。这对您有很大帮助，并允许您对阵列进行一次遍历以找到解决方案。这是一个没有额外集合的简单解决方案

public static int FindTotalUniqueNumbers(double[] list)
{
    if(list.length < 0)
        return 0;

    double currentNumber = list[0];
    int currentCount = 1;
    for(int i = 1; i < list.length; i++)
    {
        if(list[i] != currentNumber)
        {
            currentCount++;
            currentNumber = list[i];
        }
    }

    return currentCount;
}

输出

8

---

不需要复制任何数组或使用额外的数据结构，因为数组是按排序顺序提供的。这意味着当列表[i]！=列表[i+1]阵列中将不再出现任何事件。这对你有很大的帮助，让你可以做一次简单的旅行

public static int numUnique(double[] list) {
    double[] tempArray = new double[0];
    int index;
    for (double element : list) {
        boolean matchFound = false;
        if (tempArray.length > 0) {
            for (double d : tempArray) {
                if (d == element) {
                    matchFound = true;

                    break;
                }
            }
        }
        if (!matchFound) {
            tempArray = Arrays.copyOf(tempArray, tempArray.length + 1);
            tempArray[tempArray.length - 1] = element;
        }
    }
    return tempArray.length;
}

double[] doubleArray ={31.0, 31.0, 31.0, 31.0, 33.0, 46.0, 46.0, 46.0, 46.0, 46.0, 52.0, 65.0, 65.0, 66.0, 75.0, 98.0, 98.0};
long count = DoubleStream.of(doubleArray).distinct().count();
System.out.println(count);

8

int[] intArray = {31, 31, 31, 31, 33, 46, 46, 46, 46, 46, 52, 65, 65, 66, 75, 98, 98};
long count = IntStream.of(intArray).distinct().count();
System.out.println(count);

8