これらのアプローチには別の違いがあることがわかりました。シンプルで重要ではないように見えますが、インタビューの準備をしているときに非常に重要な役割を果たし、このテーマが浮上するので、よく見てください。
要約すると、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!
}
}
再帰的なpost-order-traversalでは、結果を後で反転する必要がないことに注意してください。子供が最初に印刷され、質問のあなたのタスクが最後に印刷されました。すべて順調。再帰的なpre-order-traversal（これも上に示しています）を行うことができ、結果リストの逆転が必要になります。
反復的なアプローチではそれほど単純ではありません！反復（1スタック）アプローチでは、事前順序付けトラバーサルしか実行できないため、最後に結果の配列を逆にする必要があります。
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;
}
シンプルに見えますか？
しかし、それはいくつかのインタビューの罠です。
それは次のことを意味します：再帰的なアプローチでは、深さ優先トラバーサルを実装し、必要な順序を事前または事後的に選択できます（「結果リストに追加する」の場合は、単に「印刷」の場所を変更することによって） ）。反復（1スタック）アプローチを使用すると、予約注文のトラバーサルのみを簡単に行うことができるため、子を最初に印刷する必要がある場合（下のノードから上に印刷を開始する必要がある場合のほとんどすべての状況）-トラブル。問題が発生した場合は後で元に戻すことができますが、アルゴリズムに追加されます。そして、インタビュアーが彼の時計を見ている場合、それはあなたにとって問題になるかもしれません。注文後の反復走査を行うには複雑な方法がありますが、それらは存在しますが、単純ません。例：https://www.geeksforgeeks.org/iterative-postorder-traversal-using-stack/
したがって、結論として、インタビューでは再帰を使用します。管理と説明が簡単です。緊急の場合でも、注文前から注文後のトラバーサルに簡単に移動できます。反復を使用すると、それほど柔軟ではありません。
私は再帰を使用して、次のように言います。
再帰のもう1つのプラス-グラフのサイクルを回避/通知する方が簡単です。
例（preudocode）：
dft(n){
mark(n)
for(child: n.children){
if(marked(child))
explode - cycle found!!!
dft(child)
}
unmark(n)
}
