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<array.length){  
            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<TreeNode> stack=new ArrayDeque<TreeNode>();  
        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<TreeNode> queue=new ArrayDeque<TreeNode>();  
        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    

注：深度优先(前、中、后序)可以使用递归、非递归实现；广度优先一般都采用非递归实现，递归不太好完成！