前序遍历—递归方式

public void preOrder(BaseTreeNode node) {
    if(node == null){
        return;
    }else{
        System.out.println("前序递归:   " + node.getNode());
        preOrder(node.leftChild);
        preOrder(node.rightChild);
    }
}

中序遍历—递归方式

public void middleOrder(BaseTreeNode node) {
   if(node == null){
        return;
    }else{
        middleOrder(node.leftChild);
        System.out.println("中序递归:   " + node.getNode());
        middleOrder(node.rightChild);
    }
}

后序遍历—递归方式

public void postOrder(BaseTreeNode node) {
   if(node == null){
        return;
    }else{
        postOrder(node.leftChild);
        postOrder(node.rightChild);
        System.out.println("后序递归:   " + node.getNode());
    }
}

层序遍历—队列方式

public void tierOrder(BaseTreeNode node) {
    Queue<BaseTreeNode> queue = new LinkedList<>();
    if(node == null){
        return;
    }
    queue.offer(node);
    while(queue.peek()!=null){
        BaseTreeNode n = queue.poll();
        System.out.println("层序队列:   "  + n.getNode());
        if(n.leftChild != null){
            queue.offer(n.leftChild);
        }
        if(n.rightChild != null){
            queue.offer(n.rightChild);
        }
    }
}

层序遍历—队列方式并输出每层层级

public void tierOrderHasHeight(BaseTreeNode node) {
    int i = 0;
    BaseTreeNode parent = node;
    BaseTreeNode last = null;
    Queue<BaseTreeNode> queue = new LinkedList<>();
    if(node == null){
        return;
    }
    queue.offer(node);
    while(queue.peek()!=null){
        BaseTreeNode n = queue.poll();
        System.out.println("层序队列:   "  + n.getNode());
        if(n.leftChild != null){
            queue.offer(n.leftChild);
            last = n.leftChild;
        }
        if(n.rightChild != null){
            queue.offer(n.rightChild);
            last = n.rightChild;
        }
        if(parent == n){
            System.out.println(++i);
            parent = last;
        }
    }
}

前序遍历—栈方式1

public void nonPreOrder(BaseTreeNode node) {
    if (node == null)
        return;
    Stack<BaseTreeNode> stack = new Stack<>();
    while(node != null || !stack.empty()) {
        while(node != null) {
            System.out.println("前序栈:   " + node.getNode());
            stack.push(node);
            node = node.leftChild;
        }
        if(!stack.empty()) {
            node = stack.pop();
            node = node.rightChild;
        }
    }
}

前序遍历—栈方式2

//栈的思想，按层次倒着进栈，利用后进先出解决顺序问题
public static void nonPreOrder2(BaseTreeNode node) {
    if (node == null)
        return;
    Stack<BaseTreeNode> stack = new Stack<>();
    stack.push(node);
    while (!stack.empty()) {
        node = stack.pop();
        System.out.println("前序栈2:   " + node.getNode());
        if (node.rightChild != null)
            stack.push(node.rightChild);
        if (node.leftChild != null)
            stack.push(node.leftChild);
    }
}

中序遍历—栈方式

public void nonMiddleOrder(BaseTreeNode node) {
    Stack<BaseTreeNode> stack = new Stack<>();
    while(node != null || !stack.empty()) {
        while (node != null) {
            stack.push(node);
            node = node.leftChild;
        }
        if(!stack.empty()) {
            node = stack.pop();
            System.out.println("中序栈:   "+node.getNode());
            node = node.rightChild;
        }
    }
}

后序遍历—栈方式1

public void nonPostOrder(BaseTreeNode node) {
    if (node == null) return;
    Stack<BaseTreeNode> stack = new Stack<>();
    BaseTreeNode prev = node;
    while (node != null || !stack.empty()) {
        while (node != null) {
            stack.push(node);
            node = node.leftChild;
        }
        node = stack.peek().rightChild;
        if (node == null || node == prev) {
            //若栈顶节点的右节点为空或者已经输出过，则按顺序应该访问栈顶节点
            node = stack.pop();
            System.out.println("后序栈：   " + node.getNode());
            //prev用来标记已经输出过这个节点
            prev = node;
            node = null;
        }
    }
}

后序遍历—栈方式2

public void nonPostOrder2(BaseTreeNode node) {
    if (node == null) return;
    Stack<BaseTreeNode> stack = new Stack<>();
    BaseTreeNode prev = node;
    while (node != null) {
        while (node.leftChild != null) {
            stack.push(node);
            node = node.leftChild;
        }
        while (node != null && (node.rightChild == null || node.rightChild == prev)) {
            System.out.println("后序栈：   " + node.getNode());
            prev = node;
            if (stack.empty()) return;
            node = stack.pop();
        }
        stack.push(node);
        node = node.rightChild;
    }
}

后序遍历—栈方式3（双栈模式）

public void nonPostOrder3(BaseTreeNode node) {
   if (node == null) return;
    //用来调整顺序
    Stack<BaseTreeNode> stack = new Stack<>();
    //用来最终输出
    Stack<BaseTreeNode> result = new Stack<>();
    while (!stack.empty() || node != null) {
        while (node != null) {
            stack.push(node);
            result.push(node);
            node = node.rightChild;
        }
        if (!stack.empty()){
            node = stack.pop().leftChild;
        }
    }
    while (!result.empty()) {
        node = result.pop();
        System.out.println("后序栈：   " + node.getNode());
    }
}