IDEA 的确比eclipse强大不少，并且界面更加美观。参考胡昭明《图解数据结构java》

import java.io.*;
import java.util.*;

//二叉树节点类声明
class TreeNode {
    int value;
    TreeNode left_Node;
    TreeNode right_Node;
    // TreeNode构造函数
    public TreeNode(int value) {
        this.value=value;
        this.left_Node=null;
        this.right_Node=null;
    }
}
//二叉树类声明
class BinaryTree {
    public TreeNode rootNode; //二叉树的根节点
    public BinaryTree(int[] data){
        for(int i=0;i<data.length;i++)
            Add_Node_To_Tree(data[i]);
    }
    public BinaryTree(){

    }
    // 将指定的值加入到二叉树中适当的节点
    void Add_Node_To_Tree(int value) {
        TreeNode currentNode=rootNode;
        if(rootNode==null) { //建立树根
            rootNode=new TreeNode(value);
            return;
        }
        //建立二叉树
        while(true) {
            if (value<currentNode.value) { //在左子树
                if(currentNode.left_Node==null) {
                    currentNode.left_Node=new TreeNode(value);
                    return;
                }
                else currentNode=currentNode.left_Node;
            }
            else { //在右子树
                if(currentNode.right_Node==null) {
                    currentNode.right_Node=new TreeNode(value);
                    return;
                }
                else currentNode=currentNode.right_Node;
            }
        }
    }

    public void PreOrder(TreeNode node){
        if(node!=null){
            System.out.print("["+ node.value+"] ");
            PreOrder(node.left_Node);
            PreOrder(node.right_Node);
        }
    }

    public void PreOrder1(TreeNode node){
        if(node == null)
            return;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(node);
        while(!stack.isEmpty()){
            while(stack.peek()!=null){
                System.out.print("["+stack.peek().value+"] ");
                stack.push(stack.peek().left_Node);
            }
            TreeNode p = stack.pop();
            if(!stack.isEmpty()){
                p = stack.pop();
                stack.push(p.right_Node);
            }
        }
    }



    public void PostOrder(TreeNode node){
        if(node!=null){
            PostOrder(node.left_Node);
            PostOrder(node.right_Node);
            System.out.print("["+node.value+"] ");
        }
    }

    public void PostOrder1(TreeNode node){
        TreeNode q = node;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while(node!=null){
            for(;node.left_Node!=null;node = node.left_Node)
                stack.push(node);
            while(node!=null&&(node.right_Node==null)||node.right_Node==q){
                System.out.print("["+node.value+"] ");
                q = node;
                if(stack.empty())
                    return;
                node = stack.pop();
            }
            stack.push(node);
            node = node.right_Node;
        }

    }

    public void FindXAnCestor(TreeNode node,int x){
        TreeNode q = node;
        TreeNode bt;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while(node!=null){

            for(;node.left_Node!=null;node =node.left_Node){
                if(node.value == x){
                    while(!stack.isEmpty()){
                        bt = stack.pop();
                        System.out.print("{"+bt.value+"} ");
                    }
                    return;
                }
                stack.push(node);
            }
            while(node!=null&&(node.right_Node==null)||node.right_Node == q){
                q = node;
                if(stack.empty())
                    return;
                node = stack.pop();
            }
            if(node.value == x){
                while(!stack.isEmpty()){
                    bt = stack.pop();
                    System.out.print("{"+bt.value+"}");
                }
                return;
            }
            stack.push(node);
            node = node.right_Node;
        }
    }

    public void InOrder(TreeNode node){
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode p = node;
        while(p!=null||!stack.isEmpty()){
            if(p!=null){
                stack.push(p);
                p = p.left_Node;
            }else{
                p = stack.pop();
                System.out.print("["+p.value+"] ");
                p = p.right_Node;
            }
        }
    }

    public void LelvelOrder(TreeNode node){
       if(node == null)
           return;
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        TreeNode current = null;
        queue.offer(node);
        while(!queue.isEmpty()){
            current = queue.poll();
            System.out.print("["+current.value+"]");
            if(current.left_Node!=null)
                queue.offer(current.left_Node);
            if(current.right_Node!=null)
                queue.offer(current.right_Node);
        }
    }
}
public class Dog{
    //主函数
    public static void main(String args[]) throws IOException {
        int ArraySize=6;
        int tempdata;
        int[] content=new int[ArraySize];
        BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请连续输入"+ArraySize+"个数据");
        for(int i=0;i<ArraySize;i++) {
            System.out.print("请输入第"+(i+1)+"个数据: ");
            tempdata=Integer.parseInt(keyin.readLine());
            content[i]=tempdata;
        }
        BinaryTree tree = new BinaryTree(content);
        System.out.println("\n先序遍历二叉树");
        tree.PreOrder(tree.rootNode);
        System.out.println("\n先序遍历1二叉树");
        tree.PreOrder1(tree.rootNode);
        System.out.println("\n后序遍历二叉树");
        tree.PostOrder(tree.rootNode);
        System.out.println("\n中序遍历二叉树");
        tree.InOrder(tree.rootNode);
        System.out.println("\n后序遍历1二叉树");
        tree.PostOrder1(tree.rootNode);
        System.out.println("\n层次遍历");
        tree.LelvelOrder(tree.rootNode);
        System.out.print("\n找到x的祖先（假设x只有一个）\n");
        tree.FindXAnCestor(tree.rootNode,5);
    }
}