二叉树遍历，深度遍历和广度遍历的程序说明，及其应用

package test;

import com.sun.jmx.remote.internal.ArrayQueue;

import java.util.ArrayDeque;
import java.util.Queue;
import java.util.Stack;

public class TreeTraversal {

    /**
     * 树节点
     */
    public static class TreeNode{
        int value;
        TreeNode left;
        TreeNode right;
        public TreeNode(){

        }

        public TreeNode(int value){
            this.value = value;
        }

        public void visit(){
            System.out.print(value + " ");
        }
    }

    /**
     * 广度优先遍历(BFS)
     * @param root
     */
    public static void breadth1stTraversal(TreeNode root){
        if(root == null){
            return ;
        }
        Queue<TreeNode> treeNodeQueue = new ArrayDeque<TreeNode>();
        treeNodeQueue.add(root);
        /**
         * 首先将1压入堆中，queue(1)
         * 弹出1，压入（2,3）
         * 弹出2，压入（3,4,5）
         * 弹出3，3没有左右子节点
         * 弹出4，4没有左右子节点，
         * 弹出5，压入（6）
         * 弹出6，结束
         */
        while(!treeNodeQueue.isEmpty()){
            //从队列删除第一个元素poll()-->检索并移除此队列的头，如果为空则返回null
            /**
             * poll和remove的区别
             * 在数列为空的情况下，poll会返回null，而remove会抛出异常
             */
            TreeNode node = treeNodeQueue.poll();
            node.visit();
            if(node.left != null){
                treeNodeQueue.add(node.left);
            }
            if(node.right != null){
                treeNodeQueue.add(node.right);
            }
        }

    }

    /**
     *深度优先遍历(DFS)
     * @param root
     */
    public static void depth1stTraversal(TreeNode root){
        if(root == null){
            return ;
        }
        Stack<TreeNode> treeNodeStatck = new Stack<TreeNode>();
        treeNodeStatck.push(root);
        /**
         * 首先先将1压入堆中，stack(1)
         * 将1弹出，将1的子节点（3,2），压入堆内存中，根据栈是先进后出的原则，依次弹出2
         * 弹出2，将2的子节点（5，4），亚入堆中，此时堆中有（3，5，4），弹出4
         * 4节点之后没有子节点，所以弹出5，将6放入栈中（3,6）
         * 弹出6，后面没有子节点，
         * 弹出3，放入8（8）
         * 弹出8
         *
         */
        while(!treeNodeStatck.isEmpty()){
            TreeNode node = treeNodeStatck.pop();
            node.visit();
            if(node.right != null){
                treeNodeStatck.push(node.right);
            }
            if(node.left != null){
                treeNodeStatck.push(node.left);
            }
        }
    }

    public static TreeNode buildTestTree(){
        TreeNode treeNode1 = new TreeNode(1);
        TreeNode treeNode2 = new TreeNode(2);
        TreeNode treeNode3 = new TreeNode(3);
        TreeNode treeNode4 = new TreeNode(4);
        TreeNode treeNode5 = new TreeNode(5);
        TreeNode treeNode6 = new TreeNode(6);
        TreeNode treeNode7 = new TreeNode(7);
        /*TreeNode treeNode8 = new TreeNode(8);
        TreeNode treeNode9 = new TreeNode(9);
        TreeNode treeNode10 = new TreeNode(10);*/
        treeNode1.left = treeNode2;
        treeNode1.right = treeNode3;
        treeNode2.left = treeNode4;
        treeNode2.right = treeNode5;
        treeNode5.right = treeNode6;
        /*treeNode3.right = treeNode8;
        treeNode8.left = treeNode7;
        treeNode4.right = treeNode9;
        treeNode3.left = treeNode10;*/
        return treeNode1;
    }

    /**
     * 二叉树的格式
     *                   1
     *                /     \
     *              2        3
     *            /   \
     *          4      5
     *                  \
     *                   6
     *
     */

    /**
     * 广度遍历的结果是
     */
    public static void testBreadth1stTraversal(){
        breadth1stTraversal(buildTestTree());
    }

    public static void testDepth1stTraversal(){
        depth1stTraversal(buildTestTree());
    }

    //应用为，迷宫问题最短路径问题
    public static void main(String[] args){
        //广度遍历的结果为
        testBreadth1stTraversal();
        System.out.println();
        //深度遍历的结果为
        testDepth1stTraversal();

    }
}

二叉树遍历的应用，可以根据的二叉树的遍历，解决迷宫问题，找出最短途径，扩展延伸，可以解决通信问题。