面试2

package com.tree;

import java.util.*;

/**
 * 实现对二叉树的遍历操作
 */
public class TreeOperate<T> {
    public static void main(String args[]) {
        TreeOperate<Integer> treeOperate = new TreeOperate<Integer>();
        TreeNode treeNode2 = treeOperate.addNode(null, 2, true);
        TreeNode treeNode3 = treeOperate.addNode(null, 3, false);

        TreeNode treeNode4 = treeOperate.addNode(treeNode2,4,true);
        treeOperate.addNode(treeNode2,8,false);

        treeOperate.addNode(treeNode3,6,true);
        treeOperate.addNode(treeNode3,12,false);

        treeOperate.addNode(treeNode4,7,true);
        treeOperate.addNode(treeNode4,9,false);
        List<TreeNode> treeNodeList = treeOperate.noInIterator();
        for (TreeNode treeNode : treeNodeList)
            System.out.print(treeNode + ",");
    }

    static class TreeNode {
        TreeNode parent;
        TreeNode left;
        TreeNode right;
        Object data;

        public TreeNode() {
        }

        public TreeNode(Object data) {
            this.data = data;
        }

        public TreeNode(TreeNode parent, TreeNode left, TreeNode right, Object data) {
            this.parent = parent;
            this.left = left;
            this.right = right;
            this.data = data;
        }

        @Override
        public String toString() {
            return "" +
                    "data=" + data
                    ;
        }
    }

    public TreeOperate() {
        root = new TreeNode();
    }

    //为指定节点添加子节点
    public TreeNode addNode(TreeNode parent, T data, boolean isLeft) {
        if (parent == null)
            parent = root;
        TreeNode treeNode = new TreeNode(data);
        if (isLeft)
            parent.left = treeNode;
        else
            parent.right = treeNode;
        treeNode.parent = parent;
        return treeNode;
    }

    /**
     * ****************   非递归遍历*******************************
     */
    //非递归先序遍历
    public List<TreeNode> noPreIterator() {
        List<TreeNode> list = new ArrayList<TreeNode>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode node = root;
        stack.push(node);
        while (node!=null&&!stack.isEmpty())
        {
            TreeNode t = stack.pop();
            list.add(t);
            if (t.right!=null)
                stack.push(t.right);
            if (t.left!=null)
                stack.push(t.left);

        }
        return list;
    }

    //非递归中序遍历
    public List<TreeNode> noInIterator()
    {
        List<TreeNode> list = new ArrayList<TreeNode>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode treeNode = root;

        while (treeNode!=null || !stack.isEmpty())
        {
            while (treeNode !=null)
            {
                stack.push(treeNode);
                treeNode = treeNode.left;
            }
            if (!stack.isEmpty())
            {
                treeNode = stack.pop();
                list.add(treeNode);
                treeNode = treeNode.right;
            }
        }
        return list;
    }
    // 非递归后序遍历
    public List<TreeNode> noPostIterator() {
        List<TreeNode> list = new ArrayList<TreeNode>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode node = root;
        TreeNode pre = root;
        while (node!=null||!stack.isEmpty())
        {

            //把左节点全部进行压栈
            while (node!=null)
            {
                stack.push(node);
                node = node.left;
            }
            if (stack.size()>0)
            {
                TreeNode temp = stack.peek().right;
                if (temp==null || temp==pre)
                {
                    node = stack.pop();
                    list.add(node);
                    pre = node;
                    node=null;
                }else
                {
                    node   = temp;
                }

            }

        }
        return list;
    }

    /**
     * ****************   递归遍历*******************************
     */
    private TreeNode root;

    //递归后序遍历
    public List<TreeNode> postIterator() {
        return postIterator(root);
    }

    private List<TreeNode> postIterator(TreeNode node) {
        List<TreeNode> list = new ArrayList<TreeNode>();

        //递归访问左子树
        if (node.left != null)
            list.addAll(postIterator(node.left));

        //递归访问右子树
        if (node.right != null)
            list.addAll(postIterator(node.right));
        //访问根节点
        list.add(node);
        return list;
    }

    //递归中序遍历
    public List<TreeNode> inIterator() {
        return inIterator(root);
    }

    private List<TreeNode> inIterator(TreeNode node) {
        List<TreeNode> list = new ArrayList<TreeNode>();

        //递归访问左子树
        if (node.left != null)
            list.addAll(inIterator(node.left));
        //访问根节点
        list.add(node);
        //递归访问右子树
        if (node.right != null)
            list.addAll(inIterator(node.right));
        return list;
    }

    ;

    //递归先序遍历
    public List<TreeNode> preIterator() {
        return preIterator(root);
    }

    private List<TreeNode> preIterator(TreeNode node) {

        List<TreeNode> list = new ArrayList<TreeNode>();
        //先访问根节点
        list.add(node);
        //递归访问左子树
        if (node.left != null)
            list.addAll(preIterator(node.left));
        //递归访问右子树
        if (node.right != null)
            list.addAll(preIterator(node.right));
        return list;
    }

}