算法之数据结构基础（4）

一、遍历二叉树

1、介绍

在计算机程序中，遍历本身是一个线性操作。所以遍历一个拥有线性结构的如：数组、链表，是一件很简单的事情。而二叉树是非线性数据机构，遍历时需要将非线性关联的节点转换成一个线性的结构，进行遍历。不同的方式可以遍历出不同的顺序。

2、遍历的种类

从节点位置关系：

• 前序遍历
• 中序遍历
• 后序遍历
• 层序遍历

从宏观角度来看分为两类：

• 深度优先遍历（前序、中序、后序）
• 广度优先遍历（层序遍历）

二、深度优先遍历（递归）

深度优先遍历不仅仅适用于二叉树，在树、图等一些复杂数据结构常常被用到。所谓深度优先，顾名思义，纵向遍历。

1、前序遍历

如图所示，一颗深度为3、6节点的二叉树。前序遍历优先级为由上到下，右根节点靠左遍历。
模拟前序遍历结果

• 输出根节点1 。
• 获取此节点的左孩子节点，输出节点2 。
• 再次获取左孩子节点，输出节点4。
• 节点4没有左孩子节点，也没有右孩子节点，那么回到节点2，输出2节点的右孩子节点5。
• 节点5没有左孩子节点也没右右孩子节点，那么回到节点1，输出1的右孩子节点3。
• 先看节点3有没有左孩子节点，没有则输出右孩子节点6。
• 结束遍历

2、中序遍历

还是此图作为案例，中序遍历的输出顺序是：左子树->根节点->右子树。
模拟中序遍历

• 首先访问跟节点的左孩子节点，如果左孩子节点还有左孩子，那么继续向下访问，直到不在有左孩子，则输出此节点。如图，输出节点4。
• 接着输出节点2。
• 再输出节点2的右孩子节点5。
• 根节点的左子树遍历完毕，接着输出跟节点1。
• 按照顺序，左子树和根节点都输出完毕，此时遍历右子树，按照从左到右依次输出3、6节点。
• 遍历完毕。

3、后序遍历

后序遍历，意思是从树的后方开始遍历。即从树的下方遍历。顺序：从下往上，深度优先，左子树优先，右子树其次，根节点最后。
模拟后序遍历

• 从下往上，从左子树开始，首先输出最靠右的叶子节点4。
• 其次输出节点4的同级节点5。
• 接着输出两者父节点2。
• 左子树遍历完毕，发现到了根节点，再从根节点找到右孩子，找右孩子的左孩子和右孩子，发现没有左孩子，输出右孩子节点6。
• 最后依次输出节点3、1。

4、代码实现

节点

/**
 * @author chengyanqi
 * @date 2020/8/6 22:44
 */
public class TreeNode {
    int data;//数据
    TreeNode leftChild;//左孩子
    TreeNode rightChild;//右孩子
    //构造方法
    public TreeNode(int data) {
        this.data = data;
    }
}

工具类：前序、中序、后序遍历

/**
 * @author chengyanqi
 * @date 2020/8/6 22:45
 */
public class TreeNodeUtil {
    /**
     * 构建二叉树
     * @param inputList 输入的队列
     * @return 返回构建的node
     */
    public static TreeNode createBinaryTree(LinkedList<Integer> inputList) {
        TreeNode node = null;
        if (null == inputList || inputList.isEmpty()) {
            return null;
        }
        Integer data = inputList.removeFirst();
        if (data != null) {
            node = new TreeNode(data);
            node.leftChild = createBinaryTree(inputList);
            node.rightChild = createBinaryTree(inputList);
        }
        return node;
    }

    //前序遍历（由上到下）
    public static void preOrderTraveral(TreeNode node) {
        if (node == null) {
            return;
        }
        System.out.println(node.data);
        preOrderTraveral(node.leftChild);
        preOrderTraveral(node.rightChild);
    }

    //中序遍历(由左到右)
    public static void inOrderTraveral(TreeNode node) {
        if (node == null) {
            return;
        }
        inOrderTraveral(node.leftChild);
        System.out.println(node.data);
        inOrderTraveral(node.rightChild);
    }

    //后序遍历
    public static void postOrderTraveral(TreeNode node) {
        if (node == null) {
            return;
        }
        postOrderTraveral(node.leftChild);
        postOrderTraveral(node.rightChild);
        System.out.println(node.data);
    }
}

测试

/**
 * @author chengyanqi
 * @date 2020/8/6 22:54
 */
public class TreeNodeTest {
    public static void main(String[] args) {
        Integer[] integers = new Integer[]{3, 2, 5, null, null, 10, null, null, 8, null, 4};
        List<Integer> integerList = Arrays.asList(integers);
        LinkedList<Integer> linkedList = new LinkedList<>(integerList);
        TreeNode binaryTree = TreeNodeUtil.createBinaryTree(linkedList);
        System.out.println("前序遍历");
        TreeNodeUtil.preOrderTraveral(binaryTree);
        System.out.println("中序遍历");
        TreeNodeUtil.inOrderTraveral(binaryTree);
        System.out.println("后序遍历");
        TreeNodeUtil.postOrderTraveral(binaryTree);
    }
}

输出结果如下

前序遍历
3
2
5
10
8
4
中序遍历
5
2
10
3
8
4
后序遍历
5
10
2
4
8
3

构建二叉树如图

三、深度优先遍历（栈）

绝大多数可以用递归解决的问题，都可以用另一种数据结构栈来解决。

1、非递归前序遍历理论

以前序遍历为例，用栈来做深度优先遍历主要思想是以下几个步骤

1. 以上图为例，首先遍历根节点1，放入栈中。
2. 遍历根节点1的左孩子节点2，放入栈中
3. 遍历节点2的左孩子节点4，放入栈中。
4. 此时，发现节点4既没有左孩子，也没有右孩子，我们需要回溯到上一个节点2。我们可以将节点4出栈，就可以访问到2节点。再拿到2的右孩子5节点。此时2节点已经没有利用价值了，所以将2节点弹栈，将5节点入栈。
5. 节点5既没有左孩子也没有右孩子，直接将5弹栈。此时只剩下节点1。找到节点1的右节点3，找到后，节点1也没有利用价值了，直接弹栈。由3节点入栈。
6. 根据3节点找左孩子，没有找到。再找右孩子节点6。此时3节点没有利用价值，进行弹栈。再将节点6入栈。此时栈内只有节点6
7. 节点6既没有左孩子也没有右孩子，直接进行出栈。此时栈为空，遍历结束。

以上步骤如下图表示

2、非递归前序遍历代码

    /**
     * 前序遍历（非递归）
     */
    public static void preOrderTraveralWithStack(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode treeNode = root;
        while (treeNode != null || !stack.empty()) {
            //访问节点的左孩子节点，进行入栈
            while (treeNode != null) {
                System.out.println(treeNode.data);
                stack.push(treeNode);
                treeNode = treeNode.leftChild;
            }
            //如果没有左孩子节点，则进行弹栈处理，访问节点的右孩子节点
            if (!stack.empty()) {
                treeNode = stack.pop();//弹栈
                treeNode = treeNode.rightChild;
            }
        }
    }

 public static void main(String[] args) {
        Integer[] integers = new Integer[]{3, 2, 5, null, null, 10, null, null, 8, null, 4};
        List<Integer> integerList = Arrays.asList(integers);
        LinkedList<Integer> linkedList = new LinkedList<>(integerList);
        TreeNode binaryTree = TreeNodeUtil.createBinaryTree(linkedList);
        TreeNodeUtil.preOrderTraveralWithStack(binaryTree);

输出：

3
2
5
10
8
4

四、广度优先遍历

如果说深度优先遍历是一个方向走到底，那么广度优先遍历就是每个方向走一步，再每个方向走两步…一直到走完。

1、层序遍历理论

顾名思义，一层一层进行遍历。遍历输出步骤如图：

广度优先遍历使用队列来实现。
文字解析

1. 根节点1进入队列。
2. 根节点1出队，并得到节点1的左孩子节点2和右孩子节点3.并且让2、3入队。
3. 节点2出队，得到节点2的左孩子节点4和右孩子节点5，并依次4、5进行入队。
4. 节点3出队，得到节点3的右孩子节点6。并让节点6入队。
5. 此时队列内依次包含4、5、6三个节点，节点4没有孩子节点，所以没有新的节点加入。
6. 节点5、6同理，没有孩子节点，直接进行输出。

图片解析

2、层序遍历代码

/**
 * 二叉树层序遍历
 * @param root 二叉树根节点
 */
public static void levelOrderTraversal(TreeNode root) {
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);//入队
    while (!queue.isEmpty()) {
        TreeNode pollNode = queue.poll();//出队
        System.out.println(pollNode.data);
        //如果有左孩子，则进行入队
        if (pollNode.leftChild != null) {
            queue.offer(pollNode.leftChild);
        }
        //如果有右孩子，则进行入队
        if (pollNode.rightChild != null) {
            queue.offer(pollNode.rightChild);
        }
    }
}

public static void main(String[] args) {
    Integer[] integers = new Integer[]{3, 2, 5, null, null, 10, null, null, 8, null, 4};
    List<Integer> integerList = Arrays.asList(integers);
    LinkedList<Integer> linkedList = new LinkedList<>(integerList);
    TreeNode binaryTree = TreeNodeUtil.createBinaryTree(linkedList);
    TreeNodeUtil.levelOrderTraversal(binaryTree);
 }

输出结果

3
2
8
5
10
4

五、小结

二叉树用递归方式来实现前序、中序、后续遍历，是最为自然的方式，因此代码也很简洁。
这三种遍历方式的区别，仅仅是输出的执行位置不同

• 前序遍历的输出在前
• 中序遍历的输出在中间
• 后续遍历的输出在最后