使用递归实现整数命名嵌套文件夹结构生成与计数问题求助

我正在攻读语言学博士学位，希望用递归编程方法作为平行参照可视化某一过程，递归在此处十分重要，因为本次研究需要对比编程与语言学两个领域的递归概念差异。

功能规则 #

需要实现的嵌套文件夹生成逻辑遵循以下规则：

• 所有顶层文件夹名称为1到999之间的随机整数（数值过大曾触发Stack Overflow错误，但原有实现本身也存在缺陷）
• 每个文件夹包含3个子文件夹，名称分别为父文件夹数值的2倍、3倍、4倍
• 上述命名规则对所有层级的子文件夹生效，直到子文件夹名称超过999为止
• 程序需要统计生成的所有文件夹（对应整数）的总数量

原有实现问题 #

尝试了多次但实现都存在问题，第一个版本如下：
此处numbers是类的static变量（列表类型），但希望能找到不需要使用静态变量的解决方案。

public static void countFolders(int max, int currentAmount, int originalAmount, int index) {
    int[] evenMultipliers = new int[]{2, 3, 4};
    if (originalAmount >= max){
        return;
    }
    if (currentAmount < max){
      numbers.add(currentAmount);
    }
    if (index >= evenMultipliers.length) {
      countFolders(max, originalAmount, originalAmount, 0);
    }else if (evenMultipliers[index] * currentAmount > max) {
      countFolders(max, originalAmount + 1, originalAmount + 1, 0);
    }else{
      countFolders(max, currentAmount * evenMultipliers[index], originalAmount, index + 1);
    }
}

原有递归逻辑没有正确遍历每个父节点的所有三个子节点，同时将顶层遍历和子节点递归耦合在一起导致逻辑混乱，不确定该如何追踪上一级文件夹的名称，试过包括foreach循环内递归在内的多种方案都没能顺利实现。

测试用例说明 #

此处用A代表顶层文件夹、B代表A的子文件夹、C代表B的子文件夹：

1. max=4场景
   现有代码输出：[1, 2, 2, 3]
   预期输出：[1, 2, 2, 3, 3]（顺序无要求）
   对应结构：

   1(A) -> 2(B) 和 3(B)
   2(A)
   3(A)

2. max=5场景
   现有代码输出：[1, 2, 2, 4, 3, 4]
   预期输出：[1, 2, 3, 4, 4, 2, 4, 3, 4]（顺序无要求）
   对应结构：

   1(A) -> 2(B)、3(B)、4(B)，其中2(B)还可以生成4(C)
   2(A) -> 4(B)
   3(A)
   4(A)

另一个基于循环的粗糙实现仅完成了乘2、乘3的逻辑，扩展性差：

public static void countFoldersNew(int max) {
    int actualAmount;
    for (int i = 1; i < max; i++) {
      actualAmount = i;
      numbers.add(actualAmount);
      int temp = actualAmount;

      while (actualAmount * 2 < max) {
        actualAmount = actualAmount * 2;
        numbers.add(actualAmount);
        actualAmount = temp;
        while (actualAmount * 3 < max){
          actualAmount = actualAmount * 3;
          numbers.add(actualAmount);
          if (actualAmount * 2 < max){
            actualAmount = actualAmount * 2;
            numbers.add(actualAmount);
            actualAmount = actualAmount / 2;
            if (actualAmount * 3 < max){
              actualAmount = actualAmount * 3;
              numbers.add(actualAmount);
            }
          }

        }
        actualAmount = temp * 2;
        temp = temp *2;
      }
    }
}

解决方法 #

可以把逻辑拆分为两部分：1. 遍历所有顶层节点；2. 对每个节点递归生成所有符合规则的子节点，通过参数传递或者返回值累计结果，不需要使用静态变量。

完整实现代码 #

import java.util.ArrayList;
import java.util.List;

public class FolderGenerator {
    // 对外入口：返回所有符合要求的文件夹列表
    public static List<Integer> generateFolders(int max) {
        List<Integer> result = new ArrayList<>();
        // 遍历所有顶层文件夹 1到max-1
        for (int top = 1; top < max; top++) {
            result.add(top);
            // 递归生成当前顶层文件夹的所有子文件夹
            generateSubFolders(top, max, result);
        }
        return result;
    }

    // 递归生成子文件夹的内部方法
    private static void generateSubFolders(int parent, int max, List<Integer> result) {
        int[] multipliers = {2,3,4};
        for (int m : multipliers) {
            int child = parent * m;
            if (child < max) {
                result.add(child);
                // 继续递归生成当前子节点的子节点
                generateSubFolders(child, max, result);
            }
        }
    }

    // 仅需要统计数量时可以用这个方法，不需要额外存储列表
    public static int countFolders(int max) {
        int count = 0;
        for (int top = 1; top < max; top++) {
            count += 1 + countSubFolders(top, max);
        }
        return count;
    }

    private static int countSubFolders(int parent, int max) {
        int subCount = 0;
        int[] multipliers = {2,3,4};
        for (int m : multipliers) {
            int child = parent * m;
            if (child < max) {
                subCount += 1 + countSubFolders(child, max);
            }
        }
        return subCount;
    }

    // 测试验证
    public static void main(String[] args) {
        System.out.println(generateFolders(4)); // 输出包含所有预期元素：[1,2,3,2,3]
        System.out.println(countFolders(4)); // 输出5，符合预期数量
        System.out.println(generateFolders(5)); // 输出包含所有预期元素
        System.out.println(countFolders(5)); // 输出9，符合预期数量
    }
}

实现说明 #

1. 逻辑拆分清晰：顶层遍历和子节点递归完全分开，不需要额外参数记录当前遍历的顶层节点索引，代码可读性高
2. 无静态变量：结果列表/计数通过参数传递或者返回值累计，线程安全
3. 不会出现栈溢出：数值最大为999时，递归深度最多是log2(999)≈10层，远低于JVM默认栈深度
4. 该实现的递归逻辑属于典型的结构递归，每个节点的处理规则完全一致且可无限嵌套（此处受max值限制终止），和语言学中句法结构的递归规则逻辑高度同构，适配你做两个领域递归概念对比的研究需求。

内容的提问来源于stack exchange，提问作者Pityu Szívós