调用递归函数时阶乘方法出现java.lang.StackOverflowError问题求助

核心问题1：阶乘函数完全冗余且存在溢出/栈风险 #

你代码里用阶乘计算mix完全是多此一举，factorial(n)/(2*factorial(n-2))等价于n*(n-1)/2（组合数C(n,2)），直接用公式计算就行。用阶乘的问题在于：

• 当数组长度n稍大（比如n=21），factorial(21)会超出long的取值范围，导致数值溢出，算出错误的mix值。
• 递归调用阶乘本身会占用栈空间，再加上deleteRepeated的递归调用，会快速耗尽栈内存，引发栈溢出错误（也就是你看到的阶乘return语句报错）。

核心问题2：deleteRepeated递归逻辑无效 #

递归调用deleteRepeated(newArr, newArr2)后，你没有返回这个递归的结果，而是直接返回原来的newArr，导致递归操作完全白做，还会反复调用repeated，进一步加剧阶乘的调用次数。

核心问题3：repeated函数统计重复次数逻辑混乱 #

原代码里a != j的判断逻辑错误，无法正确统计重复元素数量，会导致rep值计算错误，进而影响新数组的长度和去重流程。

修复后的代码 #

import java.util.Scanner;

public class ex9 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }
        int[] finalArr = deleteRepeated(arr);
        for (int a : finalArr) {
            System.out.println(a);
        }
    }

    // 正确统计重复元素数量：总长度减去不重复元素数
    public static int countDuplicates(int[] arr) {
        if (arr.length == 0) return 0;
        int uniqueCount = 0;
        boolean[] isUnique = new boolean[arr.length];
        for (int i = 0; i < arr.length; i++) {
            boolean duplicate = false;
            for (int j = 0; j < i; j++) {
                if (arr[i] == arr[j]) {
                    duplicate = true;
                    break;
                }
            }
            if (!duplicate) {
                uniqueCount++;
            }
        }
        return arr.length - uniqueCount;
    }

    // 简化去重逻辑，避免无效递归
    public static int[] deleteRepeated(int[] arr) {
        int uniqueCount = arr.length - countDuplicates(arr);
        int[] newArr = new int[uniqueCount];
        int index = 0;
        for (int num : arr) {
            boolean exists = false;
            for (int i = 0; i < index; i++) {
                if (newArr[i] == num) {
                    exists = true;
                    break;
                }
            }
            if (!exists) {
                newArr[index++] = num;
            }
        }
        return newArr;
    }
}

更高效的优化方案（用集合类） #

如果允许使用Java集合，用HashSet去重会更简洁高效：

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

public class ex9 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < n; i++) {
            set.add(sc.nextInt());
        }
        for (int num : set) {
            System.out.println(num);
        }
    }
}

内容的提问来源于stack exchange，提问作者457r4