【演算法】二叉樹、N叉樹先序、中序、後序、BFS、DFS遍歷的遞迴和迭代實現記錄（Java版）

        本文總結了刷LeetCode過程中，有關樹的遍歷的相關程式碼實現，包括了二叉樹、N叉樹先序、中序、後序、BFS、DFS遍歷的遞迴和迭代實現。這也是解決樹的遍歷問題的固定套路。

一、二叉樹的先序、中序、後序遍歷
  1、遞迴模板
  （1）先序

public void preorder(TreeNode root) {
   if (root == null) {
       return;
   }
   res.add(root.val);
   preorder(root.left);
   preorder(root.right);
}

  （2）中序

public void inorder(TreeNode root) {
   if (root == null) {
      return;
   }
   inorder(root.left);
   res.add(root.val);
   inorder(root.right);
}

  （3）後序

public void postorder(TreeNode root) {
    if (root == null) {
       return;
    }
    postorder(root.left);
    postorder(root.right);
    res.add(root.val);
}

  2、迭代模板:顯式使用棧
  （1）先序 。也可以使用後文的DFS實現

public void preorder(TreeNode root) {
     Deque<TreeNode> stack = new ArrayDeque<>();
      while(root !=null || !stack.isEmpty()) {
         while(root != null) {
            stack.push(root);
            res.add(root.val);//儲存結果
            root = root.left;
         }
         root = stack.pop();
         root = root.right;
      }
}

  （2）中序

public void inorder(TreeNode root) {
    Deque<TreeNode> stack = new ArrayDeque<>();
    while(root != null || !stack.isEmpty()) {
       while(root != null) {
          stack.push(root);
          root = root.left;
       }
       root = stack.pop();
       res.add(root.val);//儲存結果
       root = root.right;
    }
}

  （3）後序。先序是根——左——右，而後序是左-右-根，可以將先序改成根-右-左，然後將結果反轉。如下程式碼對比先序的程式碼：

public void postorder(TreeNode root) {
    Deque<TreeNode> stack = new ArrayDeque<>();
     while(root != null || !stack.isEmpty()) {
         while(root != null) {
            stack.push(root);
            res.add(root.val);//儲存結果
            root = root.right;//注意這裡和先序、中序的差別
         }
         root = stack.pop();
         root = root.left();
     }
     Collections.reverse(res);//將前面的結果反轉
}

       當然，上面這種方法比較間接，藉助於先序遍歷的理解。下面採用一種直接的迭代方式：

public void postorder(TreeNode root) {
    Deque<TreeNode> stack = new ArrayDeque<>();
    TreeNode preNode = new TreeNode();//該節點用於儲存前一個出棧的節點
    while (root != null || !stack.isEmpty()) {
        //將當前節點的左子樹節點一次入棧
        while (root != null) {
            stack.push(root);
            root = root.left;
        }
        root = stack.peek();
        //當前節點沒有右孩子了，或者其右孩子已經出棧了，則當前節點也出棧
        if (root.right == null || root.right == preNode) {
            root = stack.pop();
            res.add(root.val);//儲存結果
            preNode = root; //記錄本次剛輸出的節點
            root = null;
        } else {
            //當前節點還有右孩子，且其右孩子還沒有出棧，則先處理其右孩子
            root = root.right;
        }
    }
}

 

二、N叉樹的先序與後序遍歷
  1、遞迴模板
  （1）先序

public void preorder(TreeNode root) {
    if (root == null) {
        return;
    }
    res.add(root.val);//儲存結果
    if (root.children != null) {
        for (int i = 0; i < root.children.size(); i++) {
            dfs(root.children.get(i));
        }
    }
}

  （2）後序

public void postorder(TreeNode root) {
    if (root == null) {
        return;
    }
    for (int i = 0; i < root.children.size(); i++) {
        postorder(root.children.get(i));
    }
    res.add(root.val);//儲存結果
}

  2、迭代模板
  （1）先序。即下文中DFS的實現

public void preorder(Node root) {
   Deque<Node> stack = new ArrayDeque<>(); //BFS使用佇列，這裡使用棧
   stack.push(root);
   while (!stack.isEmpty()) {
       root = stack.pop();
       res.add(root.val);//儲存結果
       int childCount = root.children == null ? 0 : root.children.size();
       //這裡需要注意孩子節點入棧的順序
        for (int i = childCount - 1; i >= 0; i--) {
           stack.push(root.children.get(i));
       }
   }
}

  （2）後序。先序是根——左——右，而後序是左-右-根，可以將先序改成根-右-左，然後將結果反轉。如下程式碼對比先序的程式碼：

public void postorder(Node root) {
   List<Integer> result = new ArrayList<>();
   Deque<Node> stack = new ArrayDeque<>();
   stack.push(root);
   while (!stack.isEmpty()) {
       root = stack.pop();
       result.add(root.val);//儲存結果
       int childCount = root.children == null ? 0 : root.children.size();
        //還入棧的順序正好和先序遍歷相反
       for (int i = 0; i < childCount; i++) {
           stack.push(root.children.get(i));
       }
   }
    //將結果反轉
   Collections.reverse(result);
   for (Integer i:result) {
       System.out.print(i);
   }
}

       目前還沒有找到類似二叉樹直接後序遍歷的方法

 

三、樹的BFS(廣度優先搜尋)和DFS(深度優先搜尋)實現模板
  1、遞迴實現
  （1）BFS
          一般來說不能使用遞迴來實現BFS，因為BFS使用的時佇列實現，而遞迴使用的是棧實現。
  （2）DFS
          普通的N叉樹的DFS包括先序遍歷和後序遍歷，它們的遞迴實現和前文一致。如果是二叉樹，還有中序遍歷，遞迴實現和前文一致。
  2、迭代實現
  （1）BFS。即按層次來遍歷

public void bfs(Node root) {
   Queue<Node> queue = new LinkedList<>();
   queue.offer(root);
   while (!queue.isEmpty()) {
       root = queue.poll();
       res.add(root.val);//儲存結果
       if (root.children != null) {
           queue.addAll(root.children);//這裡的addAll後，root的children會從左往右依次入隊。這一點Deque實現的棧正好相反，這一點需要注意
       }
   }
}

  （2）DFS
       先序遍歷、中序遍歷(二叉樹)和後序遍歷的迭代方式實現和前文一致。

 

四、圖的BFS和DFS遍歷模板

        樹是圖的一種特殊情況，相比於樹而言圖中可能出現環，所以在遍歷的時候可能重複訪問。所以樹的BFS和DFS實現需要在樹的基礎上維護一個Set來避免訪問重複的節點即可。

  1、BFS

public void graphyBfs(Node root) {
    if (root == null) {
        return;
    }
    Set<Node> visitedSet = new HashSet<>(); //維護一個set，儲存已經訪問過的節點
    Queue<Node> queue = new LinkedList<>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        root = queue.poll();
        visitedSet.add(root);//儲存每個已經輸出的節點
        res.add(root.val);//儲存結果
        if (root.children == null) {
            return;
        }
        for (int i = 0; i < root.children.size(); i++) {
            Node tmpNode = root.children.get(i);
            if (!visitedSet.contains(tmpNode)) {//已經輸出過的節點，則不用再加入
                queue.offer(tmpNode);
            }
        }
    }
}

  2、DFS
       迭代方式、遞迴方式，都維護一個set來儲存已經訪問過的節點，在輸出節點時儲存到set中，在新增節點時新增去重操作即可。