java实现二叉树的常见操作

树型结构是最常见的非线性结构，其中二叉树最为常见。今天我主要就是用java来实现一下树的一些常见操作。

       首先需要一个用来存储树节点值的javabean：

view plain
public class TreeBean { 
     
    private int nodeValue; 
     
    public int getNodeValue() { 
        return nodeValue; 
    } 
 
    public void setNodeValue(int nodeValue) { 
        this.nodeValue = nodeValue; 
    } 
} 
       然后是树的节点bean：

view plain
public class TreeNode{ 
 
    private TreeBean data; 
    private TreeNode leftNode; 
    private TreeNode rightNode; 
     
    //构造函数   
    public TreeNode(){   
        data = new TreeBean();   
    } 
     
    public TreeBean getData() { 
        return data; 
    } 
 
    public void setData(TreeBean data) { 
        this.data = data; 
    } 
 
    public TreeNode getLeftNode() { 
        return leftNode; 
    } 
    public void setLeftNode(TreeNode leftNode) { 
        this.leftNode = leftNode; 
    } 
    public TreeNode getRightNode() { 
        return rightNode; 
    } 
    public void setRightNode(TreeNode rightNode) { 
        this.rightNode = rightNode; 
    } 
 
} 
       最后是Tree的主体：

view plain
public class Tree { 
    //树的根节点 
    private TreeNode root; 
    public TreeNode getRoot() { 
        return root; 
    } 
    public void setRoot(TreeNode root) { 
        this.root = root; 
    } 
     
    //无参构造函数 
    Tree(){} 
     
    Tree(int nodeValue){ 
        root = new TreeNode(); 
        TreeBean nodeBean = new TreeBean();   
        nodeBean.setNodeValue(nodeValue); 
        root.setData(nodeBean); 
    } 
    /**
     * 销毁树，将树置空。
     * @author letthinking
     * @param tree
     * @return
     */ 
    public static Tree destroy(Tree tree){ 
        return null; 
    } 
    /**
     * 给树插入数据
     * @author letthinking
     * @param root
     * @param node
     */ 
    public void insert(TreeNode root,TreeNode node){ 
        //如果根节点为空，则赋值给根节点 
        if(root == null){ 
            root = node; 
        }else{ 
            //该节点与它的双亲节点比较，如果小于双亲节点，就将它作为左孩子，否则为右孩子。 
            if(node.getData().getNodeValue() < root.getData().getNodeValue()){ 
                //判断该节点是否为空，如果不为空就继续递归。 
                if(root.getLeftNode() == null){ 
                    root.setLeftNode(node); 
                }else{ 
                    insert(root.getLeftNode(),node); 
                } 
            }else{ 
                if(root.getRightNode() == null){ 
                    root.setRightNode(node); 
                }else{ 
                    insert(root.getRightNode(),node); 
                } 
            } 
        } 
    } 
     
    /**
     * 将树的所有节点清空
     * @author letthinking
     * @param root 树的根节点
     */ 
    public void clearTree(TreeNode root){ 
         
        if(root.getData() == null){ 
            if(root.getLeftNode() != null){ 
                clearTree(root.getLeftNode()); 
            } 
            if(root.getRightNode() != null){ 
                clearTree(root.getRightNode()); 
            }        
        }else{ 
            root.setData(null); 
            if(root.getLeftNode() != null){ 
                clearTree(root.getLeftNode()); 
            } 
            if(root.getRightNode() != null){ 
                clearTree(root.getRightNode()); 
            }    
        } 
    } 
     
    /**
     * 前序遍历二叉树  
     * @author letthinking
     * @param root
     * @return
     */ 
    public String middleIterator(TreeNode root){ 
        StringBuilder str = new StringBuilder(); 
        //判断节点是否为空 
        if(root == null){ 
            return str.toString(); 
        }else{ 
            //输出节点的值 
            if(root.getData() != null){ 
                str.append(root.getData().getNodeValue()+","); 
            }else{ 
                str.append("null,"); 
            } 
            //递归输出左孩子的值 
            str.append(middleIterator(root.getLeftNode())); 
            //递归输出右孩子的值 www.2cto.com
            str.append(middleIterator(root.getRightNode())); 
        } 
        return str.toString(); 
    } 
     
    /**
     * 后序遍历二叉树  
     * @author letthinking
     * @param root
     * @return
     */ 
    public String afterIterator(TreeNode root){ 
        StringBuilder str = new StringBuilder(); 
        //判断节点是否为空 
        if(root == null){ 
            return str.toString(); 
        }else{ 
            //递归输出左孩子的值 
            str.append(afterIterator(root.getLeftNode())); 
            //递归输出右孩子的值 
            str.append(afterIterator(root.getRightNode())); 
            //输出节点的值 
            if(root.getData() != null){ 
                str.append(root.getData().getNodeValue()+","); 
            }else{ 
                str.append("null,"); 
            } 
        } 
        return str.toString(); 
    } 
     
    /**
     * 求树的深度
     * @author letthinking
     * @param node
     * @return
     */ 
    public int treeDepth(TreeNode node){ 
        //定义两个变量用来存储左深度和右深度 
        int leftDepth = 0; 
        int rightDepth = 0; 
        if(node == null){ 
            return 0; 
        }else{ 
            leftDepth = treeDepth(node.getLeftNode())+1; 
            rightDepth = treeDepth(node.getRightNode())+1; 
        } 
        //返回值最大的深度 
        return leftDepth>=rightDepth?leftDepth:rightDepth; 
    } 
     
    public static void main(String [] args){ 
         
        //构造一个只有根节点的空树 
        Tree tree = new Tree(35); 
        //创建5个节点 
        TreeNode treeNode = new TreeNode(); 
        treeNode.getData().setNodeValue(23); 
        TreeNode treeNode1 = new TreeNode(); 
        treeNode1.getData().setNodeValue(56); 
        TreeNode treeNode2 = new TreeNode(); 
        treeNode2.getData().setNodeValue(45); 
        TreeNode treeNode3 = new TreeNode(); 
        treeNode3.getData().setNodeValue(12); 
        TreeNode treeNode4 = new TreeNode(); 
        treeNode4.getData().setNodeValue(37); 
        TreeNode treeNode5 = new TreeNode(); 
        treeNode5.getData().setNodeValue(19); 
        //插入树中 
        tree.insert(tree.root, treeNode); 
        tree.insert(tree.root, treeNode1); 
        tree.insert(tree.root, treeNode2); 
        tree.insert(tree.root, treeNode3); 
        tree.insert(tree.root, treeNode4); 
        tree.insert(tree.root, treeNode5); 
        //前序变量 
        String result = tree.middleIterator(tree.getRoot()); 
        System.out.println(result); 
        //后序序变量 
        result = tree.afterIterator(tree.getRoot()); 
        System.out.println(result); 
        //清空数所有节点的值 
        tree.clearTree(tree.getRoot()); 
        result = tree.middleIterator(tree.getRoot()); 
        System.out.println(result); 
        //得到树的深度 
        System.out.println(tree.treeDepth(tree.getRoot()));  
    } 
} 
       可能会有地方写的不对，希望大家给指出。