Algorithm 解决方案只能是递归的问题示例

可能重复：

是否存在必须使用递归而无法迭代的问题？例如，删除子文件夹中的文件

public static boolean deleteFile(String sFilePath)
{
  File oFile = new File(sFilePath);
  if(oFile.isDirectory())
  {
    File[] aFiles = oFile.listFiles();
    for(File oFileCur: aFiles)
    {
       deleteFile(oFileCur.getAbsolutePath());
    }
  }
  return oFile.delete();
}

---

我想不出上述代码的迭代版本，因为我们必须事先知道实际存在多少级别的文件夹，如果我们引入一个新的子文件夹，我们将不得不更改代码。是否有可能以这样一种方式生成上述代码的迭代版本，即未来不需要更改代码

您始终可以自己使用堆栈来存储必要的变量，而无需递归调用函数

在这种情况下，我们将对文件树进行深度优先遍历，以便在拥有目录之前先删除“最深”的文件

public static void deleteFile(String sFilePath)
{
  File oFile = new File(sFilePath);
  Stack<File> filesToDelete = new Stack<File>();
  Stack<File> directoriesToDelete = new Stack<File>();

  filesToDelete.push(oFile);

  while (! filesToDelete.empty())
  {
    oFile = filesToDelete.pop();

    if(oFile.isDirectory())
    {
      File[] aFiles = oFile.listFiles();
      for(File oFileCur: aFiles)
      {
        filesToDelete.push(oFileCur);
      } 

      // it's a directory, delete it at the end
      // note that we'll see directories 
      // 'deeper down' later but we'll have
      // to delete them before those 'higher up'
      // so use a stack here to delete them
      // after all non-directories were
      // deleted
      directoriesToDelete.push(oFile);

    }
    else
      // it's a file, delete right now
      oFile.delete();

  }

  // delete the directories
  while (! directories.empty())
    directoriesToDelete.pop().delete();

}

publicstaticvoiddeletefile（字符串sFilePath）
{
fileofile=新文件（sFilePath）；
Stack filesToDelete=新堆栈（）；
堆栈方向删除=新堆栈（）；
filesToDelete.push（oFile）；
而（！filesToDelete.empty（））
{
oFile=filesToDelete.pop（）；
if（oFile.isDirectory（））
{
File[]aFiles=oFile.listFiles（）；
用于（文件名：aFiles）
{
filesToDelete.push（oFileCur）；
} 
//这是一个目录，请在末尾删除它
//注意，我们将看到目录
//“更深入”稍后，但我们会
//在“更高级别”之前删除它们
//所以在这里使用堆栈来删除它们
//在所有非目录被删除之后
//删除
directoriesToDelete.push（oFile）；
}
其他的
//这是一个文件，请立即删除
oFile.delete（）；
}
//删除目录
而（！directories.empty（））
directoriesToDelete.pop（）.delete（）；
}

如果允许使用适当的数据结构，则始终可以通过引入包含原始调用的“返回点”的堆栈来解决此类递归问题。

这取决于迭代的含义。如果您的意思是没有调用自身的函数，那么您可以通过显式使用堆栈来避免递归。

尽管在这种情况下，队列可能更合适：

def delete(path):
    todo = queue()
    todo.put(path)
    while todo:
        item = todo.get()
        if item.isdir():
           empty = True
           for entry in item.listdir():
               todo.put(entry)
               empty = False
           if empty:
               item.delete()
           else:
               todo.put(item)
        else:
           item.delete()

---

你总是可以不用递归来解决问题。那么，没有递归，你唯一不能做的就是展示递归是如何工作的

---

您删除子文件夹的示例可以使用列表和循环来解决。

取决于您是要实现提问者所说的（“删除所有文件”），还是要实现提问者的代码（“删除所有文件和目录”）。