递归与非递归遍历二叉树（各三种）

递归方法遍历

首先创建树的节点类

public class MyNode {
    private String value;
    private MyNode left;
    private MyNode reight;

    public MyNode(String value, MyNode left, MyNode reight) {
        this.value = value;
        this.left = left;
        this.reight = reight;
    }
    /**
     * 访问当前节点
     */
    public void visit() {System.out.println(value);}

    public MyNode getLeft() {
        return left;
    }

    public MyNode getReight() {
        return reight;
    }

}

我们构造的二叉树结构如下：

/**
 * 测试用的二叉树
 */
              |
              A
        |           |
        B           C
     |    |       |   |
     D    E       F   G
        |   |         |
        H   I         J

1. 先序遍历二叉树

public class PreVisitImpl implements VisitAll {
    /**
     * 先序遍历二叉树
     * 先访问中间节点，再访问左节点，再访问右节点
     */
    public void visitTree(MyNode node) {
        if(node ==null) {
            return ;
        }
        node.visit();
        visitTree(node.getLeft());
        visitTree(node.getReight());
    }
}

A B D E H I C F G J 

1. 中序遍历二叉树

/**
 * 中序遍历二叉树
 * 先访问左节点，再访问中间节点，再访问右节点
 */
public void visitTree(MyNode node) {
    if(node ==null) {
        return ;
    }
    visitTree(node.getLeft());
    node.visit();

    visitTree(node.getReight());
}

D B H E I A F C J G 

1. 后序遍历二叉树

/**
 * 后序遍历二叉树
 * 先访问左节点，再访问右节点，再访问中间节点
 */
public void visitTree(MyNode node) {
        if(node ==null) {
            return ;
        }
        visitTree(node.getLeft());
        visitTree(node.getReight());
        node.visit();
    }

D H I E B F J G C A 

非递归方法遍历

由于树的这种数据结构，无法通过自身的结构找到当前节点的父节点，所以，对于非递归方式遍历二叉树，采取的是，创建一个栈用于存放经过的节点，节点入栈，利用回溯的思想，当访问或者遍历到叶子节点的时候，将叶子节点出栈，返回到当前叶子节点的父节点。

1. 先序遍历二叉树

public void visitTree(MyNode node) {

    Deque<MyNode> deque = new ArrayDeque<MyNode>();

    while(node != null || deque.size() > 0) {

        while(node != null) {
            deque.push(node);
            node.visit();
            node =node.getLeft();

        }
        if(deque.size() >0) {
            node = deque.pop();
            node  =node.getReight();
        }
    }
}

1. 中序遍历二叉树

public void visitTree(MyNode node) {

    Deque<MyNode> deque = new ArrayDeque<MyNode>();

    while(node != null || deque.size() > 0) {

        while(node != null) {
            deque.push(node);
            node =node.getLeft();


        }
        if(deque.size() >0) {
            node = deque.pop();
            node.visit();
            node  =node.getReight();
        }
    }
}

1. 后序遍历二叉树

public void visitTree(MyNode node) {

    Deque<MyNode> deque = new ArrayDeque<MyNode>();
    MyNode preVisit =null;
    while(node != null || deque.size() > 0) {

        while(node != null) {
            deque.push(node);
            preVisit=node;
            node =node.getLeft();
        }
        //当前节点的右孩子如果为空或者已经被访问，则访问当前节点
        if(deque.size() >0) {
            node =deque.getFirst();
            if(node.getReight()==null ||node.getReight()==preVisit) {
                node.visit();
                preVisit =node ;
                deque.pop();
                node = null;

            }else {
                node=node.getReight();
            }
        }
    }
}