JAVA实现二叉树(简易版--实现了二叉树的各种遍历)

1，个人感觉二叉树的实现主要还是如何构造一颗二叉树。构造二叉树函数的设计方法多种多样，本例采用 addNode 方法实现。以下程序通过定义内部类来表示二叉树的结点，然后再实现了二叉树这种数据结构的一些基本操作。

 2，说说以下程序的一些不足：

 a，56行中的判断树是否为空时，依据根结点的数据域是否为空来判断。而使用不带参数的构造函数构造二叉树时，根结点的不空的，此时说明树已经有了根结点，但是根结点的数据却是空的，此时的树高度为1，但是不能访问树根结点，因为树根结点的数据域没有值。

3，重点讲解下二叉树遍历的几个方法：

先序遍历：将先序遍历过程中遇到的结点添加到ArrayList<TreeNode>中。根据先序遍历的递归的性质，调用addAll(Container c)方法完成遍历主要过程。

层序遍历：层序遍历需要使用队列，方法level_Traverse 中定义了ArrayDeque<TreeNode> 类型的队列。

package tree;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;

public class BinaryTree<E> {
    //为什么要用静态内部类？静态内部类中不能访问外部类的非静态成员
    public static class TreeNode{
//        E data;
        Object data;
        TreeNode left;
        TreeNode right;
        public TreeNode(){
            
        }
        public TreeNode(Object data){
            this.data = data;
        }
        //构造一个新节点，该节点以left节点为其左孩子，right节点为其右孩子
        public TreeNode(Object data, TreeNode left, TreeNode right){
            this.data = data;
            this.left = left;
            this.right = right;
        }
    }
    
    private TreeNode root;//实现二叉树的类的数据域，即根结点来表示二叉树
    
    public BinaryTree(){
        this.root = new TreeNode();
    }
    //以指定的根元素创建一颗二叉树
    public BinaryTree(E data){
        this.root = new TreeNode(data);
    }
    
    //为指定的结点添加子结点,为什么要有addNode方法？因为给定一系列的结点，通过调用该方法来构造成一颗树
    public TreeNode addNode(TreeNode parent, E data, boolean isLeft){
        if(parent == null)
            throw new RuntimeException("父节点为空，无法添加子结点");
        if(isLeft && parent.left != null)
            throw new RuntimeException("节点已经左子节点，添加失败");
        if(!isLeft && parent.right != null)
            throw new RuntimeException("节点已经有右子节点，添加失败");
        TreeNode newNode = new TreeNode(data);
        if(isLeft)
            parent.left = newNode;
        else
            parent.right = newNode;
        return newNode;
    }
    
    public boolean empty(){
        return root.data == null;//根据根元素判断二叉树是否为空
    }
    
    public TreeNode root(){
        if(empty())
            throw new RuntimeException("树空，无法访问根结点");
        return root;
    }
    
    public E parent(TreeNode node){
        return null;//采用二叉树链表存储时，访问父结点需要遍历整棵二叉树，因为这里不实现
    }
    
    //访问指定节点的左结点，返回的是其左孩子的数据域
    public E leftChild(TreeNode parent){
        if(parent == null)
            throw new RuntimeException("空结点不能访问其左孩子");
        return parent.left == null ? null : (E)parent.left.data;
    }
    public E rightChild(TreeNode parent){
        if(parent == null)
            throw new RuntimeException("空结点不能访问其右孩子");
        return parent.right == null ? null : (E)parent.right.data;
    }
    
    public int deep(){
        return deep(root);
    }
    private int deep(TreeNode node){
        if(node == null)
            return 0;
        else if(node.left == null && node.right == null)
            return 1;
        else{
            int leftDeep = deep(node.left);
            int rightDeep = deep(node.right);
            int max = leftDeep > rightDeep ? leftDeep : rightDeep;
            return max + 1;
        }
    }
    
    /*二叉树的先序遍历，实现思想如下：树是一种非线性结构，树中各个结点的组织方式有多种方式
     * 先序，即是一种组织方式。它将结点的非线性变成了按照某种方式组织成的线性结构
     */
    //返回一个list，树中结点以先序的方式存放在该list中
    public List<TreeNode> preTraverse(){
        return preOrderTraverse(root);
    }
    private List<TreeNode> preOrderTraverse(TreeNode node){
        List<TreeNode> list = new ArrayList<TreeNode>();
        list.add(node);
        if(node.left != null)
            list.addAll(preOrderTraverse(node.left));//递归的奇妙之处
        if(node.right != null)
            list.addAll(preOrderTraverse(node.right));
        return list;
    }
    
    //中序遍历
    public List<TreeNode> inTraverse(){
        return inOrderTraverse(root);
    }
    private List<TreeNode> inOrderTraverse(TreeNode node){
        List<TreeNode> list = new ArrayList<TreeNode>();
        if(node.left != null)
            list.addAll(inOrderTraverse(node.left));
        list.add(node);
        if(node.right != null)
            list.addAll(inOrderTraverse(node.right));
        return list;
    }
    
    //后序遍历
    public List<TreeNode> postTraverse(){
        return post_Traverse(root);
    }
    private List<TreeNode> post_Traverse(TreeNode node){
        List<TreeNode> list = new ArrayList<TreeNode>();
        if(node.left != null)
            list.addAll(post_Traverse(node.left));
        if(node.right != null)
            list.addAll(post_Traverse(node.right));
        list.add(node);
        return list;
    }
    
    //层序遍历
    public List<TreeNode> levelTraverse(){
        return level_Traverse(root);
    }
    private List<TreeNode> level_Traverse(TreeNode node){
        Queue<TreeNode> queue = new ArrayDeque<TreeNode>();
        List<TreeNode> list = new ArrayList<TreeNode>();//按层序遍历定义的顺序将树中结点依次添加到数组列表中
        if(root != null)//先将根结点入队列
            queue.offer(root);
        while(!queue.isEmpty())//队列不空时，说明遍历还未结束
        {
            list.add(queue.peek());//将队头元素添加到数组列表中
            TreeNode p = queue.poll();//队头元素出队列
            if(p.left != null)
                queue.offer(p.left);//队头元素的左孩子入队列
            if(p.right != null)
                queue.offer(p.right);//队头元素的右孩子入队列
        }
        return list;
    }
}

 

测试遍历的程序如下：

import java.util.ArrayList;
import java.util.List;

public class BinaryTreeTest {
    public static void main(String[] args) {
        BinaryTree<String> bt = new BinaryTree<String>("根节点");
        BinaryTree.TreeNode tn1 = bt.addNode(bt.root(),"第二层左子结点", true);
        BinaryTree.TreeNode tn2 = bt.addNode(bt.root(), "第二层右子结点", false);
        BinaryTree.TreeNode tn3 = bt.addNode(tn2,"第三层左子结点",true);
        
        List<BinaryTree.TreeNode> list1 = new ArrayList<BinaryTree.TreeNode>();
        list1 = bt.inTraverse();
        System.out.println("inorder traverse");
        for(BinaryTree.TreeNode node : list1)
            System.out.print(node.data + " ");
        
        List<BinaryTree.TreeNode> list2 = new ArrayList<BinaryTree.TreeNode>();
        list2 = bt.preTraverse();
        System.out.println("\n preorder traverse");
        for(BinaryTree.TreeNode node : list2)
            System.out.print(node.data + " ");
        List<BinaryTree.TreeNode> list3 = new ArrayList<BinaryTree.TreeNode>();
        list3 = bt.levelTraverse();
        System.out.println("\n level traverse");
        for(BinaryTree.TreeNode node : list3)
            System.out.println(node.data + " ");
    }
}