数据结构BinaryTree实例（一）:先序遍历二叉树（递归与非递归）

   二叉树的遍历是最基本的操作，本例实现二叉树的先序遍历。本例提供两种思维方式：递归与非递归。递归的实现非常简单，只给出简单的实现代码，主要实现非递归先序遍历直接用栈模拟递归。次将节点压入栈，然后弹出，压右子树，再压入左子树，在遍历过程中，遍历序列的右节点依次被存入栈，左节点逐次被访问。同一时刻，栈中元素为m-1个右节点和1个最左节点，最高为h。所以空间也为O(h)；每个节点同样被压栈一次，弹栈一次，访问一次，时间复杂度O(n)。

/**  

*@Title: PreOrderBinaryTree.java

*@Package binarytree

*@Description: TODO

*@author peidong 

*@date 2017-4-27 上午8:45:00

*@version V1.0  

*/

packagebinarytree;

importjava.util.Stack;

importbinarytree.Ancestors.TreeNode;

 

/**

 * @ClassName: PreOrderBinaryTree

 * @Description:先序遍历二叉树

 * @date 2017-4-27 上午8:45:00

 * 

 */

publicclass PreOrderBinaryTree {

       /**

       * @ClassName: TreeNode

       * @Description: 构建二叉树的结点

       * @date 2017-4-27 上午8:47:19

        */

       public static class TreeNode{

              public int data;

              public TreeNode left;

              public TreeNode right;

             

              public TreeNode(int data){

                     this.data = data;

                     left = null;

                     right = null;

              }

       }     

       /**

        *

       * @Title: preOrderRec

       * @Description: 递归先序遍历二叉树

       * @param @param root   

       * @return void   

       * @throws

        */

       void preOrderRec(TreeNode root){

              //判断树是否存在

              if(root == null){

                     return;

              }else{

                     System.out.println(root.data);

                     //递归左子树

                     preOrderRec(root.left);

                     //递归右子树

                     preOrderRec(root.right);

              }

       }      

       /**

        *

       * @Title: preOrder

       * @Description: 非递归先序遍历二叉树

       * @param @param root   

       * @return void   

       * @throws

        */

       @SuppressWarnings({ "null","null" })

       public void preOrder(TreeNode root) {

              //边界条件

              if(root == null){

                     return;

              }

              //初始化栈，记住一定要初始化，否则会报错空指针异常

              Stack<TreeNode> tnSatck=  new Stack<TreeNode>();

              if(root != null ){               

                     tnSatck.push(root);

              }

             

             

              while(tnSatck.empty() ==false){  //栈非空

                     TreeNode node =tnSatck.peek();  //赋值

                     System.out.println(node.data);  //输出数据

                     tnSatck.pop();                  //出栈

                    

                     //分别访问左右子树，并入栈,由于栈先入后出的特点，右子树先入栈

                     if(node.right != null){

                            tnSatck.push(node.right);

                     }

                     if(node.left != null){

                            tnSatck.push(node.left);

                     }

              }

       }

      

       /**

        *@Title: main

        *@Description: TODO

        *@param @param args   

        *@return void   

        *@throws

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

        // 此处该如何解决stack静态函数的空指针异常

              PreOrderBinaryTree tree = newPreOrderBinaryTree();

              TreeNode root = new TreeNode(10);

              root.left = new TreeNode(8);

              root.right = new TreeNode(2);

              root.left.left = new TreeNode(3);

              root.left.right = new TreeNode(5);

              root.right.left = new TreeNode(2);

             

              tree.preOrder(root);  //输出10-8-3-5-2-2

       }

}