递归函数JAVA

我试图用Java编写递归函数

该函数需要为我计算数组中的所有衍射值

i、 e

递归函数返回3（1,4,3）

这是我需要编写的函数：

int numOfColors(int[][] map) 

我所尝试的：

public static int numOfColors(int[][] arr) {

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

线程“main”java.lang.StackOverflowerr中出现异常

我怎样才能修好它

---

谢谢

我不认为递归在这种情况下是必要的，所以我将解释我将如何处理它。我将arr称为数组A。首先，您创建一个已经看到的数字哈希集，我们将其称为哈希集B。然后，您可以通过数组A循环，处理每个元素。检查哈希集B是否包含该元素。如果是，则继续，如果不是，则将该值添加到哈希集B。在循环之后，返回哈希集B的长度，或者如果要查看唯一值，则返回整个集合

例如：

import java.util.HashSet;

public class Class {
        public static void main(String[] args){
                int[][] A = {{1, 1, 1, 1}, {4, 4, 4, 4}, {3, 3, 1, 1}};
                System.out.println("Number of different values: " + countUniqueVals(A));
        }

        public static int countUniqueVals(int[][] A){
                HashSet<Integer> B = new HashSet<Integer>();
                for (int row = 0; row < A.length; row++)
                        for (int col = 0; col < A[row].length; col++)
                                B.add(A[row][col]);
                return B.size();
        }
}

import java.util.HashSet；
公共课{
公共静态void main（字符串[]args）{
int[]A={{1,1,1,1}，{4,4,4}，{3,3,1,1}；
System.out.println（“不同值的数量：+countUniqueVals（A））；
}
公共静态int countUniqueVals（int[]A）{
HashSet B=新的HashSet（）；
for（int row=0；row

下面是一种使用递归查找唯一值计数的方法，而不使用任何

集合

或

列表

-

package test;

public class Main {

    public static void main(String[] args) {
        int[][] arr = { { 4, 2, 2, 1, 4 }, { 4, 4, 3, 1, 4 }, { 1, 1, 4, 2, 1 }, { 1, 4, 0, 2, 2 }, { 4, 1, 4, 1, 1 } };
        System.out.println(numOfColors(arr));

    }

    public static int numOfColors(int[][] arr) {
        int unique = 0;
        if (arr.length == 0) {
            return unique;
        } else {
            int[] subArr = arr[arr.length - 1];

            outerLoop: for (int i = 0; i < subArr.length; i++) {
                int j = i + 1;
                for (; j < subArr.length; j++) {
                    if (subArr[i] == subArr[j]) {
                        break;
                    }
                }
                if (j == subArr.length) {
                    int k = 0;
                    for (; k < arr.length - 1; k++) {
                        for (int l = 0; l < arr[k].length; l++) {
                            if (subArr[i] == arr[k][l]) {
                                continue outerLoop;
                            }
                        }
                    }
                    if (k == arr.length - 1) {
                        unique++;
                    }
                }
            }
            int[][] dest = new int[arr.length - 1][];
            System.arraycopy(arr, 0, dest, 0, arr.length - 1);
            unique += numOfColors(dest);
            return unique;
        }
    }
}

封装测试；
公共班机{
公共静态void main（字符串[]args）{
int[]arr={{4,2,2,1,4}，{4,4,3,1,4}，{1,1,4,2,1}，{1,4,0,2,2}，{4,1,4,1}；
System.out.println（numofolors（arr））；
}
公共静态int numofolors（int[]arr）{
int unique=0；
如果（arr.length==0）{
返回唯一值；
}否则{
int[]subar=arr[arr.length-1]；
outerLoop:for（int i=0；i

输出
五,

---

注意，这个问题不需要递归就可以很容易地解决。此外，使用

Set

可以简化上述代码，我认为您应该在

Set

中存储唯一值，并根据其大小构建最终结果。以下是众多解决方案中的一个：

package com.company;

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        int[][] map = new int[][] {{1,1,1,1},{4,4,4,4},{3,3,1,1}};

        System.out.println(numOfColors(map));
    }

    public static int numOfColors(int[][] map) {
        HashSet<Integer> result = new HashSet<Integer>();

        numOfColorsImpl(map, 0, result);

        return result.size();
    }

    private static void numOfColorsImpl(int[][] map, int rowIndex, Set<Integer> result) {
        if (rowIndex == map.length)
            return;

        for (int value : map[rowIndex]) {
            result.add(value);
        }

        numOfColorsImpl(map, rowIndex + 1, result);
    }
}

package.com公司；
导入java.util.HashSet；
导入java.util.Set；
公共班机{
公共静态void main（字符串[]args）{
int[][]map=newint[][{{1,1,1}，{4,4,4}，{3,3,1,1}；
System.out.println（numofolors（map））；
}
公共静态int numofolors（int[]map）{
HashSet result=新的HashSet（）；
numOfColorsImpl（map，0，result）；
返回result.size（）；
}
私有静态void numOfColorSimple（int[][]映射，int行索引，设置结果）{
if（rowIndex==map.length）
返回；
for（int值：map[rowIndex]）{
结果：增加（价值）；
}
numOfColorsImpl（映射，行索引+1，结果）；
}
}

您可以使用递归助手函数删除重复项

import java.util.*;

public class Main {
    public static void main(String[] strg) {
        int[][] arr = {{1, 1, 1, 1}, {4, 4, 4, 4}, {3, 3, 1, 1}};
        numOfColors(arr);
    }
    static int numOfColors(int[][] map) {
        ArrayList<Integer> intlist = new ArrayList<Integer>();
        for (int o = 0; o < map.length; o++) {
            for (int n = 0; n < map[o].length; n++) {
                intlist.add(map[o][n]);
            }
        }
        intlist = removeDuplicates(intlist, 0);
        System.out.println(intlist.size()+" " +intlist);
        return intlist.size();
    }
    static ArrayList<Integer> removeDuplicates(ArrayList<Integer> list, int counter) {
        if (list == null) {
            throw new NullPointerException();
        }
        if (counter < list.size()) {
            if (list.contains(list.get(counter))) {
                if (list.lastIndexOf(list.get(counter)) != counter) {
                    list.remove(list.lastIndexOf(list.get(counter)));
                    counter--;
                }
            }
            removeDuplicates(list, ++counter);
        }
        return list;
    }
}

---

递归需要基本情况，即方法应该停止再次调用自身并返回的情况。此代码中没有基本情况。按照编写此代码的方式，您只需计算

arr[0][0]！=arr[0][0]

反复（递归地）。当您递归时，没有任何更改，并且没有真正的基本情况来阻止您（

arr

将不会为null，除非可能在第一次调用时）。如果您的数组为null，这就是为什么会出现这种异常。而且，我认为这不是一个需要递归解决方案的问题。迭代两个数组，并将您找到的所有内容放入一个

集合

似乎是解决此问题最直接的方法。是的，我不知道我的错误，但不知道首先修复它们，这不是递归的。第二，你到底为什么在这里使用

向量？这是一个完全不合适的数据结构，因为a）它是同步的，完全没有必要这样做；b）它是一个类似列表的结构。像
HashSet
这样的
Set
更合适。@jornverne我认为在这种情况下递归是不必要的。@Todd你说得对，一个Set会更好。我会修正它，但我认为向量对于刚开始编码的人来说更容易。谢谢，但事实并非如此recursive@CSharpBeginner您希望它是递归的，有什么原因吗？这看起来不像是递归有用的情况。处理数组的每个元素似乎是一个更简单的解决方案。我已经尝试过运行它，但它没有返回当前答案。我正在尝试使用{4,2,1,4}、{4,4,3,1,4}、{1,1,4,2,1}、{1,4,0,2,2}、{4,1,4,1,1}运行你的解决方案，例外值是5，我得到了NullOfPointExeption，我正在尝试
import java.util.*;

public class Main {
    public static void main(String[] strg) {
        int[][] arr = {{1, 1, 1, 1}, {4, 4, 4, 4}, {3, 3, 1, 1}};
        numOfColors(arr);
    }
    static int numOfColors(int[][] map) {
        ArrayList<Integer> intlist = new ArrayList<Integer>();
        for (int o = 0; o < map.length; o++) {
            for (int n = 0; n < map[o].length; n++) {
                intlist.add(map[o][n]);
            }
        }
        intlist = removeDuplicates(intlist, 0);
        System.out.println(intlist.size()+" " +intlist);
        return intlist.size();
    }
    static ArrayList<Integer> removeDuplicates(ArrayList<Integer> list, int counter) {
        if (list == null) {
            throw new NullPointerException();
        }
        if (counter < list.size()) {
            if (list.contains(list.get(counter))) {
                if (list.lastIndexOf(list.get(counter)) != counter) {
                    list.remove(list.lastIndexOf(list.get(counter)));
                    counter--;
                }
            }
            removeDuplicates(list, ++counter);
        }
        return list;
    }
}

3 [1, 4, 3]