二叉树访问

1. 前序遍历

访问顺序是：根节点→左子树→右子树

下图例是：A→B→D→E→C→F

// 递归写法
public static void preOrder(TreeNode tree) {
    if (tree == null)
        return;
    System.out.printf(tree.val + "");
    preOrder(tree.left);
    preOrder(tree.right);
}

// 非递归写法
public static void preOrder(TreeNode tree) {
    if (tree == null)
        return;
    Stack<TreeNode> q1 = new Stack<>();
    q1.push(tree);//压栈
    while (!q1.empty()) {
        TreeNode t1 = q1.pop();//出栈
        System.out.println(t1.val);
        if (t1.right != null) {
            q1.push(t1.right);
        }
        if (t1.left != null) {
            q1.push(t1.left);
        }
    }
}

2. 中序遍历

访问顺序是：左子树→根节点→右子树

下图例是：D→B→E→A→F→C

// 递归写法
public static void inOrderTraversal(TreeNode node) {
    if (node == null)
        return;
    inOrderTraversal(node.left);
    System.out.println(node.val);
    inOrderTraversal(node.right);
}

// 非递归写法
public static void inOrderTraversal(TreeNode tree) {
     Stack<TreeNode> stack = new Stack<>();
     while (tree != null || !stack.isEmpty()) {
         while (tree != null) {
             stack.push(tree);
             tree = tree.left;
         }
         if (!stack.isEmpty()) {
             tree = stack.pop();
            System.out.println(tree.val);
            tree = tree.right;
        }
    }
}

3. 后序遍历

访问顺序是：左子树→右子树→根节点

下图例是：D→E→B→F→C→A

// 递归写法
public static void postOrder(TreeNode tree) {
    if (tree == null)
        return;
    postOrder(tree.left);
    postOrder(tree.right);
    System.out.println(tree.val);
}

// 非递归写法
public static void postOrder(TreeNode tree) {
    if (tree == null)
        return;
    Stack<TreeNode> s1 = new Stack<>();
    Stack<TreeNode> s2 = new Stack<>();
    s1.push(tree);
    while (!s1.isEmpty()) {
        tree = s1.pop();
        s2.push(tree);
        if (tree.left != null) {
            s1.push(tree.left);
        }
        if (tree.right != null) {
            s1.push(tree.right);
        }
    }
    while (!s2.isEmpty()) {
        System.out.print(s2.pop().val + " ");
    }
}

4. BFS （广度优先）

访问顺序是：先访问上一层，在访问下一层，一层一层的往下访问

下图例是：A→B→C→D→E→F

// 非递归写法
public static void levelOrder(TreeNode tree) {
    if (tree == null)
        return;
    LinkedList<TreeNode> list = new LinkedList<>();//链表，这里我们可以把它看做队列
    list.add(tree);//相当于把数据加入到队列尾部
    while (!list.isEmpty()) {
        TreeNode node = list.poll();//poll方法相当于移除队列头部的元素
        System.out.println(node.val);
        if (node.left != null)
            list.add(node.left);
        if (node.right != null)
            list.add(node.right);
    }
}

// 递归写法
public static void levelOrder(TreeNode tree) {
    int depth = depth(tree);
    for (int level = 0; level < depth; level++) {
        printLevel(tree, level);
    }
}

private static int depth(TreeNode tree) {
    if (tree == null)
        return 0;
    int leftDepth = depth(tree.left);
    int rightDepth = depth(tree.right);
    return Math.max(leftDepth, rightDepth) + 1;
}


private static void printLevel(TreeNode tree, int level) {
    if (tree == null)
        return;
    if (level == 0) {
        System.out.print(" " + tree.val);
    } else {
        printLevel(tree.left, level - 1);
        printLevel(tree.right, level - 1);
    }
}

// BFS的另外一种遍历方式
def bfs_01(self, root):
    # queue里面放节点及节点在满二叉树数组的位置（从1开始）
    # 有个重要性质：编号为index的节点，左孩位置是2*index，右孩位置是2*index+1
    queue = [[root, 1]]
    while queue:
        tmp = []
        for item in queue:
            node = item[0]
            index = item[1]
            if node.left is not None:
                tmp.append([node.left, 2*index])
            if node.right is not None:
                tmp.append([node.right, 2*index+1])
        
        # 针对queue进行xxx处理
        
        # queue保存当前层的孩子层，进入下一次循环
        queue = tmp

5. DFS（深度优先）

访问顺序是：先访根节点，然后左结点，一直往下，直到最左结点没有子节点的时候然后往上退一步到父节点，然后父节点的右子节点在重复上面步骤……

下图例是：A→B→D→E→C→F

// 非递归写法
public static void treeDFS(TreeNode root) {
    Stack<TreeNode> stack = new Stack<>();
    stack.add(root);
    while (!stack.empty()) {
        TreeNode node = stack.pop();
        System.out.println(node.val);
        if (node.right != null) {
            stack.push(node.right);
        }
        if (node.left != null) {
            stack.push(node.left);
        }
    }
}

// 递归写法
public static void treeDFS(TreeNode root) {
    if (root == null)
        return;
    System.out.println(root.val);
    treeDFS(root.left);
    treeDFS(root.right);
}