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

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

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

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

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

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

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

  1 package tree;
  2 
  3 import java.util.ArrayDeque;
  4 import java.util.ArrayList;
  5 import java.util.List;
  6 import java.util.Queue;
  7 
  8 public class BinaryTree<E> {
  9     //为什么要用静态内部类？静态内部类中不能访问外部类的非静态成员
 10     public static class TreeNode{
 11 //        E data;
 12         Object data;
 13         TreeNode left;
 14         TreeNode right;
 15         public TreeNode(){
 16             
 17         }
 18         public TreeNode(Object data){
 19             this.data = data;
 20         }
 21         //构造一个新节点，该节点以left节点为其左孩子，right节点为其右孩子
 22         public TreeNode(Object data, TreeNode left, TreeNode right){
 23             this.data = data;
 24             this.left = left;
 25             this.right = right;
 26         }
 27     }
 28     
 29     private TreeNode root;//实现二叉树的类的数据域，即根结点来表示二叉树
 30     
 31     public BinaryTree(){
 32         this.root = new TreeNode();
 33     }
 34     //以指定的根元素创建一颗二叉树
 35     public BinaryTree(E data){
 36         this.root = new TreeNode(data);
 37     }
 38     
 39     //为指定的结点添加子结点,为什么要有addNode方法？因为给定一系列的结点，通过调用该方法来构造成一颗树
 40     public TreeNode addNode(TreeNode parent, E data, boolean isLeft){
 41         if(parent == null)
 42             throw new RuntimeException("父节点为空，无法添加子结点");
 43         if(isLeft && parent.left != null)
 44             throw new RuntimeException("节点已经左子节点，添加失败");
 45         if(!isLeft && parent.right != null)
 46             throw new RuntimeException("节点已经有右子节点，添加失败");
 47         TreeNode newNode = new TreeNode(data);
 48         if(isLeft)
 49             parent.left = newNode;
 50         else
 51             parent.right = newNode;
 52         return newNode;
 53     }
 54     
 55     public boolean empty(){
 56         return root.data == null;//根据根元素判断二叉树是否为空
 57     }
 58     
 59     public TreeNode root(){
 60         if(empty())
 61             throw new RuntimeException("树空，无法访问根结点");
 62         return root;
 63     }
 64     
 65     public E parent(TreeNode node){
 66         return null;//采用二叉树链表存储时，访问父结点需要遍历整棵二叉树，因为这里不实现
 67     }
 68     
 69     //访问指定节点的左结点，返回的是其左孩子的数据域
 70     public E leftChild(TreeNode parent){
 71         if(parent == null)
 72             throw new RuntimeException("空结点不能访问其左孩子");
 73         return parent.left == null ? null : (E)parent.left.data;
 74     }
 75     public E rightChild(TreeNode parent){
 76         if(parent == null)
 77             throw new RuntimeException("空结点不能访问其右孩子");
 78         return parent.right == null ? null : (E)parent.right.data;
 79     }
 80     
 81     public int deep(){
 82         return deep(root);
 83     }
 84     private int deep(TreeNode node){
 85         if(node == null)
 86             return 0;
 87         else if(node.left == null && node.right == null)
 88             return 1;
 89         else{
 90             int leftDeep = deep(node.left);
 91             int rightDeep = deep(node.right);
 92             int max = leftDeep > rightDeep ? leftDeep : rightDeep;
 93             return max + 1;
 94         }
 95     }
 96     
 97     /*二叉树的先序遍历，实现思想如下：树是一种非线性结构，树中各个结点的组织方式有多种方式
 98      * 先序，即是一种组织方式。它将结点的非线性变成了按照某种方式组织成的线性结构
 99      */
100     //返回一个list，树中结点以先序的方式存放在该list中
101     public List<TreeNode> preTraverse(){
102         return preOrderTraverse(root);
103     }
104     private List<TreeNode> preOrderTraverse(TreeNode node){
105         List<TreeNode> list = new ArrayList<TreeNode>();
106         list.add(node);
107         if(node.left != null)
108             list.addAll(preOrderTraverse(node.left));//递归的奇妙之处
109         if(node.right != null)
110             list.addAll(preOrderTraverse(node.right));
111         return list;
112     }
113     
114     //中序遍历
115     public List<TreeNode> inTraverse(){
116         return inOrderTraverse(root);
117     }
118     private List<TreeNode> inOrderTraverse(TreeNode node){
119         List<TreeNode> list = new ArrayList<TreeNode>();
120         if(node.left != null)
121             list.addAll(inOrderTraverse(node.left));
122         list.add(node);
123         if(node.right != null)
124             list.addAll(inOrderTraverse(node.right));
125         return list;
126     }
127     
128     //后序遍历
129     public List<TreeNode> postTraverse(){
130         return post_Traverse(root);
131     }
132     private List<TreeNode> post_Traverse(TreeNode node){
133         List<TreeNode> list = new ArrayList<TreeNode>();
134         if(node.left != null)
135             list.addAll(post_Traverse(node.left));
136         if(node.right != null)
137             list.addAll(post_Traverse(node.right));
138         list.add(node);
139         return list;
140     }
141     
142     //层序遍历
143     public List<TreeNode> levelTraverse(){
144         return level_Traverse(root);
145     }
146     private List<TreeNode> level_Traverse(TreeNode node){
147         Queue<TreeNode> queue = new ArrayDeque<TreeNode>();
148         List<TreeNode> list = new ArrayList<TreeNode>();//按层序遍历定义的顺序将树中结点依次添加到数组列表中
149         if(root != null)//先将根结点入队列
150             queue.offer(root);
151         while(!queue.isEmpty())//队列不空时，说明遍历还未结束
152         {
153             list.add(queue.peek());//将队头元素添加到数组列表中
154             TreeNode p = queue.poll();//队头元素出队列
155             if(p.left != null)
156                 queue.offer(p.left);//队头元素的左孩子入队列
157             if(p.right != null)
158                 queue.offer(p.right);//队头元素的右孩子入队列
159         }
160         return list;
161     }
162 }

 

测试遍历的程序如下：

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 + " ");
    }
}