二叉树DFS和BFS 递归/非递归

二叉树DFS和BFS 递归/非递归方式

1.DFS

DFS, 深度优先遍历
（1）递归形式

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

List<TreeNode> list = new ArrayList<>();
public List<TreeNode> traversal(TreeNode root) {
    dfs(root);
    return list;
}

private void dfs(TreeNode root) {
    if (root == null) return;
    list.add(root);
    dfs(root.left);
    dfs(root.right);
}

(2)非递归形式 （利用栈来递归）

public List<TreeNode> traversal(TreeNode root) {
    if (root == null) return null;
    List<TreeNode> res = new ArrayList<>();
    Stack<TreeNode> stack = new Stack<>();
    stack.add(root);
    while(!stack.empty()) {
        TreeNode node = stack.pop();
        res.add(node);
        if (node.right != null) {
            stack.push(node.right);
        }
        if (node.left != null) {
            stack.push(node.left);
        }
    }
    return res;
}

2.BFS

BFS，广度优先遍历，对应二叉树的层级遍历
(1)非递归形式 （利用队列实现遍历）

public List<TreeNode> traversal(TreeNode root) {
        if (root == null) return null;
        return bfs(root);
    }

    private List<TreeNode> bfs(TreeNode root) {
        //if (root == null) return null;
        int curNum = 1;   //维护当前层的node数量
        int nextNum = 0;  //维护下一层的node数量
        Queue<TreeNode> queue = new LinkedList<>();
        List<TreeNode> list = new ArrayList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
            TreeNode node = queue.poll();
            list.add(node);
            curNum--;
            if (node.left != null) {
                queue.add(node.left);
                nextNum++;
            }
            if (node.right != null) {
                queue.add(node.right);
                nextNum++;
            }

            if (curNum == 0) {
                curNum = nextNum;
                nextNum = 0;
            }
        }

        return list;
    }

(2)递归形式
这里所谓的bfs递归形式，是利用dfs的递归形式，在递归过程中记录每个node的level，然后将属于一个level的node放到一list里面

public List<List<TreeNode>> traversal(TreeNode root) {
    if (root == null) return null;
    List<List<TreeNode>> list = new ArrayList<>();
    dfs(root, 0, list);
    return list;
}

private void dfs(TreeNode root, int level, List<List<TreeNode>> list) {
    if (root == null) return;
    if (level >= list.size()) {
        List<TreeNode> subList = new ArrayList<>();
        subList.add(root);
        list.add(subList);
    } else {
        list.get(level).add(root);
    }
    dfs(root.left, level+1, list);
    dfs(root.right, level+1, list);
}

---

图的深度优先遍历和广度优先遍历，和二叉树的dfs、bfs原理的相同的。一般，深度优先遍历利用栈来实现（或者递归），广度优先遍历利用队列来实现。