Java实现二叉树的先序、中序、后序遍历算法

Java实现二叉树的先序、中序、后序遍历算法

一、构建二叉树的存储结构

一棵二叉树的节点结构主要包括三部分：节点的值域，指向左孩子的指针，指向右孩子的指针。由于Java语言没有指针的定义，这里采用属性的方式实现(重写equals方法是为了后续遍历非递归算法的需要，后面会说明)。代码如下：

import java.util.Objects;

/**
 * @author:Chris
 * @description 二叉树结点结构
 */
public class BiTNode {

    char val;       //节点的值域
    BiTNode lChild; //指向左孩子
    BiTNode rChild; //指向右孩子
    
    public BiTNode(char val) {
        this.val = val;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        BiTNode biTNode = (BiTNode) o;
        return val == biTNode.val &&
                Objects.equals(lChild, biTNode.lChild) &&
                Objects.equals(rChild, biTNode.rChild);
    }

}

二、先序、中序与后续遍历的递归算法

2.1 先序遍历

简单来说，就是从一棵树的根节点开始，先访问根节点，然后依次访问左孩子和右孩子节点。也就是“根左右”的次序。
举个例子，如图2.1所表示的二叉树。从根节点出发依次遍历，A节点为根节点，访问A节点；然后遍历左孩子B节点，由于B节点也是所在子树的根节点，所以访问B节点；再继续遍历B节点的左孩子，由于为空，不做处理；继续遍历B节点的右孩子，访问D节点；D节点的左右孩子均为空，不做处理。这样，以A节点为根的左子树就遍历结束了。再依次遍历A节点的右子树，最后得到的先序遍历序列为：A - B - D - C - E
代码如下：

	/**
     * 先序遍历（递归）
     * @param bt
     */
    public void PreOrder(BiTNode bt) {
        if (bt != null) {
            System.out.print(bt.val + " ");
            PreOrder(bt.lChild);
            PreOrder(bt.rChild);
        }
    }

图2.1 二叉树示例

2.2 中序遍历

中序遍历的访问次序为：左、根、右
如图2.1所示，从根节点出发，节点A左孩子非空，则应向左遍历；遇到节点B，遍历节点B的左孩子，发现左孩子为空；此时再次回到节点B，访问节点B；由于节点B的右孩子非空，继续向右遍历；节点D的左右孩子均为空，访问节点D；此时以节点A为根的左子树均被访问过了，然后访问节点A，然后遍历A的右子树。最终的访问次序为：B - D - A - C - E。需要注意的是，这里“遍历”这个词，更准确的描述应该是“经过”或“路过”。与先序遍历相比，先序遍历第一次路过根节点，根节点即被访问；而中序遍历时，根节点被第二次路过时，才会被访问。

代码如下：

	/**
     * 中序遍历（递归）
     * @param bt
     */
    public void InOrder(BiTNode bt) {
        if (bt != null) {
            InOrder(bt.lChild);
            System.out.print(bt.val + " ");
            InOrder(bt.rChild);
        }
    }

2.3 后续遍历

后续遍历的访问次序为：左、右、根
还是以图2.1为例，从根节点出发，优先向左遍历。首次经过节点B，继续向左 (注意：虽然节点B的左子树为空，但是也需要进行一次判断，即经过一次)。节点B左子树为空，继续遍历节点B的右子树 (此时节点B被第二次经过)。对于节点D，左右子树均为空，访问节点D。再次回到节点B，访问节点B (此时节点B被第三次经过时，才被访问)。此时以节点A为根的左子树就均被访问过了。继续遍历节点A的右子树，最后访问节点A，遍历结束。最终访问的次序为：D - B - E - C - A
代码如下：

	/**
     * 后序遍历（递归）
     *
     * @param bt
     */
    public void PostOrder(BiTNode bt) {
        if (bt != null) {
            PostOrder(bt.lChild);
            PostOrder(bt.rChild);
            System.out.print(bt.val + " ");
        }
    }

三、初始化一棵二叉树

这里将采用先序遍历的方式构造一棵二叉树，如图2.1所示。初始化输入各节点时，将空节点记为：’#’。

    /**
     * 先序遍历构造二叉树
     * @param bt
     * @return BiTNode
     */
    public BiTNode Create(BiTNode bt) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        char s = str.charAt(0);
        if (s == '#') {
            bt = null;
        } else {
            bt = new BiTNode(s);
            bt.lChild = Create(bt.lChild);
            bt.rChild = Create(bt.rChild);
        }
        return bt;
    }

四、测试

新建一个测试类名为 TreeTest，将上述遍历操作放在名为 TreeExer的类下面。在 TreeTest的main方法中进行测试。代码如下：

public class TreeTest {

    public static void main(String[] args) {
        TreeExer treeExer = new TreeExer();
        BiTNode root = new BiTNode();
        root = treeExer.Create(root);
        //先序遍历递归算法
        treeExer.PreOrder(root);
        //中序遍历递归算法
//        treeExer.InOrder(root);
        //后续遍历递归算法
//        treeExer.PostOrder(root);
    }

}

以图2.1为例，数据录入，输出先序遍历递归算法的结果如图4.1。(其他算法的调用读者可以自行尝试)

图4.1 先序遍历递归算法测试

五、先序、中序、后序遍历的非递归算法

将递归算法改写为非递归算法，往往需要栈这种数据结构。其实递归算法底层的实现也是通过栈来记录每次调用函数的位置。
idea中可以在System.out.print(bt.val + " ");处打断点进行调试，可以清楚的看到递归工作栈中递归调用的信息，如图5.1。

5.1 先序遍历(非递归)

先序遍历的非递归算法也是借助栈来实现。由于是先访问根节点，所以可以选择在入栈之前，对根节点进行访问。

代码如下：

	/**
     * 先序遍历的非递归算法
     *
     * @param bt
     */
    public static void PreOrder(BiTNode bt) {
        Stack<BiTNode> st = new Stack<>();      //用于保存节点

        BiTNode p = bt;                         //工作指针

        while (p != null || !st.isEmpty()) {
            if (p != null) {
                visit(p);
                st.push(p);                     //这里也可以使用add(Object obj)方法，线程安全的。因为Stack类继承自Vector类
                p = p.lChild;
            } else {
                p = st.pop();                   //如果节点为空，栈顶元素出栈
                p = p.rChild;                   //指向右子树
            }
        }
    }

图5.1 断点调试

5.2 中序遍历(非递归)

与先序遍历的非递归算法唯一不同的是，visit函数的位置不同。这里是出栈后，对目标节点进行访问。也对应了前面提到的"第二次经过"才对其访问。
代码如下：

	/**
     * 中序遍历的非递归算法
     *
     * @param bt
     */
    public static void InOrder(BiTNode bt) {
        Stack<BiTNode> st = new Stack<>();      //用于保存节点

        BiTNode p = bt;                         //工作指针

        while (p != null || !st.isEmpty()) {
            if (p != null) {
                st.push(p);                     //这里也可以使用add(Object obj)方法，线程安全的。因为Stack类继承自Vector类
                p = p.lChild;
            } else {
                p = st.pop();                   //如果节点为空，栈顶元素出栈
                visit(p);
                p = p.rChild;                   //指向右子树
            }
        }
    }
    
	/**
     * 访问该节点
     * @param bt
     */
    private static void visit(BiTNode bt) {
        System.out.print(bt.val + " ");
    }

5.3 后续遍历(非递归)

在后续遍历中，要保证左孩子和右孩子都已经被访问，并且左孩子要在右孩子前访问，最后再访问根节点，这就为流程控制带来了困难。
问题的关键在于，当经过根节点时如何判断是从左子树返回的还是从右子树返回的。因此，声明一个指针r，它用于记录最近访问过的节点。也可以在类BiTNode中增加一个标志属性，记录是否已经被访问过。这里采用第一种方式实现。

代码如下：

	/**
     * 后续遍历的非递归算法
     *
     * @param bt
     */
    public static void PostOrder(BiTNode bt) {

        BiTNode p = bt;             //工作节点，用于访问每个节点

        BiTNode r = null;           //记录前一个被访问的节点

        Stack<BiTNode> st = new Stack<>();

        while (p != null || !st.isEmpty()) {
            if (p != null) {
                st.push(p);         //节点非空，则入栈
                p = p.lChild;       //指向左子树
            } else {
                p = st.peek();      //读栈顶元素
                if (p.rChild != null && p.rChild.equals(r) == false) {       //右孩子节点非空，且未被访问
                    p = p.rChild;   //转向右子树
                    st.push(p);	
                    p = p.lChild;   //再次指向左孩子
                } else {            //右子树为空，或已经访问过
                    p = st.pop();   //栈顶元素出栈
                    visit(p);
                    r = p;          //记录最近访问过的节点
                    p = null;       //注意：p需要置空
                }
            }
        }
    }

六、总结

先序遍历、中序遍历和后续遍历是二叉树相关问题的核心操作，也是很多题目的核心思想。其中后序遍历非递归算法应用场景有很多，例如：求根节点到某节点的路径、求两个节点的最近公共祖先等等。