2、二叉树：递归遍历

　　

对二叉树而言，最为核心的操作就是遍历。遍历可以用递归的方式，也可以用循环的方式。

就递归遍历而言，又有“先序、中序、后续”三种不同的遍历顺序。通过下面的一个示意图可以从感官上来体会一下三种不同的遍历顺序：

为了学习二叉树的相关算法，首先需要构建一个二叉树的抽象类public abstract class BiTreeAbstract<T> ，该类中有一个表示结点的内部类Node，将结点的数据类型定义为泛型T以方便将其用于不同的数据类型。

package com.magicode.datastructure.tree;

public abstract class BiTreeAbstract<T> {
    /**
     * 树的根节点。
     */
    private Node root;

    /**
     * 具体的构建二叉树方法。 如果构建成功，则返回二叉树的根节点(Node)； 如果构建失败，则范湖null。
     * 
     * @return 二叉树的根节点Node
     */
    abstract protected Node initMethod();

    /**
     * 访问二叉树中的元素节点。 如果需要终止遍历，则返回false；如果需要继续遍历下去，则返回true。
     * 
     * @return
     */
    abstract protected boolean visitElem(Node node);

    /**
     * 创建一个二叉树，在此方法中具体调用抽象方法initMethod来 创建一个二叉树。
     * 
     * @return
     */
    public boolean createBiTree() {
        root = initMethod();
        if (root != null) {
            return true;
        }
        return false;
    };

    /**
     * 递归的“先序”遍历二叉树</br> 具体会调用抽象方法visitElem来具体处理遍历过程中的元素。
     * 
     * @return 遍历成功，则返回true。遍历失败，返回false。
     */
    public boolean preOrderTraverse() {
        return preTraverse(root);
    }

    private boolean preTraverse(Node node) {
        if (node == null) {
            return true;
        }
        // 改变下面三条if语句的先后关系，就可以实现“中序”和“后序”递归遍历
        if (visitElem(node))
            if (preTraverse(node.lchild))
                if (preTraverse(node.rchild))
                    return true;
        return false;
    }

    public Node getRoot() {
        return root;
    }

    /**
     * 节点结构
     */
    protected class Node {

        private T elem;
        private Node lchild;
        private Node rchild;

        public Node() {
        }

        public Node(T elem) {
            this.elem = elem;
            lchild = null;
            rchild = null;
        }

        public T getElem() {
            return elem;
        }

        public Node getLchild() {
            return lchild;
        }

        public Node getRchild() {
            return rchild;
        }

        public void setElem(T elem) {
            this.elem = elem;
        }

        public void setLchild(Node lchild) {
            this.lchild = lchild;
        }

        public void setRchild(Node rchild) {
            this.rchild = rchild;
        }

    }

}

抽象类中定义了两个功能方法：

①、public boolean createBiTree()用于构建一个二叉树，在该方法中会调用abstract protected Node initMethod()方法来具体的对构建二叉树； 

②、public boolean preOrderTraverse()方法的功能是先序递归的方法来遍历二叉树，它会调用抽象方法abstract protected boolean visitElem(Node node)在遍历过程对访问的当前节点进行处理，如果想在某个结点处终止遍历，只需要在visitElem方法中返回一个false即可。

下面是一个具体的实现类，它会构建一个满二叉树：

package com.magicode.datastructure.tree;

public class BiTree extends BiTreeAbstract<Integer> {

    private int n = 0;
    private String[] dat = "1|2|3|4|0|0|5|0|0|6|7|0|0|8|0|0|9|10|11|0|0|12|0|0|13|14|0|0|15|0|0".split("\|");
    
    private Node create(String[] str) {
        Integer ele = Integer.parseInt(str[n]);
        n++;
        //0表示该孩子节点为null
        if(ele == 0){
            return null;
        }
        Node nod = new Node(ele);
        //先构建左孩子，后构建右孩子。构建顺序于先序遍历是一致的。
        nod.setLchild(create(str));
        nod.setRchild(create(str));
        return nod;
    }

    @Override
    protected Node initMethod() {
        Node nd = create(dat);
        return nd;
    }

    @Override
    protected boolean visitElem(Node node) {
        System.out.print(node.getElem() + " ");
        return true;
    }
    
    public static void main(String[] args) {
        BiTree tree = new BiTree();
        System.out.println(tree.createBiTree());
        
        System.out.println();
        System.out.println("--------先序遍历------");
        tree.preOrderTraverse();
        
    }

}

运行测试结果（中序和后序只需要依据代码说明进行修改即可实现）：