나는 그 접근법들 사이에 또 다른 차이점을 발견했습니다. 간단하고 중요하지 않은 것처럼 보이지만 인터뷰 준비를하는 동안 매우 중요한 역할을하며이 주제가 발생하므로 자세히 살펴보십시오.
간단히 말하면 : 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;
}
간단 해 보이죠?
그러나 일부 인터뷰에서는 함정입니다.
재귀 접근 방식을 사용하면 Depth First Traversal을 구현 한 다음 사전 또는 사후 필요한 순서를 선택할 수 있습니다 ( "결과 목록에 추가"의 경우 "인쇄"의 위치를 변경하여 간단히). ). 반복 (한 번의 스택) 접근 방식을 사용하면 사전 주문 순회 만 쉽게 수행 할 수 있으므로 어린이를 먼저 인쇄 해야하는 상황 (하단 노드에서 인쇄를 시작 해야하는 모든 상황) 문제. 그 문제가 있으면 나중에 되돌릴 수 있지만 알고리즘에 추가됩니다. 면접관이 자신의 시계를보고 있다면 문제가 될 수 있습니다. 반복적 인 주문 후 순회를 수행하는 복잡한 방법이 있지만 존재하지만 단순하지는 않습니다 . 예:https://www.geeksforgeeks.org/iterative-postorder-traversal-using-stack/
결론 : 인터뷰 중에 재귀를 사용하고 관리하고 설명하는 것이 더 간단합니다. 긴급한 상황에서 사전 주문 후 주문 순회로 쉽게 이동할 수 있습니다. 반복적으로 당신은 그렇게 유연하지 않습니다.
재귀를 사용하고 다음과 같이 말합니다. "좋아요. 그러나 반복적으로 사용 된 메모리를보다 직접적으로 제어 할 수 있습니다. 스택 크기를 쉽게 측정하고 위험한 오버플로를 허용하지 않습니다."
재귀의 또 다른 장점-그래프에서 사이클을 피 / 통지하는 것이 더 간단합니다.
예 (사전 코드) :
dft(n){
mark(n)
for(child: n.children){
if(marked(child))
explode - cycle found!!!
dft(child)
}
unmark(n)
}
