二叉树-递归遍历-栈遍历（深度优先)-队列（广度优先）

 前序：头左右

中序：左头右

后续：左右头

代码

package 算法;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class 二叉树遍历 {

    /**
     * 树节点
     */
    public static class Node{
        public Node left;
        public Node right;
        public String str;

        public Node(String str) {
            this.str = str;
        }
    }
    public static Node getTree(){
        Node nodeA = new Node("A");
        Node nodeB = new Node("B");
        Node nodeC = new Node("C");
        Node nodeD = new Node("D");
        Node nodeE = new Node("E");
        Node nodeF = new Node("F");
        Node nodeG = new Node("G");
        /**
         *    A
         *  B   C
         * D E F G
         */
        nodeA.left = nodeB;
        nodeA.right = nodeC;
        nodeB.left = nodeD;
        nodeB.right = nodeE;
        nodeC.left =nodeF;
        nodeC.right = nodeG;
        return nodeA;
    }




    public static void main(String[] args) {
        //1 构建一棵树
        Node node = getTree();
        /**
         *    A
         *  B   C
         * D E F G
         */
        String qx="ABDECFG";
        String zx="DBEAFCG";
        String hx="DEBFGCA";
        //2 遍历-递归版

        //2.1 前序遍历-递归版
        if (beforeRecursive(node,new StringBuffer()).toString().equals(qx)) {
            System.out.println("前序遍历-递归版 正确");
        }
        //2.2 中序遍历-递归版
        if (middleRecursive(node,new StringBuffer()).toString().equals(zx)) {
            System.out.println("前序遍历-递归版 正确");
        }
        //2.3 后续遍历-递归版
        if (afterRecursive(node,new StringBuffer()).toString().equals(hx)) {
            System.out.println("前序遍历-递归版 正确");
        }

        //3 遍历-非递归版-栈
        //3.1 前序遍历-非递归版-栈
        if (beforeStack(node).equals(qx)) {
            System.out.println("前序遍历-栈版 正确");
        }

        //3.2 中序遍历-非递归版-栈
        if (middleStack(node).equals(zx)) {
            System.out.println("前序遍历-栈版 正确");
        }
        //3.3 后续遍历-非递归版-栈
        if (afterStack(node).equals(hx)) {
            System.out.println("前序遍历-栈版 正确");
        }
        //4.1 队列 广度遍历
        if (breadth(node).equals("ABCDEFG")) {
            System.out.println("广度遍历 正确");
        }

    }

    /**
     * 深度遍历
     * @param node
     * @return
     */
    private static Object breadth(Node node) {
        StringBuffer sb = new StringBuffer();
        Queue<Node> queue = new LinkedList();
        queue.add(node);
        while (queue.peek()!=null){
            Node node1 =  queue.poll();
            sb.append(node1.str);
            queue.add(node1.left);
            queue.add(node1.right);
        }
        return sb.toString();
    }


    /**
     * 递归前序遍历 -栈
     * @param node
     */
    private static String beforeStack(Node node) {
        StringBuffer sb = new StringBuffer();
        //先进先出
        Stack<Node> stack = new Stack<>();
        stack.push(node);
        while (!stack.empty()){
            Node n = stack.pop();
            sb.append(n.str);
            if (n.right != null) {
                stack.push(n.right);
            }
            if (n.left != null) {
                stack.push(n.left);
            }
        }
        return sb.toString();
    }

    /**
     * 递归中序遍历 -栈
     * @param node
     */
    private static Object middleStack(Node node) {
        StringBuffer sb = new StringBuffer();
        if(node!=null){
            Stack<Node> stack = new Stack<Node>();
            // 1 先找最左
            // 2 输出之后看右节点 如果有就继续找最左 如果没有说明下一个应该是 栈里面的下一个pop
            while (!stack.isEmpty()||node!=null){
                //一直找left直到为空
                if (node != null) {
                    stack.push(node);
                    node = node.left;
                }else{
                    //拿出最左边的那个 输出 （ 这个 时候 如果 right 有输出的就是中节点 如果没有就是输出的左节点）
                    node=stack.pop();
                    sb.append(node.str);
                    node = node.right;
                }
            }
        }
        return sb;
    }

    /**
     * 递归后序遍历 -栈
     * @param node
     */
    private static Object afterStack(Node node) {
        StringBuffer sb = new StringBuffer();
        //先进先出
        Stack<Node> stack = new Stack<>();
        Stack<Node> stack1 = new Stack<>();
        stack.push(node);
        while (!stack.empty()){
            Node n = stack.pop();
            // 前序 是头左右   后续是左右头  先将left right 循序调换 头右左   左头右
            // 这里加另外一个栈 在输出正好是前序调换后的逆序 就是后续
            stack1.push(n);
            if (n.left != null) {
                stack.push(n.left);
            }
            if (n.right != null) {
                stack.push(n.right);
            }

        }
        while (!stack1.empty()){
            sb.append(stack1.pop().str);
        }
        return sb.toString();
    }


    /**
     * 递归前序遍历
     * @param node
     */
    private static StringBuffer beforeRecursive(Node node,StringBuffer sb) {
        sb.append(node.str);
        if (node.left != null) {
             beforeRecursive(node.left,sb);
        }
        if (node.right != null) {
            beforeRecursive(node.right,sb);
        }
        return sb;
    }

    /**
     * 递归中序遍历
     * @param node
     */
    private static StringBuffer middleRecursive(Node node,StringBuffer sb) {

        if (node.left != null) {
            middleRecursive(node.left,sb);
        }
        sb.append(node.str);
        if (node.right != null) {
            middleRecursive(node.right,sb);
        }
        return sb;
    }
    /**
     * 递归后序遍历
     * @param node
     */
    private static StringBuffer afterRecursive(Node node,StringBuffer sb) {

        if (node.left != null) {
            afterRecursive(node.left,sb);
        }
        if (node.right != null) {
            afterRecursive(node.right,sb);
        }
        sb.append(node.str);
        return sb;
    }

}