我发现这些方法之间的另一个区别。它看起来简单而无关紧要，但是在您准备面试时它起着非常重要的作用，因此这个话题出现了，因此请仔细观察。
简而言之：1）迭代后遍历并不容易-这使DFT变得更加复杂2）循环使用递归更容易检查
细节：
在递归的情况下，创建遍历前后很容易：
想象一个非常标准的问题：“当任务依赖于其他任务时，打印应该执行以执行任务5的所有任务”
例：
//key-task, value-list of tasks the key task depends on
//"adjacency map":
Map<Integer, List<Integer>> tasksMap = new HashMap<>();
tasksMap.put(0, new ArrayList<>());
tasksMap.put(1, new ArrayList<>());
List<Integer> t2 = new ArrayList<>();
t2.add(0);
t2.add(1);
tasksMap.put(2, t2);
List<Integer> t3 = new ArrayList<>();
t3.add(2);
t3.add(10);
tasksMap.put(3, t3);
List<Integer> t4 = new ArrayList<>();
t4.add(3);
tasksMap.put(4, t4);
List<Integer> t5 = new ArrayList<>();
t5.add(3);
tasksMap.put(5, t5);
tasksMap.put(6, new ArrayList<>());
tasksMap.put(7, new ArrayList<>());
List<Integer> t8 = new ArrayList<>();
t8.add(5);
tasksMap.put(8, t8);
List<Integer> t9 = new ArrayList<>();
t9.add(4);
tasksMap.put(9, t9);
tasksMap.put(10, new ArrayList<>());
//task to analyze:
int task = 5;
List<Integer> res11 = getTasksInOrderDftReqPostOrder(tasksMap, task);
System.out.println(res11);**//note, no reverse required**
List<Integer> res12 = getTasksInOrderDftReqPreOrder(tasksMap, task);
Collections.reverse(res12);//note reverse!
System.out.println(res12);
private static List<Integer> getTasksInOrderDftReqPreOrder(Map<Integer, List<Integer>> tasksMap, int task) {
List<Integer> result = new ArrayList<>();
Set<Integer> visited = new HashSet<>();
reqPreOrder(tasksMap,task,result, visited);
return result;
}
private static void reqPreOrder(Map<Integer, List<Integer>> tasksMap, int task, List<Integer> result, Set<Integer> visited) {
if(!visited.contains(task)) {
visited.add(task);
result.add(task);//pre order!
List<Integer> children = tasksMap.get(task);
if (children != null && children.size() > 0) {
for (Integer child : children) {
reqPreOrder(tasksMap,child,result, visited);
}
}
}
}
private static List<Integer> getTasksInOrderDftReqPostOrder(Map<Integer, List<Integer>> tasksMap, int task) {
List<Integer> result = new ArrayList<>();
Set<Integer> visited = new HashSet<>();
reqPostOrder(tasksMap,task,result, visited);
return result;
}
private static void reqPostOrder(Map<Integer, List<Integer>> tasksMap, int task, List<Integer> result, Set<Integer> visited) {
if(!visited.contains(task)) {
visited.add(task);
List<Integer> children = tasksMap.get(task);
if (children != null && children.size() > 0) {
for (Integer child : children) {
reqPostOrder(tasksMap,child,result, visited);
}
}
result.add(task);//post order!
}
}
请注意，递归后顺序遍历不需要后续结果反转。儿童先打印，问题中的任务打印最后。一切都很好。您可以进行递归的预遍历（也如上所示），并且需要对结果列表进行翻转。
迭代方法不是那么简单！在迭代（单栈）方法中，您只能进行预排序遍历，因此必须在最后对结果数组求逆：
List<Integer> res1 = getTasksInOrderDftStack(tasksMap, task);
Collections.reverse(res1);//note reverse!
System.out.println(res1);
private static List<Integer> getTasksInOrderDftStack(Map<Integer, List<Integer>> tasksMap, int task) {
List<Integer> result = new ArrayList<>();
Set<Integer> visited = new HashSet<>();
Stack<Integer> st = new Stack<>();
st.add(task);
visited.add(task);
while(!st.isEmpty()){
Integer node = st.pop();
List<Integer> children = tasksMap.get(node);
result.add(node);
if(children!=null && children.size() > 0){
for(Integer child:children){
if(!visited.contains(child)){
st.add(child);
visited.add(child);
}
}
}
//If you put it here - it does not matter - it is anyway a pre-order
//result.add(node);
}
return result;
}
看起来很简单，不是吗？
但这是一些采访中的陷阱。
它的含义如下：使用递归方法，您可以实现“深度优先遍历”，然后选择需要的先后顺序（仅通过更改“打印”的位置即可，在本例中为“添加到结果列表”中） ）。使用迭代（单堆栈）方法，您可以轻松地仅执行预遍历，因此在需要先打印子项的情况下（几乎所有情况下，您需要从底部节点开始打印，然后向上打印）-您处于麻烦。如果遇到这种麻烦，可以稍后再撤消，但这将是对算法的补充。如果面试官在看他的手表，那对您来说可能是个问题。存在多种进行迭代后序遍历的复杂方法，但是它们并不简单。例：https://www.geeksforgeeks.org/iterative-postorder-traversal-using-stack/
因此，最重要的是：我将在采访中使用递归，它更易于管理和解释。在任何紧急情况下，您都可以轻松地进行从订单遍历到后遍历。有了迭代，您就没有那么灵活了。
我将使用递归，然后说：“好吧，但是迭代可以为我提供对已用内存的更直接控制，我可以轻松地测量堆栈大小并禁止某些危险的溢出。”
递归的另一个优点-避免/注意图中的循环更简单。
示例（preudocode）：
dft(n){
mark(n)
for(child: n.children){
if(marked(child))
explode - cycle found!!!
dft(child)
}
unmark(n)
}
