早上看数据结构时，二叉平衡树就不怎么看得懂，尝试写代码发现无法进展下去，麻烦懂的人教下

1. /**
   
2. * 二叉树加入节点,以及按照中序排序.
   
3. */
   
4. class BinaryTree<T extends Comparable<T>> {
   
5. 
   
6.         private Node root;// 二叉树的根节点
   
7. 
   
8.         class Node {
   
9.                 private T data;
   
10.                 private Node left;// 左节点
    
11.                 private Node right;// 右节点
    
12. 
    
13.                 public Node(T data) {
    
14.                         this.data = data;
    
15.                 }
    
16. 
    
17.                 /**
    
18.                  * 添加节点
    
19.                  *
    
20.                  * @param newNode
    
21.                  *            要添加的节点,按中序排序.
    
22.                  */
    
23.                 public void addNode(Node newNode) {
    
24.                         if (newNode.data.compareTo(this.data) <= 0) {
    
25.                                 if (this.left == null) {
    
26.                                         this.left = newNode;
    
27.                                 } else {
    
28.                                         this.left.addNode(newNode);
    
29.                                 }
    
30.                         }
    
31.                         if (newNode.data.compareTo(this.data) > 0) {
    
32.                                 if (this.right == null) {
    
33.                                         this.right = newNode;
    
34.                                 } else {
    
35.                                         this.right.addNode(newNode);
    
36.                                 }
    
37.                         }
    
38.                 }
    
39. 
    
40.                 /**
    
41.                  * 按中序遍历并打印.
    
42.                  */
    
43.                 public void printNode() {
    
44.                         if (this.left != null) {
    
45.                                 this.left.printNode();
    
46.                         }
    
47.                         System.out.println(this.data);
    
48.                         if (this.right != null) {
    
49.                                 this.right.printNode();
    
50.                         }
    
51.                 }
    
52.         }
    
53. 
    
54.         /**
    
55.          * 为二叉树增加一个节点,如果没有根节点,新增的节点就为根节点,否则将按照中序,为根节点增加新的节点.
    
56.          *
    
57.          * @param data
    
58.          *            节点中的的一个属性,此属性的类型不确定,通过实例化二叉树来决定此数据的具体类型.
    
59.          */
    
60.         public void add(T data) {
    
61.                 Node newNode = new Node(data);
    
62.                 if (this.root == null) {
    
63.                         this.root = newNode;
    
64.                 } else {
    
65.                         this.root.addNode(newNode);
    
66.                 }
    
67.         }
    
68. 
    
69.         /**
    
70.          * 将二叉树的所有节点按中序打印出来
    
71.          */
    
72.         public void print() {
    
73.                 this.root.printNode();
    
74.         }
    
75. 
    
76. }
    
77. 
    
78. public class BinaryTreeTest {
    
79. 
    
80.         public static void main(String[] args) {
    
81.                 BinaryTree<Integer> bt = new BinaryTree<Integer>();
    
82.                 bt.add(3);
    
83.                 bt.add(5);
    
84.                 bt.add(1);
    
85.                 bt.add(0);
    
86.                 bt.add(1);
    
87.                 bt.add(9);
    
88.                 bt.print();
    
89.         }
    
90. 
    
91. }

复制代码

说实话在java的编程中很少会直接用到底层的数据结构的东西，这些数据结构在java中都是被封装好的，比如说列表，哈希表，图，二叉树，比如各种排序，等等，直接使用就可以，基本上有个大概了解就可以，而你要了解二叉树，首先你要明白在编程语言中，什么是树的概念，这就涉及到底层的算法设计思想，这种思想其实注重的不是代码，而是解决问题的思路，这就是数据结构，一般大学里面都是有这样的专门课程，如果你想深入了解建议买本数据结构的书看看，或者看看教程