【算法】二叉樹

 

和堆類似，二叉樹也是一種很奇特的數據結構。它包含了根節點，節點最多隻有一個左右節點。

父節點和左右子節點之間有一定的關係：
1. 父節點比左節點大（小）。
2. 父節點比右節點小（大）。

通過這種特性，二叉樹的查找定位非常方便，比數組、鏈表的查找效率要高很多。在我的機器上，從100萬個隨機整數中查找一個整數平均需要0.00386毫秒。可見效率確實很高。

不過，二次樹有一個致命的缺點：如果插入的數是經過排序的，則會使二次樹高度非常大，就等同於線性數組了，從而極大影響了查找和插入的效率。

下面是二叉樹的Java實現代碼。

1. package cn.tenyears.demo;
3. import java.util.Comparator;
5. /**
6.  * Binary Tree
7.  * 
8.  * @author taolue
9.  * 
10.  */
12. public class BinTree<T> {
13.   public class Node {
14.     private T data;
16.     private Node left;
18.     private Node right;
20.     public void setData(T data) {
21.       this.data = data;
22.     }
24.     public void setLeft(Node left) {
25.       this.left = left;
26.     }
28.     public void setRight(Node right) {
29.       this.right = right;
30.     }
32.     public Node getLeft() {
33.       return this.left;
34.     }
36.     public Node getRight() {
37.       return this.right;
38.     }
40.     public T getData() {
41.       return this.data;
42.     }
44.     public Node(T data, Node l, Node r) {
45.       this.data = data;
46.       this.left = l;
47.       this.right = r;
48.     }
49.   }
51.   class ParentAndChild {
53.     public Node parent = null;
55.     public Node child = null;
57.     public ParentAndChild(Node p, Node c) {
58.       this.parent = p;
59.       this.child = c;
60.     }
61.   }
63.   private Comparator<T> comparator = null;;
65.   public final ParentAndChild NONE_PC = new ParentAndChild(null, null);
67.   private Node root = null;
69.   private int treeSize = 0;
71.   public BinTree(Comparator<T> comparator) {
72.     this.comparator = comparator;
73.   }
75.   public Node search(T data) {
76.     return searchPC(data).child;
77.   }
79.   public void insert(T data) {
80.     Node temp = root;
81.     Node parent = null;
82.     int equal = 0;
83.     while (temp != null) {
84.       parent = temp;
85.       equal = comparator.compare(data, temp.getData());
86.       if (equal < 0)
87.         temp = temp.getLeft();
88.       else
89.         temp = temp.getRight();
90.     }
91.     Node one = new Node(data, null, null);
92.     if (parent == null)
93.       root = one;
94.     else if (comparator.compare(data, parent.getData()) < 0)
95.       parent.setLeft(one);
96.     else
97.       parent.setRight(one);
98.     this.treeSize++;
99.   }
101.   public boolean delete(T data) {
102.     Node deleted = null;
103.     Node parent = null;
104.     Node right = null;
105.     ParentAndChild pc = this.searchPC(data);
106.     deleted = pc.child;
107.     parent = pc.parent;
108.     if (deleted == null)
109.       return false;
110.     if (deleted.getRight() == null)
111.       right = deleted.getLeft();
112.     else if (deleted.getLeft() == null)
113.       right = deleted.getRight();
114.     else {
115.       Node parent1 = deleted;
116.       right = deleted.getLeft();
117.       while (right.getRight() != null) {
118.         parent1 = right;
119.         right = right.getRight();
120.       }
121.       if (parent1 == deleted)
122.         right.setRight(deleted.getRight());
123.       else {
124.         parent1.setRight(right.getLeft());
125.         right.setLeft(deleted.getLeft());
126.         right.setRight(deleted.getRight());
127.       }
128.     }
129.     if (parent == null)
130.       root = right;
131.     else if (comparator.compare(deleted.getData(), parent.getData()) < 0)
132.       parent.setLeft(right);
133.     else
134.       parent.setRight(right);
135.     this.treeSize--;
136.     return true;
137.   }
139.   public int getSize() {
140.     return this.treeSize;
141.   }
143.   private ParentAndChild searchPC(T data) {
144.     Node temp = root;
145.     Node parent = null;
146.     int equal = 0;
147.     while (temp != null) {
148.       equal = comparator.compare(data, temp.getData());
149.       if (equal == 0)
150.         break;
151.       else {
152.         parent = temp;
153.         if (equal < 0)
154.           temp = parent.getLeft();
155.         else
156.           temp = parent.getRight();
157.       }
158.     }
159.     if (temp != null)
160.       return new ParentAndChild(parent, temp);
161.     return this.NONE_PC;
162.   }
164.   public static void main(String[] args) {
165.     Comparator<Integer> com = new Comparator<Integer>() {
166.       public int compare(Integer o1, Integer o2) {
167.         return o1.compareTo(o2);
168.       }
169.     };
170.     BinTree<Integer> tree = new BinTree<Integer>(com);
171.     int size = 1000000;
172.     Integer[] a = new Integer[size];
173.     for (int i = 0; i < size; i++) {
174.       a[i] = Integer.valueOf((int) Math.round(Math.random() * size));
175.       tree.insert(a[i]);
176.     }
177.     long start = System.currentTimeMillis();
178.     // find
179.     for (int i = 0; i < size; i++) {
180.       if (tree.search(a[i]) == null)
181.         System.out.println("Error: Find None.");
182.     }
183.     long end = System.currentTimeMillis();
184.     System.out.println("Last(AVG): " + (end - start) * 1.0f / size + " ms");
185.   }
186. }