Java 查找数组中有多少不同的值

假设我有一个长度为

n

的数组，其中只能出现0-9的值。我想创建一个递归函数，返回数组中不同值的数目

例如，对于以下数组：

int[]arr={0,1,1,2,1,0,1}

-->函数将返回

3

，因为此数组中出现的唯一值是

0

、

1

和

2

函数接收一个int数组并返回int 大概是这样的：

int numOfValues(int[] arr)

试着这样做：

public int myFunc(int[] array) {

     Set<Integer> set = new HashSet<Integer>(array.length);
     for (int i : array) {
        set.add(i);
     }
     return set.size();
 }

public int myFunc（int[]数组）{
Set=newhashset（array.length）；
for（int i:array）{
增加（i）；
}
返回set.size（）；
}

---

i、 e，在集合中添加数组元素，然后您可以返回集合的大小。

如果您使用的是Java 8，您可以使用一个简单的单行程序：

private static int numOfValues(int[] arr) {
    return (int) Arrays.stream(arr).distinct().count();
}

返回由数组元素组成的数组。然后，返回一个仅包含此流的不同元素的

IntStream

。最后，返回此流中的元素数

请注意，

count（）

返回一个

long

，因此我们需要将其转换为

int

---

如果你真的想要一个递归的解决方案，你可以考虑下面的算法：

• 如果输入数组的长度为1，则元素是不同的，因此答案为1
• 否则，让我们删除第一个元素并计算这个新数组上不同元素的数量（通过递归调用）。然后，如果第一个元素包含在这个新数组中，我们将不再对它进行计数，否则我们将进行计数，然后添加1

这将为您提供足够的洞察力，以便在代码中实现这一点。

public int f（int[]数组）{
public int f(int[] array) {
   int[] counts = new int[10];
   int distinct = 0;
   for(int i = 0; i< array.length; i++) counts[array[i]]++;
   for(int i = 0; i< counts.length; i++) if(counts[array[i]]!=0) distinct++;
   return distinct;

 }

int[]计数=新的int[10]；
int=0；
对于（int i=0；i

---

您甚至可以更改代码以获取每个值的出现次数。

您可以尝试以下代码片段

Integer[] arr = {0,1,1,2,1,0,1};
Set<Integer> s = new HashSet<Integer>(Arrays.asList(arr));

Integer[]arr={0,1,1,2,1,0,1}；
Set s=新的HashSet（Arrays.asList（arr））；

---

输出：[0，1，2]

当您要求递归实现时，这是一种不好的方法。我说不好是因为递归不是解决这个问题的最好方法。还有其他更简单的方法。当您希望基于该函数先前生成的项计算下一项时，通常使用递归。比如斐波那契级数

当然，在使用此函数之前必须克隆数组，否则会更改原始数组（使用

countDistinct（arr.clone（），0）调用它；

）

公共静态int countDistinct（int[]arr，最终int索引）{
布尔包含=假；
if（arr==null | | index==arr.length）{
返回0；
}否则如果（arr.length==1）{
返回1；
}否则如果（arr[索引]！=-1）{
包含=真；
对于（int i=索引+1；i

int numOfValues（int[]arr）{
布尔值[]c=新的布尔值[10]；
整数计数=0；
对于（int i=0；i

您尝试了什么？将数组放入

集合

中，然后检查

集合的大小

此特定任务对于递归来说是一个非常糟糕的候选任务。你不能从一个切片的两半中不同项目的数量推断出切片中不同项目的数量。不幸的是，除了不起作用的草稿之外，我什么都没有。递归对我来说并不清楚，我只是想知道这个问题是否可以用递归来解决。基本情况是，如果数组为null，则返回0；如果array.length为1，则返回1。现在我正试图找出第三种情况的循环，以及你如何总结。他不是在要求递归函数吗？@Ata是的，我添加了一个递归解决方案的算法。我没有提供代码，只是提供了想法。这值得否决吗？现在不行，但我没有看到递归实现。@我最初发布了代码，但最终删除了它（如果需要，可以在修订历史中看到），但我认为OP可以通过自己实现来了解更多。用英语编写的算法非常简单。你会考虑取消你的投票吗？

public static int countDistinct(int[] arr, final int index) {
    boolean contains = false;

    if (arr == null || index == arr.length) {
        return 0;
    } else if (arr.length == 1) {
        return 1;
    } else if (arr[index] != -1) {
        contains = true;
        for (int i = index + 1; i < arr.length; i++) {
            if (arr[index] == arr[i]) {
                arr[i] = -1;
            }
        }
    }

    return countDistinct(arr, index + 1) + (contains ? 1 : 0);
}

int numOfValues(int[]  arr)  {
    boolean[]  c = new boolean[10];
    int count = 0;
    for(int i =0; i < arr.length; i++) {
        if(!c[arr[i]]) {
            c[arr[i]] = true;
            count++;
        } 
    } 
    return count;
}