java版数据结构与算法—二叉树遍历

package com.zoujc.tree;

import java.util.LinkedList;
import java.util.Stack;

/**
 * 二叉树遍历
 */
public class Binaryorder {
    private TreeNode root; //根节点
    public Binaryorder()
    {

    }
    public Binaryorder(TreeNode root)
    {
        this.root=root;
    }
    public TreeNode getRoot()
    {
        return root;
    }
    public void setRoot(TreeNode root)
    {
        this.root=root;
    }
    /*
     * 递归 前序遍历
     */
    public void preOrder(TreeNode node)
    {
        if(node!=null)
        {
            System.out.print(node.getdata()+" ");
            preOrder(node.getleft());
            preOrder(node.getright());
        }
    }
    /*
     * 递归 中序遍历
     */
    public void inOrder(TreeNode node)
    {
        if(node!=null)
        {
            inOrder(node.getleft());
            System.out.println(node.getdata()+" ");
            inOrder(node.getright());
        }
    }
    /*
     * 递归 后序遍历
     */
    public void postOrder(TreeNode node)
    {
        if(node!=null)
        {
            postOrder(node.getleft());
            postOrder(node.getright());
            System.out.println(node.getdata()+" ");
        }
    }

    /*
     * 非递归 前序遍历
     */
    public void preOrdernorec(TreeNode root)
    {
        LinkedList<TreeNode> list= new LinkedList<TreeNode>();
        list.push(root);
        TreeNode cur=null;
        while(!list.isEmpty())
        {
            cur=list.poll();  //!!!
            System.out.print(cur.getdata()+" ");
            if(cur.getright()!=null)
                list.push(cur.getright()); //!!!
            if(cur.getleft()!=null)
                list.push(cur.getleft()); //这里使用push就是当做栈在使用，如果换成add就不是这样的输出
        }
    }
    /*
     * 非递归 中序遍历
     */
    public void inordernocur(TreeNode root)
    {
        LinkedList<TreeNode> list= new LinkedList<TreeNode>();
        TreeNode cur=root;
        while(cur!=null||! list.isEmpty())
        {
            while(cur!=null)
            {
                list.push(cur);
                cur=cur.getleft();
            }
            if(!list.isEmpty())
            {
                cur=list.pop();
                System.out.println(cur.getdata()+" ");
                cur=cur.getright();
            }
        }
    }

    /*
     * 非递归 后序遍历  单栈法
     */
    public void postordernocur(TreeNode root)
    {
        Stack<TreeNode> stack= new Stack<TreeNode>();
        TreeNode cur=root;
        TreeNode node=root;
        while(cur!=null||!stack.isEmpty())
        {
            while(cur!=null)
            {
                stack.push(cur);
                cur=cur.getleft();
            }
            if(stack.size()>0)
            {
                TreeNode temp=stack.peek().getright();

                if(temp==null||temp==node)//注意第二个条件
                {
                    cur=stack.pop();
                    System.out.print(cur.getdata()+" ");
                    node=cur;
                    cur=null;
                }
                else
                    cur=temp;

            }
        }
    }

    /*
     * 双栈法
     */
    public void postordernocur2(TreeNode root)
    {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        Stack<TreeNode> temp = new Stack<TreeNode>();
        TreeNode node=root;
        while(node!=null||stack.size()>0)
        {
            while(node!=null)
            {
                temp.push(node);
                stack.push(node);
                node=node.getright();
            }
            if(stack.size()>0)
            {
                node=stack.pop();
                node=node.getleft();
            }
        }
        while(temp.size()>0)
        {
            node=temp.pop();
            System.out.print(node.getdata()+" ");
        }
    }

    //主函数
    public static void main(String[] args) {

        Binaryorder b =new Binaryorder();
        //构造二叉树
        TreeNode l2=new TreeNode("E",null,null);
        TreeNode r2=new TreeNode("D",null,null);
        TreeNode l1=new TreeNode("B",null,r2);
        TreeNode r1=new TreeNode("C",l2,null);
        TreeNode root=new TreeNode("A",l1,r1);

        b.postOrder(root);
        System.out.println("----");
        b.postordernocur(root);
    }
}


//节点类
class TreeNode
{
    private String data=null;//数据部分
    private TreeNode left;
    private TreeNode right;
    public TreeNode(String data,TreeNode left,TreeNode right)
    {
        this.data=data;
        this.left=left;
        this.right=right;
    }
    public String getdata()
    {
        return data;
    }
    public void setdata(String data)
    {
        this.data=data;
    }
    public TreeNode getleft()
    {
        return left;
    }
    public void setleft(TreeNode left)
    {
        this.left=left;
    }
    public TreeNode getright()
    {
        return right;
    }
    public void setright(TreeNode right)
    {
        this.right=right;
    }
}