递归方法如何计算数组中有多少个不同的数字？ 【JAVA]

Question

我需要编写一个递归函数来计算数组中有多少不同的值，并且可以在其中显示的唯一值是0-9。

例如，对于以下数组：

{   { 1, 5, 4, 3 }, 
    { 4, 3, 2, 1 },     
    { 4, 5, 1, 4 },
    { 1, 4, 3, 2 }
};

该函数将返回5，因为此数组中出现的唯一值是：1,2,3,4,5

这就是我到目前为止所尝试的内容我不明白如何在不使用for的情况下推广索引

public static int numOfColors(int[][] map) { 
    int i=0;
    int j=0;
    int colors=0;
    int contains=map[i][j];
    if (map == null ) { 
        return 0;
    } else if (map[i][j] != 0&&map[i][j]!=contains) { 
        colors ++;
    }
    return numOfColors(map) + 1;
}

Answer 1

如果您有一个类似：int numbers [] []的数组，您可以执行类似

的操作

public int getNUnique(int[][] numbers) {
     int usedNumbers[10];
     boolean found=false;
     for(int i=0, i<numbers.lenght, i++) {
         for(int j=0, i<numbers[].lenght, j++) {
              for(int x=0, x<usedNumbers.lenght, X++) {
                   if(numbers[i][j]==usedNumbers[x]) {
                       found=true;
                   }
                   if(!found) {
                       usedNumbers[usedNumbers.lenght]=numbers[i][j];
                   }
              }
         }
         return usedNumbers.length
     }

Answer 2

递归调用需要另一个参数：这是您已经看过的一组整数。或者您可以使用BitSet，甚至是字符串，因为您被限制为单个数字。

至于推进索引，您可以传入两个参数，表示行和列，或者您可以使用div（/）和mod（％）策略从单个索引参数计算行和列。

最后，您可以考虑完全不需要索引，只需传入迭代器而不是数组（尽管将迭代器传递给递归调用的想法看起来很奇怪）：

public static int numColors(PrimitiveIterator.OfInt iter, BitSet seen) {
    if(!iter.hasNext())
        return seen.cardinality();
    seen.set(iter.nextInt());
    return numColors(iter, seen);
}
public static void main(String[] args) {
    int[][] arr = {
        { 1, 5, 4, 3 }, 
        { 4, 3, 2, 1 },     
        { 4, 5, 1, 4 },
        { 1, 4, 3, 2 }};
    PrimitiveIterator.OfInt iter  = Arrays.stream(arr).flatMapToInt(Arrays::stream).iterator();
    System.out.println(numColors(iter, new BitSet()));
}

根据要求，这里有一个更愚蠢的＆＃34;的方法：

public class SampleJava {
private static final int MAX_COLORS = 10;
public static int numColors(int[][] arr, int row, int column, int[] seen) {
    if(row == arr.length) // end of rows
        return 0; // done
    if(column == arr[row].length) // end of column
        return numColors(arr, row + 1, 0, seen); // advance to next row
    seen[arr[row][column]]++; // increment the "seen" count for this color 
    if(seen[arr[row][column]] == 1) // are we seeing a new color?
        return 1 + numColors(arr, row, column + 1, seen); // yes. next column
    return 0 + numColors(arr, row, column + 1, seen); // no. next column
}
public static void main(String[] args) {
    int[][] arr = {
        { 1, 5, 4, 3 }, 
        { 4, 3, 2, 1 },     
        { 4, 5, 1, 4 },
        { 1, 4, 3, 2 }};
    System.out.println(numColors(arr, 0, 0, new int[MAX_COLORS]));
}
}

Answer 3

正如其他人建议的那样，你需要一个超出范围的元素，它的生命周期与你正在使用的递归函数无关，以保持你访问过的颜色（数字）。