接下來我們將會介紹另外一種數據結構——樹。二叉樹是樹這種數據結構的一員，后面我們還會介紹紅黑樹，2-3-4樹等數據結構。那么為什么要使用樹？它有什么優點？
前面我們介紹數組的數據結構，我們知道對於有序數組，查找很快，並介紹可以通過二分法查找，但是想要在有序數組中插入一個數據項，就必須先找到插入數據項的位置，然后將所有插入位置后面的數據項全部向后移動一位，來給新數據騰出空間，平均來講要移動N/2次，這是很費時的。同理，刪除數據也是。
然后我們介紹了另外一種數據結構——鏈表，鏈表的插入和刪除很快，我們只需要改變一些引用值就行了，但是查找數據卻很慢了，因為不管我們查找什么數據，都需要從鏈表的第一個數據項開始，遍歷到找到所需數據項為止，這個查找也是平均需要比較N/2次。
那么我們就希望一種數據結構能同時具備數組查找快的優點以及鏈表插入和刪除快的優點，於是 樹 誕生了。
1、樹
樹（tree）是一種抽象數據類型（ADT），用來模擬具有樹狀結構性質的數據集合。它是由n（n>0）個有限節點通過連接它們的邊組成一個具有層次關系的集合。把它叫做“樹”是因為它看起來像一棵倒掛的樹，也就是說它是根朝上，而葉朝下的。
①、節點：上圖的圓圈，比如A,B,C等都是表示節點。節點一般代表一些實體，在java面向對象編程中，節點一般代表對象。
②、邊：連接節點的線稱為邊，邊表示節點的關聯關系。一般從一個節點到另一個節點的唯一方法就是沿着一條順着有邊的道路前進。在Java當中通常表示引用。
樹有很多種，向上面的一個節點有多余兩個的子節點的樹，稱為多路樹，后面會講解2-3-4樹和外部存儲都是多路樹的例子。而每個節點最多只能有兩個子節點的一種形式稱為二叉樹，這也是本篇博客講解的重點。
樹的常用術語
①、路徑：順着節點的邊從一個節點走到另一個節點，所經過的節點的順序排列就稱為“路徑”。
②、根：樹頂端的節點稱為根。一棵樹只有一個根，如果要把一個節點和邊的集合稱為樹，那么從根到其他任何一個節點都必須有且只有一條路徑。A是根節點。
③、父節點：若一個節點含有子節點，則這個節點稱為其子節點的父節點；B是D的父節點。
④、子節點：一個節點含有的子樹的根節點稱為該節點的子節點；D是B的子節點。
⑤、兄弟節點：具有相同父節點的節點互稱為兄弟節點；比如上圖的D和E就互稱為兄弟節點。
⑥、葉節點：沒有子節點的節點稱為葉節點，也叫葉子節點，比如上圖的H、E、F、G都是葉子節點。
⑦、子樹：每個節點都可以作為子樹的根，它和它所有的子節點、子節點的子節點等都包含在子樹中。
⑧、節點的層次：從根開始定義，根為第一層，根的子節點為第二層，以此類推。
⑨、深度：對於任意節點n,n的深度為從根到n的唯一路徑長，根的深度為0；
⑩、高度：對於任意節點n,n的高度為從n到一片樹葉的最長路徑長，所有樹葉的高度為0；
2、二叉樹
二叉樹：樹的每個節點最多只能有兩個子節點
上圖的第一幅圖B節點有DEF三個子節點，就不是二叉樹，稱為多路樹；而第二幅圖每個節點最多只有兩個節點，是二叉樹，並且二叉樹的子節點稱為“左子節點”和“右子節點”。上圖的D,E分別是B的左子節點和右子節點。
如果我們給二叉樹加一個額外的條件，就可以得到一種被稱作二叉搜索樹(binary search tree)的特殊二叉樹。
二叉搜索樹要求：若它的左子樹不空，則左子樹上所有結點的值均小於它的根結點的值； 若它的右子樹不空，則右子樹上所有結點的值均大於它的根結點的值； 它的左、右子樹也分別為二叉排序樹。
二叉搜索樹作為一種數據結構，那么它是如何工作的呢？它查找一個節點，插入一個新節點，以及刪除一個節點，遍歷樹等工作效率如何，下面我們來一一介紹。
二叉樹的節點類：
package com.ys.tree;
public class Node {
private Object data; //節點數據
private Node leftChild; //左子節點的引用
private Node rightChild; //右子節點的引用
//打印節點內容
public void display(){
System.out.println(data);
}
}
二叉樹的具體方法：
package com.ys.tree;
public interface Tree {
//查找節點
public Node find(Object key);
//插入新節點
public boolean insert(Object key);
//刪除節點
public boolean delete(Object key);
//Other Method......
}
3、查找節點
查找某個節點，我們必須從根節點開始遍歷。
①、查找值比當前節點值大，則搜索右子樹；
②、查找值等於當前節點值，停止搜索（終止條件）；
③、查找值小於當前節點值，則搜索左子樹；
//查找節點
public Node find(int key) {
Node current = root;
while(current != null){
if(current.data > key){//當前值比查找值大，搜索左子樹
current = current.leftChild;
}else if(current.data < key){//當前值比查找值小，搜索右子樹
current = current.rightChild;
}else{
return current;
}
}
return null;//遍歷完整個樹沒找到，返回null
}
用變量current來保存當前查找的節點，參數key是要查找的值，剛開始查找將根節點賦值到current。接在在while循環中，將要查找的值和current保存的節點進行對比。如果key小於當前節點，則搜索當前節點的左子節點，如果大於，則搜索右子節點，如果等於，則直接返回節點信息。當整個樹遍歷完全，即current == null，那么說明沒找到查找值，返回null。
樹的效率：查找節點的時間取決於這個節點所在的層數，每一層最多有2n-1個節點，總共N層共有2n-1個節點，那么時間復雜度為O(logN),底數為2。
我看評論有對這里的時間復雜度不理解，這里解釋一下，O(logN)，N表示的是二叉樹節點的總數，而不是層數。
4、插入節點
要插入節點，必須先找到插入的位置。與查找操作相似，由於二叉搜索樹的特殊性，待插入的節點也需要從根節點開始進行比較，小於根節點則與根節點左子樹比較，反之則與右子樹比較，直到左子樹為空或右子樹為空，則插入到相應為空的位置，在比較的過程中要注意保存父節點的信息 及 待插入的位置是父節點的左子樹還是右子樹，才能插入到正確的位置。
//插入節點
public boolean insert(int data) {
Node newNode = new Node(data);
if(root == null){//當前樹為空樹，沒有任何節點
root = newNode;
return true;
}else{
Node current = root;
Node parentNode = null;
while(current != null){
parentNode = current;
if(current.data > data){//當前值比插入值大，搜索左子節點
current = current.leftChild;
if(current == null){//左子節點為空，直接將新值插入到該節點
parentNode.leftChild = newNode;
return true;
}
}else{
current = current.rightChild;
if(current == null){//右子節點為空，直接將新值插入到該節點
parentNode.rightChild = newNode;
return true;
}
}
}
}
return false;
}
5、遍歷樹
遍歷樹是根據一種特定的順序訪問樹的每一個節點。比較常用的有前序遍歷，中序遍歷和后序遍歷。而二叉搜索樹最常用的是中序遍歷。
①、中序遍歷:左子樹——》根節點——》右子樹
②、前序遍歷:根節點——》左子樹——》右子樹
③、后序遍歷:左子樹——》右子樹——》根節點
//中序遍歷
public void infixOrder(Node current){
if(current != null){
infixOrder(current.leftChild);
System.out.print(current.data+" ");
infixOrder(current.rightChild);
}
}
//前序遍歷
public void preOrder(Node current){
if(current != null){
System.out.print(current.data+" ");
preOrder(current.leftChild);
preOrder(current.rightChild);
}
}
//后序遍歷
public void postOrder(Node current){
if(current != null){
postOrder(current.leftChild);
postOrder(current.rightChild);
System.out.print(current.data+" ");
}
}
6、查找最大值和最小值
這沒什么好說的，要找最小值，先找根的左節點，然后一直找這個左節點的左節點，直到找到沒有左節點的節點，那么這個節點就是最小值。同理要找最大值，一直找根節點的右節點，直到沒有右節點，則就是最大值。
//找到最大值
public Node findMax(){
Node current = root;
Node maxNode = current;
while(current != null){
maxNode = current;
current = current.rightChild;
}
return maxNode;
}
//找到最小值
public Node findMin(){
Node current = root;
Node minNode = current;
while(current != null){
minNode = current;
current = current.leftChild;
}
return minNode;
}
7、刪除節點
刪除節點是二叉搜索樹中最復雜的操作，刪除的節點有三種情況，前兩種比較簡單，但是第三種卻很復雜。
1、該節點是葉節點（沒有子節點）
2、該節點有一個子節點
3、該節點有兩個子節點
下面我們分別對這三種情況進行講解。
①、刪除沒有子節點的節點
要刪除葉節點，只需要改變該節點的父節點引用該節點的值，即將其引用改為 null 即可。要刪除的節點依然存在，但是它已經不是樹的一部分了，由於Java語言的垃圾回收機制，我們不需要非得把節點本身刪掉，一旦Java意識到程序不在與該節點有關聯，就會自動把它清理出存儲器。
@Override
public boolean delete(int key) {
Node current = root;
Node parent = root;
boolean isLeftChild = false;
//查找刪除值，找不到直接返回false
while(current.data != key){
parent = current;
if(current.data > key){
isLeftChild = true;
current = current.leftChild;
}else{
isLeftChild = false;
current = current.rightChild;
}
if(current == null){
return false;
}
}
//如果當前節點沒有子節點
if(current.leftChild == null && current.rightChild == null){
if(current == root){
root = null;
}else if(isLeftChild){
parent.leftChild = null;
}else{
parent.rightChild = null;
}
return true;
}
return false;
}
刪除節點，我們要先找到該節點，並記錄該節點的父節點。在檢查該節點是否有子節點。如果沒有子節點，接着檢查其是否是根節點，如果是根節點，只需要將其設置為null即可。如果不是根節點，是葉節點，那么斷開父節點和其的關系即可。
②、刪除有一個子節點的節點
刪除有一個子節點的節點，我們只需要將其父節點原本指向該節點的引用，改為指向該節點的子節點即可。
//當前節點有一個子節點
if(current.leftChild == null && current.rightChild != null){
if(current == root){
root = current.rightChild;
}else if(isLeftChild){
parent.leftChild = current.rightChild;
}else{
parent.rightChild = current.rightChild;
}
return true;
}else{
//current.leftChild != null && current.rightChild == null
if(current == root){
root = current.leftChild;
}else if(isLeftChild){
parent.leftChild = current.leftChild;
}else{
parent.rightChild = current.leftChild;
}
return true;
}
③、刪除有兩個子節點的節點
當刪除的節點存在兩個子節點，那么刪除之后，兩個子節點的位置我們就沒辦法處理了。既然處理不了，我們就想到一種辦法，用另一個節點來代替被刪除的節點，那么用哪一個節點來代替呢？
我們知道二叉搜索樹中的節點是按照關鍵字來進行排列的，某個節點的關鍵字次高節點是它的中序遍歷后繼節點。用后繼節點來代替刪除的節點，顯然該二叉搜索樹還是有序的。（這里用后繼節點代替，如果該后繼節點自己也有子節點，我們后面討論。）
那么如何找到刪除節點的中序后繼節點呢？其實我們稍微分析，這實際上就是要找比刪除節點關鍵值大的節點集合中最小的一個節點，只有這樣代替刪除節點后才能滿足二叉搜索樹的特性。
后繼節點也就是：比刪除節點大的最小節點。
算法：程序找到刪除節點的右節點，(注意這里前提是刪除節點存在左右兩個子節點，如果不存在則是刪除情況的前面兩種)，然后轉到該右節點的左子節點，依次順着左子節點找下去，最后一個左子節點即是后繼節點；如果該右節點沒有左子節點，那么該右節點便是后繼節點。
需要確定后繼節點沒有子節點，如果后繼節點存在子節點，那么又要分情況討論了。
①、后繼節點是刪除節點的右子節點
這種情況簡單，只需要將后繼節點表示的子樹移到被刪除節點的位置即可！
②、后繼節點是刪除節點的右子節點的左子節點
public Node getSuccessor(Node delNode){
Node successorParent = delNode;
Node successor = delNode;
Node current = delNode.rightChild;
while(current != null){
successorParent = successor;
successor = current;
current = current.leftChild;
}
//將后繼節點替換刪除節點
if(successor != delNode.rightChild){
successorParent.leftChild = successor.rightChild;
successor.rightChild = delNode.rightChild;
}
return successor;
}
④、刪除有必要嗎？
通過上面的刪除分類討論，我們發現刪除其實是挺復雜的，那么其實我們可以不用真正的刪除該節點，只需要在Node類中增加一個標識字段isDelete，當該字段為true時，表示該節點已經刪除，反正沒有刪除。那么我們在做比如find()等操作的時候，要先判斷isDelete字段是否為true。這樣刪除的節點並不會改變樹的結構。
public class Node {
int data; //節點數據
Node leftChild; //左子節點的引用
Node rightChild; //右子節點的引用
boolean isDelete;//表示節點是否被刪除
}
8、二叉樹的效率
從前面的大部分對樹的操作來看，都需要從根節點到下一層一層的查找。
一顆滿樹，每層節點數大概為2n-1，那么最底層的節點個數比樹的其它節點數多1，因此，查找、插入或刪除節點的操作大約有一半都需要找到底層的節點，另外四分之一的節點在倒數第二層，依次類推。
總共N層共有2n-1個節點，那么時間復雜度為O(logn),底數為2。
在有1000000 個數據項的無序數組和鏈表中，查找數據項平均會比較500000 次，但是在有1000000個節點的二叉樹中，只需要20次或更少的比較即可。
有序數組可以很快的找到數據項，但是插入數據項的平均需要移動 500000 次數據項，在 1000000 個節點的二叉樹中插入數據項需要20次或更少比較，在加上很短的時間來連接數據項。
同樣，從 1000000 個數據項的數組中刪除一個數據項平均需要移動 500000 個數據項，而在 1000000 個節點的二叉樹中刪除節點只需要20次或更少的次數來找到他，然后在花一點時間來找到它的后繼節點，一點時間來斷開節點以及連接后繼節點。
所以，樹對所有常用數據結構的操作都有很高的效率。
遍歷可能不如其他操作快，但是在大型數據庫中，遍歷是很少使用的操作，它更常用於程序中的輔助算法來解析算術或其它表達式。
9、用數組表示樹
用數組表示樹，那么節點是存在數組中的，節點在數組中的位置對應於它在樹中的位置。下標為 0 的節點是根，下標為 1 的節點是根的左子節點，以此類推，按照從左到右的順序存儲樹的每一層。
樹中的每個位置，無論是否存在節點，都對應於數組中的一個位置，樹中沒有節點的在數組中用0或者null表示。
假設節點的索引值為index，那么節點的左子節點是 2*index+1，節點的右子節點是 2*index+2，它的父節點是 （index-1）/2。
在大多數情況下，使用數組表示樹效率是很低的，不滿的節點和刪除掉的節點都會在數組中留下洞，浪費存儲空間。更壞的是，刪除節點如果要移動子樹的話，子樹中的每個節點都要移到數組中新的位置，這是很費時的。
不過如果不允許刪除操作，數組表示可能會很有用，尤其是因為某種原因要動態的為每個字節分配空間非常耗時。
10、完整的BinaryTree代碼
Node.java
package com.ys.tree;
public class Node {
int data; //節點數據
Node leftChild; //左子節點的引用
Node rightChild; //右子節點的引用
boolean isDelete;//表示節點是否被刪除
public Node(int data){
this.data = data;
}
//打印節點內容
public void display(){
System.out.println(data);
}
}
Tree.java
package com.ys.tree;
public interface Tree {
//查找節點
public Node find(int key);
//插入新節點
public boolean insert(int data);
//中序遍歷
public void infixOrder(Node current);
//前序遍歷
public void preOrder(Node current);
//后序遍歷
public void postOrder(Node current);
//查找最大值
public Node findMax();
//查找最小值
public Node findMin();
//刪除節點
public boolean delete(int key);
//Other Method......
}
BinaryTree.java
package com.ys.tree;
public class BinaryTree implements Tree {
//表示根節點
private Node root;
//查找節點
public Node find(int key) {
Node current = root;
while(current != null){
if(current.data > key){//當前值比查找值大，搜索左子樹
current = current.leftChild;
}else if(current.data < key){//當前值比查找值小，搜索右子樹
current = current.rightChild;
}else{
return current;
}
}
return null;//遍歷完整個樹沒找到，返回null
}
//插入節點
public boolean insert(int data) {
Node newNode = new Node(data);
if(root == null){//當前樹為空樹，沒有任何節點
root = newNode;
return true;
}else{
Node current = root;
Node parentNode = null;
while(current != null){
parentNode = current;
if(current.data > data){//當前值比插入值大，搜索左子節點
current = current.leftChild;
if(current == null){//左子節點為空，直接將新值插入到該節點
parentNode.leftChild = newNode;
return true;
}
}else{
current = current.rightChild;
if(current == null){//右子節點為空，直接將新值插入到該節點
parentNode.rightChild = newNode;
return true;
}
}
}
}
return false;
}
//中序遍歷
public void infixOrder(Node current){
if(current != null){
infixOrder(current.leftChild);
System.out.print(current.data+" ");
infixOrder(current.rightChild);
}
}
//前序遍歷
public void preOrder(Node current){
if(current != null){
System.out.print(current.data+" ");
infixOrder(current.leftChild);
infixOrder(current.rightChild);
}
}
//后序遍歷
public void postOrder(Node current){
if(current != null){
infixOrder(current.leftChild);
infixOrder(current.rightChild);
System.out.print(current.data+" ");
}
}
//找到最大值
public Node findMax(){
Node current = root;
Node maxNode = current;
while(current != null){
maxNode = current;
current = current.rightChild;
}
return maxNode;
}
//找到最小值
public Node findMin(){
Node current = root;
Node minNode = current;
while(current != null){
minNode = current;
current = current.leftChild;
}
return minNode;
}
@Override
public boolean delete(int key) {
Node current = root;
Node parent = root;
boolean isLeftChild = false;
//查找刪除值，找不到直接返回false
while(current.data != key){
parent = current;
if(current.data > key){
isLeftChild = true;
current = current.leftChild;
}else{
isLeftChild = false;
current = current.rightChild;
}
if(current == null){
return false;
}
}
//如果當前節點沒有子節點
if(current.leftChild == null && current.rightChild == null){
if(current == root){
root = null;
}else if(isLeftChild){
parent.leftChild = null;
}else{
parent.rightChild = null;
}
return true;
//當前節點有一個子節點，右子節點
}else if(current.leftChild == null && current.rightChild != null){
if(current == root){
root = current.rightChild;
}else if(isLeftChild){
parent.leftChild = current.rightChild;
}else{
parent.rightChild = current.rightChild;
}
return true;
//當前節點有一個子節點，左子節點
}else if(current.leftChild != null && current.rightChild == null){
if(current == root){
root = current.leftChild;
}else if(isLeftChild){
parent.leftChild = current.leftChild;
}else{
parent.rightChild = current.leftChild;
}
return true;
}else{
//當前節點存在兩個子節點
Node successor = getSuccessor(current);
if(current == root){
root= successor;
}else if(isLeftChild){
parent.leftChild = successor;
}else{
parent.rightChild = successor;
}
successor.leftChild = current.leftChild;
}
return false;
}
public Node getSuccessor(Node delNode){
Node successorParent = delNode;
Node successor = delNode;
Node current = delNode.rightChild;
while(current != null){
successorParent = successor;
successor = current;
current = current.leftChild;
}
//后繼節點不是刪除節點的右子節點，將后繼節點替換刪除節點
if(successor != delNode.rightChild){
successorParent.leftChild = successor.rightChild;
successor.rightChild = delNode.rightChild;
}
return successor;
}
public static void main(String[] args) {
BinaryTree bt = new BinaryTree();
bt.insert(50);
bt.insert(20);
bt.insert(80);
bt.insert(10);
bt.insert(30);
bt.insert(60);
bt.insert(90);
bt.insert(25);
bt.insert(85);
bt.insert(100);
bt.delete(10);//刪除沒有子節點的節點
bt.delete(30);//刪除有一個子節點的節點
bt.delete(80);//刪除有兩個子節點的節點
System.out.println(bt.findMax().data);
System.out.println(bt.findMin().data);
System.out.println(bt.find(100));
System.out.println(bt.find(200));
}
}
11、哈夫曼(Huffman)編碼
我們知道計算機里每個字符在沒有壓縮的文本文件中由一個字節（比如ASCII碼）或兩個字節（比如Unicode,這個編碼在各種語言中通用）表示，在這些方案中，每個字符需要相同的位數。
有很多壓縮數據的方法，就是減少表示最常用字符的位數量，比如英語中，E是最常用的字母，我們可以只用兩位01來表示，2位有四種組合：00、01、10、11，那么我們可以用這四種組合表示四種常用的字符嗎？
答案是不可以的，因為在編碼序列中是沒有空格或其他特殊字符存在的，全都是有0和1構成的序列，比如E用01來表示，X用01011000表示，那么在解碼的時候就弄不清楚01是表示E還是表示X的起始部分，所以在編碼的時候就定下了一個規則：每個代碼都不能是其它代碼的前綴。
①、哈夫曼編碼
二叉樹中有一種特別的樹——哈夫曼樹（最優二叉樹），其通過某種規則（權值）來構造出一哈夫曼二叉樹，在這個二叉樹中，只有葉子節點才是有效的數據節點（很重要），其他的非葉子節點是為了構造出哈夫曼而引入的！
哈夫曼編碼是一個通過哈夫曼樹進行的一種編碼，一般情況下，以字符：‘0’與‘1’表示。編碼的實現過程很簡單，只要實現哈夫曼樹，通過遍歷哈夫曼樹，規定向左子樹遍歷一個節點編碼為“0”，向右遍歷一個節點編碼為“1”，結束條件就是遍歷到葉子節點！因為上面說過：哈夫曼樹葉子節點才是有效數據節點！
我們用01表示S，用00表示空格后，就不能用01和11表示某個字符了，因為它們是其它字符的前綴。在看三位的組合，分別有000,001,010,100,101,110和111，A是010，I是110，為什么沒有其它三位的組合了呢？因為已知是不能用01和11開始的組合了，那么就減少了四種選擇，同時011用於U和換行符的開始，111用於E和Y的開始，這樣就只剩下2個三位的組合了，同理可以理解為什么只有三個四位的代碼可用。
所以對於消息：SUSIE SAYS IT IS EASY
哈夫曼編碼為：100111110110111100100101110100011001100011010001111010101110
②、哈夫曼解碼
如果收到上面的一串哈夫曼編碼，怎么解碼呢？消息中出現的字符在哈夫曼樹中是葉節點，也就是沒有子節點，如下圖：它們在消息中出現的頻率越高，在樹中的位置就越高，每個圓圈外面的數字就是頻率，非葉節點外面的數字是它子節點數字的和。
每個字符都從根開始，如果遇到0，就向左走到下一個節點，如果遇到1，就向右。比如字符A是010，那么先向左，再向右，再向左，就找到了A，其它的依次類推。
12、總結
樹是由邊和節點構成，根節點是樹最頂端的節點，它沒有父節點；二叉樹中，最多有兩個子節點；某個節點的左子樹每個節點都比該節點的關鍵字值小，右子樹的每個節點都比該節點的關鍵字值大，那么這種樹稱為二叉搜索樹，其查找、插入、刪除的時間復雜度都為logN；可以通過前序遍歷、中序遍歷、后序遍歷來遍歷樹，前序是根節點-左子樹-右子樹，中序是左子樹-根節點-右子樹，后序是左子樹-右子樹-根節點；刪除一個節點只需要斷開指向它的引用即可；哈夫曼樹是二叉樹，用於數據壓縮算法，最經常出現的字符編碼位數最少，很少出現的字符編碼位數多一些。