递归和非递归遍历二叉树

树的定义

package tree;

import javax.swing.tree.TreeNode;

public class BinaryTreeNode {
    int value=0;
    BinaryTreeNode leftNode=null;
    BinaryTreeNode rightNode=null;

}

递归方式实现前序遍历，中序遍历，后序遍历

package tree;

import javax.swing.tree.TreeNode;

import tree.BinaryTreeNode;
import tree.Depth_binarytree;

/**
 * 递归方式实现二叉树打印
 * @author Administrator
 *
 */

public class BinaryTree {
    public static void main(String[] args) throws Exception{
        BinaryTreeNode root1=new BinaryTreeNode();
        BinaryTreeNode node1=new BinaryTreeNode();
        BinaryTreeNode node2=new BinaryTreeNode();
        BinaryTreeNode node3=new BinaryTreeNode();
        BinaryTreeNode node4=new BinaryTreeNode();
        BinaryTreeNode node5=new BinaryTreeNode();
        BinaryTreeNode node6=new BinaryTreeNode();

        root1.leftNode=node1;
        root1.rightNode=node2;
        node1.leftNode=node3;
        node1.rightNode=node4;
        node3.leftNode=node5;
        node3.rightNode=node6;
        root1.value=1;
        node1.value=2;
        node2.value=3;
        node3.value=4;
        node4.value=5;
        node5.value=6;
        node6.value=7;
        BinaryTree test=new BinaryTree();
        //递归方式实现前序，中序，后序排序。
        test.preorder(root1);
        //test.inorder(root1);
        //test.posorder(root1);
    }



    /**
     * 前序遍历
     * @param root
     */
    public void preorder(BinaryTreeNode root){

        if(root==null) return;
        System.out.println(root.value);
        preorder(root.leftNode);
        System.out.println("node"+root.value+" finish scanning left");  

        preorder(root.rightNode);
        System.out.println("node"+root.value+" finish scanning right");  

    }

    /**
     *中序遍历
     * @param root
     */
    public void inorder(BinaryTreeNode root){

        if(root==null) return;

        inorder(root.leftNode);
        System.out.println(root.value);

        inorder(root.rightNode);

    }

    /**
     * 后序遍历
     * @param root
     */
    public void posorder(BinaryTreeNode root){

        if(root==null) return;
        posorder(root.leftNode);
        posorder(root.rightNode);
        System.out.println(root.value);
    }
}

非递归方式实现前序遍历，中序遍历，后序遍历

package tree;

import java.util.Stack;

import javax.swing.tree.TreeNode;

import tree.BinaryTreeNode;
import tree.Depth_binarytree;

/**
 * 非递归方式实现二叉树打印
 * @author Administrator
 *
 */

public class BinaryTree1 {
    public static void main(String[] args) throws Exception{
        BinaryTreeNode root1=new BinaryTreeNode();
        BinaryTreeNode node1=new BinaryTreeNode();
        BinaryTreeNode node2=new BinaryTreeNode();
        BinaryTreeNode node3=new BinaryTreeNode();
        BinaryTreeNode node4=new BinaryTreeNode();
        BinaryTreeNode node5=new BinaryTreeNode();
        BinaryTreeNode node6=new BinaryTreeNode();

        root1.leftNode=node1;
        root1.rightNode=node2;
        node1.leftNode=node3;
        node1.rightNode=node4;
        node3.leftNode=node5;
        node3.rightNode=node6;
        root1.value=1;
        node1.value=2;
        node2.value=3;
        node3.value=4;
        node4.value=5;
        node5.value=6;
        node6.value=7;
        BinaryTree1 test=new BinaryTree1();
        //递归方式实现前序，中序，后序排序。
        //test._preorder(root1);
        //test._inorder(root1);
        test._posorder(root1);
    }

    /**
     * 非递归前序遍历
     * @param root
     */
    public void _preorder(BinaryTreeNode root){
        Stack<BinaryTreeNode> stack=new Stack<BinaryTreeNode>();
        while(!(root==null && stack.isEmpty())){
            if(root!=null){
                System.out.println(root.value);
                stack.push(root);
                root=root.leftNode;
            }else{
                root=stack.pop();
                root=root.rightNode;
                }
            }   
        }

    /**
     * 非递归中序遍历
     * @param root
     */
    public void _inorder(BinaryTreeNode root){
        Stack<BinaryTreeNode> stack=new Stack<BinaryTreeNode>();
        while(!(root==null && stack.isEmpty())){

            while(root!=null){
                //找到当前节点最深的左子树
                stack.push(root);
                root=root.leftNode;
            }
                root=stack.pop();
                System.out.println(root.value);
                root=root.rightNode;
            }
        }


        /**
         * 非递归方式后序遍历
         * 非递归的后续遍历需要两次访问节点，最后一次访问节点为准
         */
        private int sign=0;
        public void _posorder(BinaryTreeNode root){
            Stack stack=new Stack();//定义一个可以存放TreeNode和Integer的栈
            while(!(root==null && stack.isEmpty())){
                if(root!=null){//找最深的左子树
                    stack.push(root);
                    stack.push(1);
                    root=root.leftNode;
                }else{
                    while(!stack.isEmpty()){
                        sign=(Integer)stack.pop();
                        root=(BinaryTreeNode)stack.pop();
                        if(sign==1){//第一次访问节点
                            stack.push(root);
                            stack.push(2);
                            root=root.rightNode;
                            break;
                        }else if(sign==2){
                            System.out.println(root.value);
                            root=null;
                        }
                    }
                }
            }
        }
    }