数据结构与算法：二叉树的先序遍历（递归与非递归方法）

数据结构与算法：二叉树的先序遍历（递归与非递归方法） 

public class BinaryTree<E> {
    private TreeNode<E> root;  //根节点
    private List<TreeNode> nodeList = null;   //二叉树节点的链式结构
    
    public BinaryTree(){
        
    }
    
    public BinaryTree(TreeNode<E> root){
        this.root = root;
    }
    
    //把一个数组转化为一颗完全二叉树
    public TreeNode<E> buildTree(E[] array){
        nodeList = new LinkedList<TreeNode>();        
        //将数组中的元素依次转换为TreeNode节点，存放于链表中
        for(int i=0; i< array.length; i++){
            nodeList.add(new TreeNode(array[i]));  
        }
        //对前（array.length / 2 - 1）个父节点，按照父节点与孩子节点的数字关系建立完全二叉树
        //对完全二叉树，按从上到下，从左到右的顺序依次编号0,1,2,3....N,则i>0的节点，其左孩子为（2*i+1），
        //其右孩子为（2*i+2）
        for(int j=0; j < (array.length/2-1);j++){
            //左孩子
            nodeList.get(j).setLchild(nodeList.get(j*2+1));
            //右孩子
            nodeList.get(j).setRchild(nodeList.get(j*2+2));
        }
        //最后一个父节点：因为最后一个父节点可能没有右孩子，所以单独处理
        int index = array.length/2 -1;
        //左孩子
        nodeList.get(index).setLchild(nodeList.get(index*2+1));
        //右孩子：如果数组的长度为奇数才有右孩子
        if(array.length % 2 == 1){
            nodeList.get(index).setRchild(nodeList.get(index*2+2));
        }
        root=nodeList.get(0); //设置根节点
        return root;
    }
    
    //得到树的高度
    public int height(TreeNode<E> node){
        if(node == null){
            return 0;
        }else{
            int i = height(node.getLchild());
            int j = height(node.getRchild());
            return (i<j)?(j+1):(i+1);
        }
    }
    
    //得到节点的个数
    public int size(TreeNode<E> node){
        if(node == null){
            return 0;
        }else{
            return 1+ size(node.getLchild())+size(node.getRchild());
        }
    }
    
    //递归实现先序遍历 NLR
    public void preOrder(TreeNode<E> node){
        if(node != null){
            System.out.print(node.getData() + " ");
            preOrder(node.getLchild());
            preOrder(node.getRchild());
        }
    }
    //非递归实现先序遍历 NLR
    public void nonRecPreOrder(TreeNode<E> node){
        Stack<TreeNode<E>> nodeStack = new Stack<TreeNode<E>>();
        TreeNode<E> nodeTemp = node; //nodeTemp作为遍历指针
        while(nodeTemp != null || !nodeStack.isEmpty()){   //当nodeTemp非空或栈非空时循环
            if(nodeTemp != null){   //根指针非空，遍历左子树
                nodeStack.push(nodeTemp);   //根指针进栈
                System.out.print(nodeStack.peek().getData() + " "); //根指针退栈，访问根节点
                nodeTemp = nodeTemp.getLchild();  //每遇到非空二叉树先向左走
            }else{ //再向右子树走
                nodeTemp = nodeStack.pop();
                nodeTemp = nodeTemp.getRchild();
            }
        }    
    }
}