20172308 2018-2019-1 實驗2 《線性結構》報告
課程：《程序設計與數據結構》
班級： 1723
姓名： 周亞傑
學號：20172308
實驗教師：王志強
實驗日期：2018年11月5日
必修/選修： 必修
1.實驗內容
- (1)樹之實現二叉樹：完成鏈樹LinkedBinaryTree的實現（getRight,contains,toString,preorder,postorder），並測試
- (2)樹之中序先序序列構造二叉樹：基於LinkedBinaryTree，實現基於（中序，先序）序列構造唯一一棵二㕚樹的功能，並測試
- (3)樹之決策樹：自己設計並實現一顆決策樹
- (4)樹之表達式樹：輸入中綴表達式，使用樹將中綴表達式轉換為后綴表達式，並輸出后綴表達式和計算結果（如果沒有用樹，則為0分）
- (5)樹之二叉查找樹：完成PP11.3
- (6)樹之紅黑樹分析：參考相關資料對Java中的紅黑樹（TreeMap，HashMap）進行源碼分析，並在實驗報告中體現分析結果
2. 實驗過程及結果
- (1)樹之實現二叉樹：
1.完成鏈樹LinkedBinaryTree的方法：getRight，contains，toString，preorder，postorder
2.對LinkedBinaryTree類進行測試
3.實驗結果截圖：
- (2)樹之中序先序序列構造二叉樹：
1.基於LinkedBinaryTree，實現基於（中序，先序）序列構造唯一一棵二㕚樹的功能
2.測試LinkedBinaryTree類
3.實驗結果截圖：
- (3)樹之決策樹：
1.根據課本背部疼痛診斷設計一顆新的決策樹
2.測試新的決策樹
4.實驗結果截圖：
- (4)樹之表達式樹：
1.利用樹設計並實現中綴轉后綴表達式類
2.利用樹設計並實現后綴表達式計算結果類
3.並輸出后綴表達式和計算結果
4.測試中綴轉后綴及計算結果類
5.實驗結果截圖：
- (5)樹之二叉查找樹：完成PP11.3
1.鏈表實現的二叉樹，設計實現removeMax，findMin，findMax操作
2.測試類
3.實驗結果截圖：
- (6)樹之紅黑樹分析：
1.參考http://www.cnblogs.com/rocedu/p/7483915.html對Java中的紅黑樹（TreeMap，HashMap）進行源碼分析
2.在實驗報告中體現分析結果
3. 實驗過程中遇到的問題和解決過程
-
問題1：實驗2.2：利用中序和先序構造出一棵樹並輸出，其實這個原理明白，但實現代碼的時候卻不知道從哪里下手
-
問題1解決過程：
-
構造出樹的原理就是：
由先序遍歷的特點知道最先訪問的是根結點（結點），然后是左右子樹
再由中序遍歷的結果找到根結點，並得到左右子樹
再返回先序遍歷，找到根結點左或右子樹的結點，再返回中序遍歷結果中找到此結點左右子樹
如此遞歸下去...... -
舉個栗子：
先序遍歷: GDAFEMHZ
中序遍歷: ADEFGHMZ
畫出樹：
第一步，根據先序遍歷的特點，我們知道根結點為G
第二步，觀察中序遍歷ADEFGHMZ。其中root節點G左側的ADEF必然是root的左子樹，G右側的HMZ必然是root的右子樹。
第三步，觀察左子樹ADEF，左子樹的中的根節點必然是大樹的root的leftchild。在先序遍歷中，大樹的root的leftchild位於root之后，所以左子樹的根節點為D。
第四步，同樣的道理，root的右子樹節點HMZ中的根節點也可以通過前序遍歷求得。在先序遍歷中，一定是先把root和root的所有左子樹節點遍歷完之后才會遍歷右子樹，並且遍歷的左子樹的第一個節點就是左子樹的根節點。同理，遍歷的右子樹的第一個節點就是右子樹的根節點。
第五步，觀察發現，上面的過程是遞歸的。先找到當前樹的根節點，然后划分為左子樹，右子樹，然后進入左子樹重復上面的過程，然后進入右子樹重復上面的過程。最后就可以還原一棵樹了。
該步遞歸的過程可以簡潔表達如下：
1 確定根,確定左子樹，確定右子樹
2 在左子樹中遞歸
3 在右子樹中遞歸
4 打印當前根
然后可以畫出這個二叉樹的形狀：
- 然后是實現代碼：
public void buildTree(T[] inorder, T[] postorder) {//調用makeTree方法，即利用遞歸方法得到樹
BinaryTreeNode temp = makeTree(inorder, 0, inorder.length, postorder, 0, postorder.length);
root = temp;
這個是調用了makeTree方法，以先序和中序作為形參從而構造出樹的方法
下面是具體的makeTree方法實現：
public BinaryTreeNode<T> makeTree(T[] inorder, int startInorder, int lenInorder, T[] preorder, int startPreorder, int lenPreorder) {
if (lenInorder < 1) {//判斷中序的字符串長度（即元素個數）小於1，則返回null，即樹為空
return null;
}
BinaryTreeNode root;//創建根結點
T rootelement = preorder[startPreorder];//preorder中的第一個元素就是當前處理的數據段的根節點
root = new BinaryTreeNode(rootelement);//把給定的根結點元素放進root
int temp;
boolean isFound = false;
for (temp = 0; temp < lenInorder; temp++) {
if (inorder[startInorder + temp] == rootelement) {
isFound = true;//此時找到結點，即將先序中的第一個元素（根元素）在中序中尋找到相同元素，得到根結點的左右子樹
break;
}
}
if (!isFound)//如果不存在相等的情況就跳出該函數
return root;//即沒有左右子樹
root.setLeft(makeTree(inorder, startInorder, temp, preorder, startPreorder + 1, temp));//遞歸找到並設置各結點左孩子
root.setRight(makeTree(inorder, startInorder + temp + 1, lenInorder - temp - 1, preorder, startPreorder + temp + 1, lenPreorder - temp - 1));//遞歸找到並設置各結點右孩子
//每次遞歸，先序序列中都要往后跳過temp個元素（因為他們都是從中序序列中得知的一個結點的左或右孩子），再加1，即為下一個結點的元素
return root;
}
上面的代碼實現是參考並理解了余坤澎同學的代碼之后進行了細微修改得到的，並作出了代碼注釋
【參考資料】
余坤澎同學的碼雲鏈接
Java實現二叉樹先序，中序，后序遍歷
二叉樹前序、中序、后序遍歷相互求法 （原理，程序）
-
問題2：實驗2.3：自己設計一顆決策樹
-
問題2解決過程：
參考課本上的背部疼痛診斷類，在節點處放置問題，根據用戶輸入的Y或N，對應不同的左右孩子，並返回當前節點的元素（即下一個問題內容）
即達到設計要求
設計想法有兩種：
一是改變書上決策樹的子樹情況，設計其它的問題填充進去
二是直接改變原子樹中的節點內容，使問題問題銜接的更緊湊（雖然這一種有點偷懶，但也是要在理解原決策樹的結構基礎上才能正確更改，否則會出現答非所問的情況） -
問題3：實驗2.4：輸入中綴表達式，使用樹將中綴表達式轉換為后綴表達式，並輸出后綴表達式和計算結果
-
問題3解決過程：
這個實驗應該是六個實驗里面最不好做的一個，其中最關鍵的問題是如何將中綴轉換成后綴表達式，即如何把中綴里面的操作數和操作符存儲在樹中，然后輸出的樹即為后綴表達式
后面的后綴表達式通過課本上的后綴表達式計算出結果即可
首先，第一個問題：如何構造出后綴表達式樹
表達式樹的特點：樹的樹葉是操作數（常數或變量），而其他節點為操作符
每次找到“最后計算”的運算符，作為當前根節點，運算符左側表達式作為左節點，右側表達式作為右節點，然后遞歸處理
- 舉個栗子：9+（3-1）*3+10/2對應的二叉樹的構造過程如下圖所示：
此二叉樹做后序遍歷就得到了后綴表達式
然后，這里就存在一個優先級的問題，也就是存儲操作符時，先存儲哪個才能保證輸出表達式時是正確的
我們知道乘除的運算級要高於加減，所以要先按順序存儲乘除的運算符及其兩邊的操作數，然后將其作為一個節點放在原來的列表位置，最后再存儲加減及其兩邊的操作數
這一段的代碼實現如下：
while (operList.size() > 0) { //第三步，重復第二步，直到操作符取完為止
//第二，取出前兩個數字和一個操作符，組成一個新的數字節點
for (int a = 0; a < operList.size(); a++){
if(operList.get(a).equals("*") || operList.get(a).equals("/")){
Node left = numList.remove(a);
Node right = numList.remove(a);
String oper = operList.remove(a);
Node node = new Node(oper, left, right);
numList.add(a, node);
a--;
}
else
time++;
}
Node left = numList.remove(0);
Node right = numList.remove(0);
String oper = operList.remove(0);
Node node = new Node(oper, left, right);
numList.add(0, node); //將新生的節點作為第一個節點，同時以前index=0的節點變為index=1
}
通過在一個循環里面判斷操作符有沒有乘除一級的運算，然后執行上述的相應操作
在for循環外面再按順序對加減一級的操作符進行相應操作，即可達到轉后綴的要求
最后一個，代碼的問題：在寫代碼的時候，會報出下圖中的錯誤
通過debug發現問題所在，是這個for循環的問題，這個循環不能正常結束，會超出范圍
那么問題就是，為什么會不能正常結束循環？
這里的變量a是當前乘除一級的操作符在列表中的索引值（這里的操作數和操作符是存儲在列表里的）
所以就導致了問題出現：ArrayList沒有空位置，刪除后的元素會被后面的元素自動補全
所以當一個乘除一級運算很多的中綴表達式，在找到乘除運算符的索引時，對應操作數中的索引值可能已經超出了循環的終止條件count的值（count是操作符的個數）
count是個定值，無法保證對所有的表達式都能正確轉換成后綴表達式
經過很多次嘗試和思考，才找到了最終的終止條件，那就是上面給出的代碼 a < operList.size() 操作符的元素個數會變化，這里用size()方法就解決了
【參考資料】
前綴，中綴，后綴表達式學習筆記(1)
前綴、中綴、后綴表達式和二叉樹
二叉樹應用——后綴表達式構建表達式樹
用二叉樹表示表達式
中綴表達式轉后綴表達式---棧--二叉樹---四則運算
樹之紅黑樹分析結果報告
一、首先要了解一下什么是treeMap和HashMap
Map：在數組中我們是通過數組下標來對其內容索引的，而在Map中我們通過對象來對對象進行索引，用來索引的對象叫做key，其對應的對象叫做value（就是我們平時說的鍵值對）
二、 HashMap
HashMap 是基於哈希表的 Map 接口的實現。此實現提供所有可選的映射操作，並允許使用 null 值和 null 鍵。（除了非同步和允許使用 null 之外，HashMap 類與 Hashtable 大致相同。）此類不保證映射的順序，特別是它不保證該順序恆久不變。
官方文檔
官方文檔如下：
此實現假定哈希函數將元素適當地分布在各桶之間，可為基本操作（get 和 put）提供穩定的性能。迭代 collection 視圖所需的時間與 HashMap 實例的“容量”（桶的數量）及其大小（鍵-值映射關系數）成比例。所以，如果迭代性能很重要，則不要將初始容量設置得太高（或將加載因子設置得太低）。
HashMap 的實例有兩個參數影響其性能：初始容量 和加載因子。容量 是哈希表中桶的數量，初始容量只是哈希表在創建時的容量。加載因子 是哈希表在其容量自動增加之前可以達到多滿的一種尺度。當哈希表中的條目數超出了加載因子與當前容量的乘積時，則要對該哈希表進行 rehash 操作（即重建內部數據結構），從而哈希表將具有大約兩倍的桶數。
通常，默認加載因子 (.75) 在時間和空間成本上尋求一種折衷。加載因子過高雖然減少了空間開銷，但同時也增加了查詢成本（在大多數 HashMap 類的操作中，包括 get 和 put 操作，都反映了這一點）。在設置初始容量時應該考慮到映射中所需的條目數及其加載因子，以便最大限度地減少 rehash 操作次數。如果初始容量大於最大條目數除以加載因子，則不會發生 rehash 操作。
如果很多映射關系要存儲在 HashMap 實例中，則相對於按需執行自動的 rehash 操作以增大表的容量來說，使用足夠大的初始容量創建它將使得映射關系能更有效地存儲。
注意，此實現不是同步的。如果多個線程同時訪問一個哈希映射，而其中至少一個線程從結構上修改了該映射，則它必須 保持外部同步。（結構上的修改是指添加或刪除一個或多個映射關系的任何操作；僅改變與實例已經包含的鍵關聯的值不是結構上的修改。）這一般通過對自然封裝該映射的對象進行同步操作來完成。如果不存在這樣的對象，則應該使用 Collections.synchronizedMap 方法來“包裝”該映射。最好在創建時完成這一操作，以防止對映射進行意外的非同步訪問，如下所示：
Map m = Collections.synchronizedMap(new HashMap(…));
由所有此類的“collection 視圖方法”所返回的迭代器都是快速失敗 的：在迭代器創建之后，如果從結構上對映射進行修改，除非通過迭代器本身的 remove 方法，其他任何時間任何方式的修改，迭代器都將拋出 ConcurrentModificationException。因此，面對並發的修改，迭代器很快就會完全失敗，而不冒在將來不確定的時間發生任意不確定行為的風險。
HashMap中有三個關於紅黑樹的關鍵參數
//一個桶的樹化閾值
//當桶中元素個數超過這個值時，需要使用紅黑樹節點替換鏈表節點
//這個值必須為 8，要不然頻繁轉換效率也不高
static final int TREEIFY_THRESHOLD = 8;
//一個樹的鏈表還原閾值
//當擴容時，桶中元素個數小於這個值，就會把樹形的桶元素 還原（切分）為鏈表結構
//這個值應該比上面那個小，至少為 6，避免頻繁轉換
static final int UNTREEIFY_THRESHOLD = 6;
//哈希表的最小樹形化容量
//當哈希表中的容量大於這個值時，表中的桶才能進行樹形化
//否則桶內元素太多時會擴容，而不是樹形化
//為了避免進行擴容、樹形化選擇的沖突，這個值不能小於 4 * TREEIFY_THRESHOLD
static final int MIN_TREEIFY_CAPACITY = 64;
treeifyBin
HashMap中樹形化最重要的一個方法treeifyBin() 即樹形化。在一個桶中的元素個數超過 TREEIFY_THRESHOLD(默認是8)，就使用紅黑樹來替換鏈表。
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//如果hash表為空或者hash表的容量小於MIN_TREEIFY_CAPACITY（64），那么就去新建或者擴容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
//新建一個樹形節點，內容和當前鏈表節點一致
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p; //頭節點
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
//之前得到的只是一個鏈表狀的二叉樹，下一步格式化紅黑樹
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
return new TreeNode<>(p.hash, p.key, p.value, next);
}
HashMap類屬性及構造函數
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
// 序列號
private static final long serialVersionUID = 362498820763181265L;
// 默認的初始容量是16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默認的填充因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 當桶(bucket)上的結點數大於這個值時會轉成紅黑樹
static final int TREEIFY_THRESHOLD = 8;
// 當桶(bucket)上的結點數小於這個值時樹轉鏈表
static final int UNTREEIFY_THRESHOLD = 6;
// 桶中結構轉化為紅黑樹對應的table的最小大小
static final int MIN_TREEIFY_CAPACITY = 64;
// 存儲元素的數組，總是2的冪次倍
transient Node<k,v>[] table;
// 存放具體元素的集
transient Set<map.entry<k,v>> entrySet;
// 存放元素的個數，注意這個不等於數組的長度。
transient int size;
// 每次擴容和更改map結構的計數器
transient int modCount;
// 臨界值 當實際大小(容量*填充因子)超過臨界值時，會進行擴容
int threshold;
// 填充因子
final float loadFactor;
}
HashMap類的主要方法
1.putVal函數（put操作的基礎函數）
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//檢測table是否為空，如果為空，則使用擴容函數進行初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//如果通過hash值取模得到的桶為空，則直接把新生成的節點放入該桶
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {//以下為該桶不為空的邏輯
Node<K,V> e; K k;
//判斷桶的第一個元素的key值是否相同（hash值相同，且能equals）
//如果相同，則返回當前元素（函數末尾進行統一處理）
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)//桶元素采用的是紅黑樹結構
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {//桶元素采用的是鏈表結構
for (int binCount = 0; ; ++binCount) {
//如果遍歷到了鏈表末端，則直接在鏈表末端插入新元素
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//插入之后，檢查是否達到了轉成紅黑樹結構的標准
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果在遍歷過程中，發現了key值相同，則返回當前元素（函數末尾進行統一處理）
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//處理相同元素的情況
if (e != null) { // existing mapping for key
V oldValue = e.value;
//如果onlyIfAbsent為ture，則在oldValue為空時才替換
//否則直接替換
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;//修改次數+1
//map的size加1，然后判斷是否達到了threshold，否則進行擴容
//threshold由Node[] table的長度及loadFactor控制
if (++size > threshold)
resize();
//執行回調函數
afterNodeInsertion(evict);
return null;
}
2.put函數
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
3.getNode函數（get操作的基礎函數）
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//如果table不為空，則再進行查詢操作
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//先檢查第一個元素是否key相同
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
//如果為紅黑樹結構，則走紅黑樹的查詢邏輯
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {//否則遍歷鏈表
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
4.resize()函數
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
//如果擴容之前的容量已經達到了最大值
//則只把threshold變成Integer.MAX_VALUE，即不限制map的最大size，之后不管插入多少元素也不觸發resize
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}//把新容量變成原來的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // 初始capacity（構造函數輸入的）被設置成了threshold
newCap = oldThr;
else { // oldThr=0的情況，此時表明采用默認的參數進行初始化
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//處理好newThr和newCap之后，開始resize()函數的真正邏輯
threshold = newThr;//設置threshold
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//如果原來桶的首元素不為空，則進行復制邏輯
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//如果該桶只裝了一個元素，則直接復制
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)//紅黑樹的情況
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else {
// 鏈式情況，此時會把原來的鏈分成兩個鏈loHead和hiHead
//loHead存儲(e.hash & oldCap) == 0的元素
//hiHead存儲(e.hash & oldCap) != 0的元素
//擴容之后，由於新的capacity為oldCap的2倍，且它們都為2的整數冪
//對於該鏈上的元素，如果(e.hash & oldCap) == 0，則新的槽位(hash%capacity)==舊的槽位(hash%oldCap)
//否則，它們新的槽位都一樣，且都為原來的槽位后移oldCap
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
三、TreeMap
（1）TreeMap（）：構建一個空的映像樹
（2）TreeMap（Map m）： 構建一個映像樹，並且添加映像m中所有元素
（3）TreeMap（Comparator c）： 構建一個映像樹，並且使用特定的比較器對關鍵字進行排序
（4）TreeMap（SortedMap s）： 構建一個映像樹，添加映像樹s中所有映射，並且使用與有序映像s相同的比較器排序。
官方文檔：
基於紅黑樹（Red-Black tree）的 NavigableMap 實現。該映射根據其鍵的自然順序進行排序，或者根據創建映射時提供的 Comparator 進行排序，具體取決於使用的構造方法。
此實現為 containsKey、get、put 和 remove 操作提供受保證的 log(n) 時間開銷。這些算法是 Cormen、Leiserson 和 Rivest 的 Introduction to Algorithms 中的算法的改編。
注意，如果要正確實現 Map 接口，則有序映射所保持的順序（無論是否明確提供了比較器）都必須與 equals 一致。（關於與 equals 一致 的精確定義，請參閱 Comparable 或 Comparator）。這是因為 Map 接口是按照 equals 操作定義的，但有序映射使用它的 compareTo（或 compare）方法對所有鍵進行比較，因此從有序映射的觀點來看，此方法認為相等的兩個鍵就是相等的。即使排序與 equals 不一致，有序映射的行為仍然是 定義良好的，只不過沒有遵守 Map 接口的常規協定。
注意，此實現不是同步的。如果多個線程同時訪問一個映射，並且其中至少一個線程從結構上修改了該映射，則其必須 外部同步。（結構上的修改是指添加或刪除一個或多個映射關系的操作；僅改變與現有鍵關聯的值不是結構上的修改。）這一般是通過對自然封裝該映射的對象執行同步操作來完成的。如果不存在這樣的對象，則應該使用 Collections.synchronizedSortedMap 方法來“包裝”該映射。最好在創建時完成這一操作，以防止對映射進行意外的不同步訪問，如下所示：
SortedMap m = Collections.synchronizedSortedMap(new TreeMap(…));
collection（由此類所有的“collection 視圖方法”返回）的 iterator 方法返回的迭代器都是快速失敗 的：在迭代器創建之后，如果從結構上對映射進行修改，除非通過迭代器自身的 remove 方法，否則在其他任何時間以任何方式進行修改都將導致迭代器拋出 ConcurrentModificationException。因此，對於並發的修改，迭代器很快就完全失敗，而不會冒着在將來不確定的時間發生不確定行為的風險。
構造方法：TreeMap一共有4個構造方法
1、無參構造方法
public TreeMap() {
comparator = null;
}
采用無參構造方法，不指定比較器，這時候，排序的實現要依賴key.compareTo()方法，因此key必須實現Comparable接口，並覆寫其中的compareTo方法。
2、帶有比較器的構造方法
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
采用帶比較器的構造方法，這時候，排序依賴該比較器，key可以不用實現Comparable接口。
3、帶Map的構造方法
public TreeMap(Map<? extends K, ? extends V> m) {
comparator = null;
putAll(m);
}
該構造方法同樣不指定比較器，調用putAll方法將Map中的所有元素加入到TreeMap中
4、帶有SortedMap的構造方法
public TreeMap(SortedMap<K, ? extends V> m) {
comparator = m.comparator();
try {
buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
}
首先將比較器指定為m的比較器，這取決於生成m時調用構造方法是否傳入了指定的構造器，而后調用buildFromSorted方法，將SortedMap中的元素插入到TreeMap中，由於SortedMap中的元素師有序的，實際上它是根據SortedMap創建的TreeMap，將SortedMap中對應的元素添加到TreeMap中。
插入刪除
插入操作即對應TreeMap的put方法，put操作實際上只需按照二叉排序樹的插入步驟來操作即可，插入到指定位置后，再做調整，使其保持紅黑樹的特性。
put源碼的實現：
public V put(K key, V value) {
Entry<K,V> t = root;
// 若紅黑樹為空，則插入根節點
if (t == null) {
// TBD:
// 5045147: (coll) Adding null to an empty TreeSet should
// throw NullPointerException
//
// compare(key, key); // type check
root = new Entry<K,V>(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
// 找出(key, value)在二叉排序樹中的插入位置。
// 紅黑樹是以key來進行排序的，所以這里以key來進行查找。
if (cpr != null) {
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
else {
if (key == null)
throw new NullPointerException();
Comparable<? super K> k = (Comparable<? super K>) key;
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
// 為（key-value）新建節點
Entry<K,V> e = new Entry<K,V>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
// 插入新的節點后，調用fixAfterInsertion調整紅黑樹。
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
deleteEntry方法的實現源碼如下：
// 刪除“紅黑樹的節點p”
private void deleteEntry(Entry<K,V> p) {
modCount++;
size--;
if (p.left != null && p.right != null) {
Entry<K,V> s = successor (p);
p.key = s.key;
p.value = s.value;
p = s;
}
Entry<K,V> replacement = (p.left != null ? p.left : p.right);
if (replacement != null) {
replacement.parent = p.parent;
if (p.parent == null)
root = replacement;
else if (p == p.parent.left)
p.parent.left = replacement;
else
p.parent.right = replacement;
p.left = p.right = p.parent = null;
if (p.color == BLACK)
fixAfterDeletion(replacement);
} else if (p.parent == null) {
root = null;
} else {
if (p.color == BLACK)
fixAfterDeletion(p);
if (p.parent != null) {
if (p == p.parent.left)
p.parent.left = null;
else if (p == p.parent.right)
p.parent.right = null;
p.parent = null;
}
}
}
fixAfterDeletion方法便是節點刪除后對樹進行調整的方法
總結：
1、TreeMap是根據key進行排序的，它的排序和定位需要依賴比較器或覆寫Comparable接口，也因此不需要key覆寫hashCode方法和equals方法，就可以排除掉重復的key，而HashMap的key則需要通過覆寫hashCode方法和equals方法來確保沒有重復的key
2、TreeMap的查詢、插入、刪除效率均沒有HashMap高，一般只有要對key排序時才使用TreeMap
3、TreeMap的key不能為null，而HashMap的key可以為null。
四、HashMap和TreeMap比較
（1）HashMap:適用於在Map中插入、刪除和定位元素。
（2）Treemap:適用於按自然順序或自定義順序遍歷鍵（key）。
（3）HashMap通常比TreeMap快一點（樹和哈希表的數據結構使然），建議多使用HashMap,在需要排序的Map時候才用TreeMap.
（4）HashMap 非線程安全 TreeMap 非線程安全
（5）HashMap的結果是沒有排序的，而TreeMap輸出的結果是排好序的。
【參考資料】
Java Collections API源碼分析
【Java集合源碼剖析】TreeMap源碼剖析
TreeMap（紅黑樹）源碼分析
HashMap和TreeMap區別詳解以及底層實現
4.感悟
本次實驗對樹的學習之后運用的檢測性很強，只有真正對樹的結構和原理熟練掌握才能做好實驗
同時也讓我知道了我對樹的運用還很欠缺，仍然需要繼續努力、學習