Question

我正在创建一个文件夹迷宫创建者（在另一个文件夹中创建一个文件夹）以获得一些乐趣，但它似乎比我最初期望的要复杂得多。我认为例子会更好地解释这一点。基本上我想这样做

for (int i = 0; i < iterations; i++)
{
    Directory.CreateDirectory(dirName + i);
    for (int ii = 0; ii < iterations; ii++)
    {
        Directory.CreateDirectory(Path.Combine(dirName + i, dirName + ii));
        for (int iii = 0; iii < iterations; iii++)
        {
            Directory.CreateDirectory(Path.Combine(dirName + i, dirName + ii, dirName + iii));
            for (int iv = 0; iv < iterations; iv++)
            {
                Directory.CreateDirectory(Path.Combine(dirName + i, dirName + ii, dirName + iii, dirName + iv));
            }
        }
    }
}

但是，我希望用户能够在运行时设置嵌套循环的数量，而不是设置嵌套循环的数量。所以在程序员的帮助下，我得到了这个。

private void Recursion(int depth)
{
    if (depth >= depthMax)
        return;

    //string[] folderPlace = new string[depthMax + 1];
    //for (int ii = 0; ii < depthMax; ii++)
    //{
    //    if (ii <= depth)
    //    {
    //        folderPlace[ii] = dirName;
    //    }
    //   else
    //    {
    //        folderPlace[ii] = "";
    //    }
    //}

    for (int i = 0; i < iterations; i++)
    {
        folderPlace[1] = dirName + i;
        Directory.CreateDirectory(dirName + i);
        Recursion(depth + 1);
    }

}

但我似乎无法找到一种方法来在数组中获得正确的路径，因此每个文件夹都应该自动进入...

感谢任何帮助，谢谢！

Answer 1

我建议你看一下这个例子：

public partial class Form1 : Form
{
    const string DirName = "Mydir";
    const string RootFolder = @"c:\test";

    public Form1()
    {

        CreateDirectories(0, 5, 5, RootFolder);


        InitializeComponent();
    }

    public void CreateDirectories(int currentDepth, int maxDepth, int iterations, string root)
    {
        if (currentDepth > maxDepth)
        {
            return;
        }
        for (var i = 0; i < iterations; i++)
        {
            var currentDirName = Path.Combine(root, DirName + i.ToString());
            Directory.CreateDirectory(currentDirName);
            CreateDirectories(currentDepth + 1, maxDepth, iterations, currentDirName);
        }
    }
}

Answer 2

基本上，您需要了解迭代和递归之间的区别。

迭代是所有类型的循环（例如for，foreach）。递归意味着一个方法调用它自己，并提供某种退出条件，以防止无休止的exectution。

递归允许您定义操作的嵌套级别，但被认为较慢。迭代只允许您定义一次迭代处理的循环数，但不能定义硬编码类型的嵌套级别（第一个示例中的3个嵌套循环）。与递归相比，IMO迭代更容易理解和开发。

您的特定问题需要一个组合解决方案，其中一个方法在迭代循环内递归调用它。

一个可能的解决方案如下所示（最有趣的部分是Magic(int, string) - 方法，其中我添加了一些注释以指出我上面解释过的事例的例子）：

    private class FolderMaze
    {
        private const string SubDirectoryName = "Maze_";
        private readonly string baseDirectory;
        private readonly int depth;
        private readonly int nFoldersPerIteration;

        public FolderMaze(string baseDirectory, int depth, int nFoldersPerIteration)
        {
            this.baseDirectory = baseDirectory;
            this.depth = depth;
            this.nFoldersPerIteration = nFoldersPerIteration;
        }

        public void Magic()
        {
            this.Magic(0, this.baseDirectory);
        }

        private void Magic(int iteration, string iterationPath)
        {
            // exit condition
            if (iteration >= this.depth)
            {
                return;
            }

            // Iteration
            for (int i = 0; i < this.nFoldersPerIteration; i++)
            {
                var currentPath = Path.Combine(iterationPath, SubDirectoryName + i);
                Directory.CreateDirectory(currentPath);

                // recursive call to Magic(int string)
                this.Magic(++iteration, currentPath);
            }
        }
    }

您可以这样称呼它：

var maze = new FolderMaze(Environment.CurrentDirectory, 2, 2);
maze.Magic();

我确实把解决方案放在了一个类中，这样你就可以专注于Magic - 方法中的重要事情了，但你也可以将它放在一个单独的方法中，而不是周围的类，就像回答一样由@Jean F。

提供

如何通过循环组合路径

2 个答案: