【資料結構】二叉樹
一、二叉樹介紹
簡單地理解，滿足以下兩個條件的樹就是二叉樹：
-
本身是有序樹；
-
樹中包含的各個節點的度不能超過 2，即只能是 0、1 或者 2；
二、二叉樹的性質
經過前人的總結，二叉樹具有以下幾個性質：
-
二叉樹中，第 i 層最多有 2i-1個結點。
-
如果二叉樹的深度為 K，那麼此二叉樹最多有 2K-1 個結點。
-
二叉樹中，終端結點數（葉子結點數）為 n0，度為 2 的結點數為 n2，則 n0=n2+1。
性質 3 的計算方法為：對於一個二叉樹來說，除了度為 0 的葉子結點和度為 2 的結點，剩下的就是度為 1 的結點（設為 n1），那麼總結點 n=n0+n1
兩種方式得到的 n 值組成一個方程組，就可以得出 n0=n2+1。
二叉樹還可以繼續分類，衍生出滿二叉樹和完全二叉樹。
三、滿二叉樹
如果二叉樹中除了葉子結點，每個結點的度都為 2，則此二叉樹稱為滿二叉樹。
如圖 2 所示就是一棵滿二叉樹。
滿二叉樹除了滿足普通二叉樹的性質，還具有以下性質：
-
滿二叉樹中第 i 層的節點數為 2n-1個。
-
深度為 k 的滿二叉樹必有 2k
-1 個節點 ，葉子數為 2k-1。 -
滿二叉樹中不存在度為 1 的節點，每一個分支點中都兩棵深度相同的子樹，且葉子節點都在最底層。
-
具有 n 個節點的滿二叉樹的深度為 log2(n+1)。
四、完全二叉樹
如果二叉樹中除去最後一層節點為滿二叉樹，且最後一層的結點依次從左到右分佈，則此二叉樹被稱為完全二叉樹。
如圖 3a) 所示是一棵完全二叉樹，圖 3b) 由於最後一層的節點沒有按照從左向右分佈，因此只能算作是普通的二叉樹。
完全二叉樹除了具有普通二叉樹的性質，它自身也具有一些獨特的性質，比如說，n 個結點的完全二叉樹的深度為 ⌊log2n⌋+1。
⌊log2
對於任意一個完全二叉樹來說，如果將含有的結點按照層次從左到右依次標號（如圖 3a)），對於任意一個結點 i ，完全二叉樹還有以下幾個結論成立：
-
當 i>1 時，父親結點為結點 [i/2] 。（i=1 時，表示的是根結點，無父親結點）
-
如果 2*i>n（總結點的個數） ，則結點 i 肯定沒有左孩子（為葉子結點）；否則其左孩子是結點 2*i 。
-
如果 2*i+1>n ，則結點 i 肯定沒有右孩子；否則右孩子是結點 2*i+1 。
五、樹的儲存結構
二叉樹的儲存結構有兩種，分別為順序儲存和鏈式儲存。
1 、順序儲存
二叉樹的順序儲存，指的是使用順序表（陣列）儲存二叉樹。需要注意的是，順序儲存只適用於完全二叉樹。換句話說，只有完全二叉樹才可以使用順序表儲存。因此，如果我們想順序儲存普通二叉樹，需要提前將普通二叉樹轉化為完全二叉樹。
有讀者會說，滿二叉樹也可以使用順序儲存。要知道，滿二叉樹也是完全二叉樹，因為它滿足完全二叉樹的所有特徵。
普通二叉樹轉完全二叉樹的方法很簡單，只需給二叉樹額外新增一些節點，將其"拼湊"成完全二叉樹即可。如圖1 所示：
圖 1 中，左側是普通二叉樹，右側是轉化後的完全（滿）二叉樹。
解決了二叉樹的轉化問題，接下來學習如何順序儲存完全（滿）二叉樹。
完全二叉樹的順序儲存，僅需從根節點開始，按照層次依次將樹中節點儲存到陣列即可。
--->
儲存由普通二叉樹轉化來的完全二叉樹也是如此
--->
非常重要
完全二叉樹具有這樣的性質，將樹中節點按照層次並從左到右依次標號（0,1,2,3,...），
若節點 i 有左右孩子，則其左孩子節點為 2 * i + 1，右孩子節點為 2 * i+2。
此性質可用於還原陣列中儲存的完全二叉樹
2、鏈式儲存
--->
如圖 1 所示，此為一棵普通的二叉樹，若將其採用鏈式儲存，則只需從樹的根節點開始，將各個節點及其左右孩子使用連結串列儲存即可。
因此，圖 1 對應的鏈式儲存結構如圖 2 所示：
由圖 2 可知，採用鏈式儲存二叉樹時，其節點結構由 3 部分構成（如圖 3 所示）：
-
指向左孩子節點的指標（Lchild）；
-
節點儲存的資料（data）；
-
指向右孩子節點的指標（Rchild）
六、樹的遍歷
-
前序遍歷:先輸出父節點， 再遍歷左子樹和右子樹
-
中序遍歷: 先遍歷左子樹，再輸出父節點， 再遍歷右子樹
-
後序遍歷: 先遍歷左子樹， 再遍歷右子樹，最後輸出父節點
看輸出父節點的順序，就確定是前序，中序還是後序
示例程式碼如下：
1 public class BinaryTree { 2 3 4 public static void main(String[] args) { 5 BinaryTree binaryTree = new BinaryTree(); 6 TreeNode node = binaryTree.initTree(); 7 List<Integer> preList = binaryTree.preOrder(node); 8 System.out.println("preList = " + preList); 9 List<Integer> midOrder = binaryTree.midOrder(node); 10 System.out.println("midOrder = " + midOrder); 11 List<Integer> afterOrder = binaryTree.afterOrder(node); 12 System.out.println("afterOrder = " + afterOrder); 13 } 14 15 // 先遍歷左子樹，再遍歷右子樹，最後輸出父節點 16 public List<Integer> afterOrder(TreeNode node) { 17 List<Integer> list = new ArrayList<>(); 18 if (node != null) { 19 list.addAll(afterOrder(node.left)); 20 list.addAll(afterOrder(node.right)); 21 list.add(node.val); 22 } 23 return list; 24 } 25 26 // 先遍歷左子樹，再輸出父節點，再遍歷右子樹 27 public List<Integer> midOrder(TreeNode node) { 28 List<Integer> list = new ArrayList<>(); 29 if (node != null) { 30 list.addAll(midOrder(node.left)); 31 list.add(node.val); 32 list.addAll(midOrder(node.right)); 33 } 34 return list; 35 } 36 37 // 先輸出父節點，再遍歷左子樹和右子樹 38 public List<Integer> preOrder(TreeNode node) { 39 List<Integer> list = new ArrayList<>(); 40 if (node != null) { 41 list.add(node.val); 42 list.addAll(preOrder(node.left)); 43 list.addAll(preOrder(node.right)); 44 } 45 return list; 46 } 47 48 private TreeNode initTree() { 49 // 1 50 // 2 3 51 // 4 5 6 7 52 TreeNode node2 = new TreeNode(2, new TreeNode(4), new TreeNode(5)); 53 TreeNode node3 = new TreeNode(3, new TreeNode(6), new TreeNode(7)); 54 return new TreeNode(1, node2, node3); 55 } 56 57 58 static class TreeNode { 59 int val; 60 TreeNode left; 61 TreeNode right; 62 63 TreeNode() { 64 } 65 66 TreeNode(int val) { 67 this.val = val; 68 } 69 70 TreeNode(int val, TreeNode left, TreeNode right) { 71 this.val = val; 72 this.left = left; 73 this.right = right; 74 } 75 } 76 }View Code
順序儲存二叉樹的遍歷
示例程式碼如下：
1 public class ArrBinaryTree { 2 3 public List<Integer> preOrder(int[] arr) { 4 return preOrder(arr, 0); 5 } 6 7 // 前序遍歷 8 private List<Integer> preOrder(int[] arr, int index) { 9 List<Integer> list = new ArrayList<>(); 10 if(index < arr.length) { 11 list.add(arr[index]); 12 list.addAll(preOrder(arr, 2 * index + 1)); 13 list.addAll(preOrder(arr, 2 * index + 2)); 14 } 15 return list; 16 } 17 18 public List<Integer> midOrder(int[] arr) { 19 return midOrder(arr, 0); 20 } 21 22 // 中序遍歷 23 private List<Integer> midOrder(int[] arr, int index) { 24 List<Integer> list = new ArrayList<>(); 25 if(index < arr.length) { 26 list.addAll(midOrder(arr, 2 * index + 1)); 27 list.add(arr[index]); 28 list.addAll(midOrder(arr, 2 * index + 2)); 29 } 30 return list; 31 } 32 33 // 前序遍歷轉化 34 public TreeNode preOrderConvert(int[] arr) { 35 return preOrderConvert(arr, 0); 36 } 37 38 private TreeNode preOrderConvert(int[] arr, int index) { 39 if(index < arr.length) { 40 TreeNode treeNode = new TreeNode(arr[index]); 41 treeNode.left = preOrderConvert(arr, 2 * index + 1); 42 treeNode.right = preOrderConvert(arr, 2 * index + 2); 43 return treeNode; 44 } 45 return null; 46 } 47 48 public static void main(String[] args) { 49 int[] arr = {1, 2, 3, 4, 5, 6, 7}; 50 ArrBinaryTree arrBinaryTree = new ArrBinaryTree(); 51 // 前序遍歷 52 List<Integer> proList = arrBinaryTree.preOrder(arr); 53 System.out.println("proList = " + proList); 54 // 中序遍歷 55 List<Integer> midList = arrBinaryTree.midOrder(arr); 56 System.out.println("midList = " + midList); 57 58 // 轉化成樹，前序遍歷轉化 59 TreeNode treeNode = arrBinaryTree.preOrderConvert(arr); 60 System.out.println("treeNode = " + treeNode); 61 } 62 63 static class TreeNode { 64 int val; 65 TreeNode left; 66 TreeNode right; 67 68 TreeNode() { 69 } 70 71 TreeNode(int val) { 72 this.val = val; 73 } 74 75 TreeNode(int val, TreeNode left, TreeNode right) { 76 this.val = val; 77 this.left = left; 78 this.right = right; 79 } 80 } 81 }View Code
七、線索化二叉樹
將數列 {1, 3, 6, 8, 10, 14 } 構建成一顆二叉樹，當我們對這顆二叉樹進行中序遍歷時， 輸出數列為 {8, 3, 10, 1, 6, 14 }
但是 6, 8, 10, 14 這幾個節點的左右指標，並沒有完全的利用上，如果我們希望充分的利用 各個節點的左右指標， 讓各個節點可以指向自己的前後節點，怎麼辦?
解決方案：線索二叉樹
線索二叉樹基本介紹
-
n 個結點的二叉連結串列中含有 n+1 【公式 2n-(n-1)=n+1】 個空指標域。 利用二叉連結串列中的空指標域， 存放指向該結點在某種遍歷次序下的前驅和後繼結點的指標（這種附加的指標稱為"線索"）
-
這種加上了線索的二叉連結串列稱為線索連結串列， 相應的二叉樹稱為線索二叉樹(Threaded BinaryTree)。
-
根據線索性質的不同， 線索二叉樹可分為前序線索二叉樹、 中序線索二叉樹和後序線索二叉樹三種
-
前驅結點和後繼節點：
- 一個結點的前一個結點， 稱為前驅結點
- 一個結點的後一個結點， 稱為後繼結點
-
當我們對二叉樹進行中序遍歷時， 得到的數列為 {8, 3, 10, 1, 6, 14 }
-
那麼 8 節點的前驅結點為 null ，8 和後驅節點為 3
-
那麼 3 節點的前驅結點為 8 ，3 和後驅節點為 10
-
以此類推…
-
程式碼實現
1 public class ThreadBinaryTree { 2 3 // 最後處理過的節點，即當前處理節點的前一個處理節點 4 private TreeNode preNode; 5 6 // 中序線索化 7 public void midOrderThreadedNodes(TreeNode node) { 8 if (node != null) { 9 // 1、先線索化左子樹 10 midOrderThreadedNodes(node.left); 11 // 2、線索化當前節點 12 if (node.left == null) { 13 node.leftType = 1; 14 node.left = preNode; 15 } 16 if (preNode != null && preNode.right == null) { 17 preNode.rightType = 1; 18 preNode.right = node; 19 } 20 // 更新preNode節點 21 preNode = node; 22 // 3、再線索化右子樹 23 midOrderThreadedNodes(node.right); 24 } 25 } 26 27 // 遍歷中序線索化二叉樹 28 public List<Integer> midOrderThreadList(TreeNode treeNode) { 29 List<Integer> list = new ArrayList<>(); 30 // 找到leftType = 1 && left == null 的節點 31 // 這個節點就是第一個線索化的節點 32 TreeNode node = treeNode; 33 while (node != null) { 34 35 while (node.leftType == 0) { 36 node = node.left; 37 } 38 39 list.add(node.val); 40 41 while (node.rightType == 1) { 42 node = node.right; 43 list.add(node.val); 44 } 45 46 node = node.right; 47 } 48 return list; 49 } 50 51 public List<Integer> midOrder(TreeNode node) { 52 List<Integer> list = new ArrayList<>(); 53 if (node != null) { 54 list.addAll(midOrder(node.left)); 55 list.add(node.val); 56 list.addAll(midOrder(node.right)); 57 } 58 return list; 59 } 60 61 public static void main(String[] args) { 62 ThreadBinaryTree threadBinaryTree = new ThreadBinaryTree(); 63 TreeNode treeNode = threadBinaryTree.initTree(); 64 List<Integer> midOrder = threadBinaryTree.midOrder(treeNode); 65 System.out.println("midOrder = " + midOrder); 66 67 threadBinaryTree.midOrderThreadedNodes(treeNode); 68 System.out.println("treeNode = " + treeNode); 69 70 List<Integer> orderThreadList = threadBinaryTree.midOrderThreadList(treeNode); 71 System.out.println("orderThreadList = " + orderThreadList); 72 } 73 74 private TreeNode initTree() { 75 // 1 76 // 2 3 77 // 4 5 6 78 TreeNode node2 = new TreeNode(2, new TreeNode(4), new TreeNode(5)); 79 TreeNode node3 = new TreeNode(3, new TreeNode(6), null); 80 return new TreeNode(1, node2, node3); 81 } 82 83 84 static class TreeNode { 85 int val; 86 // 左指標型別，0樹節點指向型別 1線索化指標,前驅節點 87 int leftType; 88 TreeNode left; 89 // 右 指標型別，0樹節點指向型別 1線索化指標,後驅節點 90 int rightType; 91 TreeNode right; 92 93 TreeNode() { 94 } 95 96 TreeNode(int val) { 97 this.val = val; 98 } 99 100 TreeNode(int val, TreeNode left, TreeNode right) { 101 this.val = val; 102 this.left = left; 103 this.right = right; 104 } 105 } 106 }View Code
參考：http://data.biancheng.net/view/194.html