java-二叉树广度优先实现、深度优先之前序实现(非递归)

深度优先遍历--->栈；

广度优先遍历--->队列；

这里以二叉树为例来实现。

 import java.util.ArrayDeque;

 public class BinaryTree {
     static class TreeNode{
         int value;
         TreeNode left;
         TreeNode right;

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

     TreeNode root;

     public BinaryTree(int[] array){
         root=makeBinaryTreeByArray(array,1);
     }

     /**
      * 采用递归的方式创建一颗二叉树
      * 传入的是二叉树的数组表示法
      * 构造后是二叉树的二叉链表表示法
      */
     public static TreeNode makeBinaryTreeByArray(int[] array,int index){
         if(index
             int value=array[index];
             if(value!=0){
                 TreeNode t=new TreeNode(value);
                 array[index]=0;
                 t.left=makeBinaryTreeByArray(array,index*2);
                 t.right=makeBinaryTreeByArray(array,index*2+1);
                 return t;
             }
         }
         return null;
     }

     /**
      * 深度优先遍历，相当于先根遍历
      * 采用非递归实现
      * 需要辅助数据结构：栈
      */
     public void depthOrderTraversal(){
         if(root==null){
             System.out.println("empty tree");
             return;
         }
         ArrayDeque stack=new ArrayDeque();
         stack.push(root);
         while(stack.isEmpty()==false){
             TreeNode node=stack.pop();
             System.out.print(node.value+"    ");
             if(node.right!=null){
                 stack.push(node.right);
             }
             if(node.left!=null){
                 stack.push(node.left);
             }
         }
         System.out.print("\n");
     }

     /**
      * 广度优先遍历
      * 采用非递归实现
      * 需要辅助数据结构：队列
      */
     public void levelOrderTraversal(){
         if(root==null){
             System.out.println("empty tree");
             return;
         }
         ArrayDeque queue=new ArrayDeque();
         queue.add(root);
         while(queue.isEmpty()==false){
             TreeNode node=queue.remove();
             System.out.print(node.value+"    ");
             if(node.left!=null){
                 queue.add(node.left);
             }
             if(node.right!=null){
                 queue.add(node.right);
             }
         }
         System.out.print("\n");
     }

     /**
      *                  13
      *                 /  \
      *               65    5
      *              /  \    \
      *             97  25   37
      *            /    /\   /
      *           22   4 28 32
      */
     public static void main(String[] args) {
         int[] arr={0,13,65,5,97,25,0,37,22,0,4,28,0,0,32,0};
         BinaryTree tree=new BinaryTree(arr);
         tree.depthOrderTraversal();
         tree.levelOrderTraversal();
     }
 }
 运行结果：
 13    65    97    22    25    4    28    5    37    32     13    65    5    97    25    37    22    4    28    32