再也不害怕！二叉樹結構相關算法總結
寫在前面
樹結構對於程序員來講應該不陌生，特別是二叉樹，基本只要接觸算法這一類的都必定會碰到的，因此我打算經過一篇文章，對二叉樹結構的相關算法進行總結匯總，思路和代碼實現相結合，讓你不在害怕二叉樹。（ps：後面我還想寫一篇樹結構的高級篇，就是多叉數，就是對我平時看算法論文碰到的一些新奇的算法，好比B樹、B+樹，還有我一種叫作Bed樹的新奇算法等等）
單純就是想分享技術博文，還想說一句就是，若是以爲有用，請點個關注、給個贊吧，也算對我來講是個寬慰，畢竟也得掉很多頭髮，嘿嘿嘿html
預備
下面的思路講解中，我會給出一個類僞代碼的思路，而後進行相關說明，也就是一種思路框架，有了思路框架，之後碰到問題就直接交給框架完成。本文主要說一下二叉搜索樹（Binary Search Tree，簡稱 BST），BST是一種很經常使用的的二叉樹。它的定義是：一個二叉樹中，任意節點的值要大於等於左子樹全部節點的值，且要小於等於右邊子樹的全部節點的值。以下就是一個符合定義的 BST：
後面若是遇到特殊的思路結構，如多叉樹，我會特別說明。首先咱們先給出二叉樹的節點定義（這個定義應該不陌生吧，有刷算法題都會碰到）。node
public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } }
遞歸
不過這裏要說明一點的是，在僞代碼中的「進行想要的操做」的位置，不必定就在我放置的位置，具體位置還須要咱們根據不一樣的實際需求進行判斷。不過由於前中後序的遍歷，遞歸進入的時機應該須要和個人同樣。程序員
先序遍歷
遍歷根節點，若是根節點爲空，返回；不然，遍歷根節點，而後先序遍歷左子樹，再先序遍歷右子樹。web
public void preorderTraverse(TreeNode root){ System.out.print(node.val+" "); preorderTraverse(root.left); preorderTraverse(root.right); }
中序遍歷
路過根節點，若是根節點爲空，返回；不然，中序遍歷左子樹，而後遍歷根節點，再中序遍歷右子樹。算法
public void inorderTraverse(TreeNode root){ inorderTraverse(root.left); System.out.print(node.val+" "); inorderTraverse(root.right); }
後序遍歷
路過根節點，若是根節點爲空，返回；不然，後序遍歷左子樹，再後序遍歷右子樹，最後遍歷根節點。app
public void postorderTraverse(TreeNode root){ postorderTraverse(root.left); postorderTraverse(root.right); System.out.print(node.val+" "); }
迭代（非遞歸）
咱們使用迭代的思想，其實就是利用循環和棧來模擬遞歸的操做，上面遞歸的操做，其實就是一個不斷將本身以及左右子節點進行壓棧和出棧的過程，若是理解了上面的算法下面的算法就好理解了框架
前序遍歷
public List<Integer> preorderTraversal(TreeNode root) { List<Integer> list = new ArrayList<>(); if(root==null){ return list; } Stack<TreeNode> stack = new Stack<>(); stack.push(root); while(!stack.isEmpty()){ TreeNode res = stack.pop(); if(res.right != null) stack.push(res.right); if(res.left != null) stack.push(res.left); list.add(res.val); } return list; }
中序遍歷
public List<Integer> inorderTraversal(TreeNode root) { List<Integer> list = new ArrayList<>(); if(root==null){ return list; } Stack<TreeNode> stack = new Stack<>(); TreeNode curr = root; while(curr != null || !(stack.isEmpty())){ if(curr!= null){ stack.push(curr); curr = curr.left; }else{ curr = stack.pop(); list.add(curr.val); curr = curr.right; } } return list; }
後序遍歷
咱們能夠很簡單的實現另外一種遍歷：」根->右->左「遍歷。雖然這種遍歷沒有名字，可是他是後序遍歷的反序。因此咱們能夠利用兩個棧，利用棧的LIFO特色，來實現後續遍歷。svg
public List<Integer> preorderTraversal(TreeNode root) { List<Integer> list = new ArrayList<>(); if(root==null){ return list; } Stack<TreeNode> stack = new Stack<>(); stack.push(root); while(!stack.isEmpty()){ TreeNode res = stack.pop(); if(res.left != null) stack.push(res.left); if(res.right != null) stack.push(res.right); list.add(res.val); } list.reserve(); return list; }
深度優先搜索（DFS）
其實，二叉樹的先序遍歷，中序遍歷，後序遍歷，都是深度優先搜索，深搜是一種思想，並不具體指代實現方式，你可使用遞歸，也可使用棧來實現，因此上面提到的都是深度優先搜索的實現方式，畢竟「深度優先」嘛。
那在這裏我就是提幾個實際的應用的例子，加深一下印象。post
*二叉樹的最大深度
public int maxDepth(TreeNode root) { if(root==null){ return 0; } int left = maxDepth(root.left); int right = maxDepth(root.right); return Math.max(left,right)+1; }
*二叉樹的鏡像
public void Mirror(TreeNode root) { if(root!=null){ if(root.left!=null || root.right!= null){ TreeNode temp =root.left; root.left=root.right; root.right=temp; } Mirror(root.left); Mirror(root.right); } }
*對稱二叉樹
boolean isSymmetrical(TreeNode pRoot){ if(pRoot == null) return true; return real(pRoot.left,pRoot.right); } public boolean real(TreeNode root1,TreeNode root2){ if(root1 == null && root2 == null){ return true; } if(root1 ==null || root2 == null){ return false; } if(root1.val != root2.val){ return false; } return real(root1.left,root2.right)&&real(root1.right,root2.left); }
*路徑總和
public class Solution { private ArrayList<Integer> list = new ArrayList<Integer>(); private ArrayList<ArrayList<Integer>> listAll = new ArrayList<ArrayList<Integer>>(); public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) { if(root == null) return listAll; list.add(root.val); target -= root.val; if(target == 0 && root.left==null && root.right == null){ listAll.add(new ArrayList<Integer>(list)); } FindPath(root.left,target); FindPath(root.right,target); list.remove(list.size()-1); return listAll; } }
*重建二叉樹
public TreeNode reConstructBinaryTree(int [] pre,int [] in) { return reConstructBinaryTree(pre,0,pre.length-1,in,0,in.length-1); } public TreeNode reConstructBinaryTree(int [] pre,int startpre,int endpre,int [] in,int startin,int endin){ if(startpre > endpre || startin > endin){ return null; } TreeNode root = new TreeNode(pre[startpre]); for(int i =startin;i<=endin;i++){ if(in[i] == pre[startpre]){ root.left = reConstructBinaryTree(pre,startpre+1,startpre+i-startin,in,startin,i-1); root.right = reConstructBinaryTree(pre,startpre+i-startin+1,endpre,in,i+1,endin); } } return root; }
*二叉搜索樹的最近公共祖先
class Solution { public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { if(root == null || root == p || root == q){ return root; } TreeNode left = lowestCommonAncestor(root.left,p,q); TreeNode right = lowestCommonAncestor(root.right,p,q); if(left!=null && right!=null){ return root; } return left!=null?left:right; } }
*二叉樹的序列化和反序列化
序列化： public String serialize(TreeNode root) { if (root == null) { return null; } // 利用二叉樹的層次遍歷方式進行序列化 StringBuilder res = new StringBuilder(); LinkedList<TreeNode> queue = new LinkedList<>(); queue.add(root); while (!queue.isEmpty()) { TreeNode node = queue.remove(); if (node != null) { res.append(node.val).append(","); queue.add(node.left); queue.add(node.right); } else { res.append("null,"); } } return res.toString(); } 反序列化： public TreeNode deserialize(String data) { if (data == null || data.length() == 0) { return null; } String[] dataArr = data.split(","); // 層次遍歷逆向還原二叉樹 int index = 0; TreeNode root = toNode(dataArr[index]); LinkedList<TreeNode> queue = new LinkedList<>(); queue.add(root); while (index < dataArr.length - 2 && !queue.isEmpty()) { TreeNode cur = queue.remove(); // 添加左子節點 TreeNode leftNode = toNode(dataArr[++index]); cur.left = leftNode; // 隊列中的節點用於爲其賦值孩子節點，若該節點自己爲 null， // 沒有孩子節點，便再也不添加到隊列中，下同理 if (leftNode != null) { queue.add(leftNode); } // 添加右子節點 TreeNode rightNode = toNode(dataArr[++index]); cur.right = rightNode; if (rightNode != null) { queue.add(rightNode); } } return root; } private TreeNode toNode(String val) { if (!"null".equals(val)) { return new TreeNode(Integer.parseInt(val)); } else { return null; } }
廣度優先搜索（BFS）
- 首先將根節點放入隊列中。
- 從隊列中取出第一個節點，並檢驗它是否爲目標。
- 若是找到目標，則結束搜索並回傳結果。
- 不然將它全部還沒有檢驗過的直接子節點加入隊列中。
- 若隊列爲空，表示整張圖都檢查過了——亦即圖中沒有欲搜索的目標。結束搜索並回傳「找不到目標」。
- 重複步驟2。
public List<List<Integer>> levelOrder(TreeNode root) { List<List<Integer>> res = new ArrayList<List<Integer>>(); List<TreeNode> quene = new ArrayList<TreeNode>(); if(root == null){ return res; } quene.add(root); while(quene.size()!=0){ int count = quene.size(); List<Integer> list = new ArrayList<Integer>(); while(count>0){ TreeNode temp =quene.remove(0); list.add(temp.val); if(temp.left!=null){ quene.add(temp.left); } if(temp.right!=null){ quene.add(temp.right); } count--; } res.add(list); } return res; }
莫里斯遍歷（Morris）
一般咱們對於二叉樹進行遍歷時，使用遞歸遍歷或是基於棧來遍歷，這兩種方法都擁有最差爲O(n)的空間複雜度(遞歸方法會在遞歸調用上浪費更多的時間)，以及O(n)的時間複雜度。對於時間複雜度來講，因爲須要遍歷每一個元素一次，因此O(n)已經是最優狀況。如此只能對空間進行優化。Morris遍歷如何作到的呢？首先咱們須要分析遞歸和基於棧的遍歷它們爲何有O(n)的空間佔用。如下圖這個簡單的二叉樹遍歷爲例：
例如進行中序遍歷(LDR)，從1開始：
- 1有左孩子2，將1放入棧中，移動到節點2；
- 2有左孩子4，將2放入棧中，移動到節點4；
- 4左孩子爲空，輸出節點4，此時節點4右孩子也爲空，彈棧回到節點2；
- 輸出節點2，節點2有右孩子5，移動到節點5；
- 5左孩子爲空，輸出節點5，此時節點5右孩子也爲空，彈棧回到節點1；
- …
從上面分析能夠得知，傳統遍歷利用空間存儲未實現所有操做的父節點，好比對於1節點，一開始進行L操做，沒有進行D、R操做因此須要存儲起來。爲解決這一問題，Morris算法用到了」線索二叉樹」的概念，利用葉節點的左右空指針指向某種遍歷順序的前驅節點或後繼節點。Morris算法中序遍歷流程：
- 設置節點1爲Current節點；
- Current節點不爲空，且有左孩子，因而找到節點1左子樹中的最右側節點，即節點5，使其右孩子指針指向本身，即link1；
- Current節點移動到左孩子節點2，並刪除父節點的左指針，使其指向爲null，即刪除erase1；
- 節點2不爲空，且有左孩子，因而找到節點2左子樹中最右側節點，即節點4，使其右孩子指針指向本身，即link2；
- Current節點移動到左孩子節點4，並刪除父節點的左指針，使其指向爲null，即刪除erase2；
- 節點4左孩子爲空，輸出節點4，移動到右孩子節點2；
- 節點2無左孩子(指針指向null)，輸出節點2，移動到右孩子節點5；
- 節點5無左孩子，輸出節點5，移動到右孩子節點1；
- 節點2無左孩子(指針指向null)，輸出節點1，移動到右孩子節點3；
- …
代碼實現
void Morris_inorderTraversal(TreeNode root) { TreeNode curr = root; TreeNode pre; while (curr != null) { if (curr.left == null) { // 左孩子爲空 System.out.print(curr.val+" "); curr = curr.right; } else { // 左孩子不爲空 // 找左子樹中的最右節點 pre = curr.left; while (pre.right != null) { pre = pre.right; } // 刪除左孩子，防止循環 pre.right = curr; TreeNode temp = curr; curr = curr.left; temp.left = null; } } }
AVL樹
AVL 樹是一種平衡二叉樹，平衡二叉樹遞歸定義以下：
- 左右子樹的高度差小於等於 1。
- 其每個子樹均爲平衡二叉樹。
爲了保證二叉樹的平衡， AVL 樹引入了所謂監督機制，就是在樹的某一部分的不平衡度超過一個閾值後觸發相應的平衡操做。保證樹的平衡度在能夠接受的範圍內。既然引入了監督機制，咱們必然須要一個監督指標，以此來判斷是否須要進行平衡操做。這個監督指標被稱爲「平衡因子（Balance Factor）」。定義以下：
- 平衡因子： 某個結點的左子樹的高度減去右子樹的高度獲得的差值。
基於平衡因子，咱們就能夠這樣定義 AVL 樹。
- AVL 樹： 全部結點的平衡因子的絕對值都不超過 1 的二叉樹。
爲了計算平衡因子，咱們天然須要在節點中引入高度這一屬性。在這裏，咱們把節點的高度定義爲其左右子樹的高度的最大值。所以，引入了高度屬性的 AVL 樹的節點定義以下：
public class TreeNode { int val; int height; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } }
這裏的節點和上面的不一樣的地方在於，咱們多加了一個高度，用來記錄每一個節點的高度，如何獲得每一個節點的高度很簡單，前面講的算法中任何一種思路均可以實現，我這裏就不贅述了，不過這裏要多說一點的是，與之對應地，咱們在進行以下操做時須要更新受影響的全部節點的高度：
- 在插入結點時， 沿插入的路徑更新結點的高度值
- 在刪除結點時（delete），沿刪除的路徑更新結點的高度值
咱們從新定義了節點以後，有了高度屬性，計算平衡因子的操做就得以很簡單的實現，也就是某個節點的平衡因子=左節點高度-右節點高度。
當平衡因子的絕對值大於 1 時，就會觸發樹的修正，或者說是再平衡操做。
樹的平衡化操做
二叉樹的平衡化有兩大基礎操做： 左旋和右旋。左旋，便是逆時針旋轉；右旋，便是順時針旋轉。這種旋轉在整個平衡化過程當中可能進行一次或屢次，這兩種操做都是從失去平衡的最小子樹根結點開始的(即離插入結點最近且平衡因子超過1的祖結點)。其中，右旋操做示意圖以下
所謂右旋操做，就是把上圖中的 B 節點和 C 節點進行所謂「父子交換」。在僅有這三個節點時候，是十分簡單的。可是當 B 節點處存在右孩子時，事情就變得有點複雜了。咱們一般的操做是：拋棄右孩子，將之和旋轉後的節點 C 相連，成爲節點 C 的左孩子。這樣，對應的代碼以下。
TreeNode treeRotateRight(TreeNode root) { TreeNode left = root.left; root.left = left.right; // 將將要被拋棄的節點鏈接爲旋轉後的 root 的左孩子 left.right = root; // 調換父子關係 left.height = Math.max(treeHeight(left.left), treeHeight(left.right))+1; right.height = Math.max(treeHeight(right.left), treeHeight(right.right))+1; return left; }
而左旋操做示意圖以下
左旋操做和右旋操做十分相似，惟一不一樣的就是須要將左右互換下。咱們能夠認爲這兩種操做是對稱的。代碼以下：
TreeNode treeRotateLeft(TreeNode root) { TreeNode right = root.ight; root.right = right.left; right.left = root; left.height = Math.max(treeHeight(left.left), treeHeight(left.right))+1; right->height = Math.max(treeHeight(right.left), treeHeight(right.right))+1; return right; }
須要平衡的四種狀況
- LL 型
所謂 LL 型就是上圖左邊那種狀況，即由於在根節點的左孩子的左子樹添加了新節點，致使根節點的平衡因子變爲 +2，二叉樹失去平衡。對於這種狀況，對節點 n 右旋一次便可。
- RR 型
RR 型的狀況和 LL 型徹底對稱。只須要對節點 n 進行一次左旋便可修正。
- LR 型
LR 就是將新的節點插入到了 n 的左孩子的右子樹上致使的不平衡的狀況。這時咱們須要的是先對 i 進行一次左旋再對 n 進行一次右旋。
- RL 型
RL 就是將新的節點插入到了 n 的右孩子的左子樹上致使的不平衡的狀況。這時咱們須要的是先對 i 進行一次右旋再對 n 進行一次左旋。
這四種狀況的判斷很簡單。咱們根據破壞樹的平衡性（平衡因子的絕對值大於 1）的節點以及其子節點的平衡因子來判斷平衡化類型。
平衡化操做的實現以下：
int treeGetBalanceFactor(TreeNode root) { if(root == NULL) return 0; else return x.left.height - x.right.height; } TreeNode treeRebalance(TreeNode root) { int factor = treeGetBalanceFactor(root); if(factor > 1 && treeGetBalanceFactor(root.left) > 0) // LL return treeRotateRight(root); else if(factor > 1 && treeGetBalanceFactor(root.left) <= 0) { //LR root.left = treeRotateLeft(root.left); return treeRotateRight(temp); } else if(factor < -1 && treeGetBalanceFactor(root.right) <= 0) // RR return treeRotateLeft(root); else if((factor < -1 && treeGetBalanceFactor(root.right) > 0) { // RL root.right = treeRotateRight(root.right); return treeRotateLeft(root); } else { // Nothing happened. return root; } }
這裏推薦一個AVL樹動態化的網站，能夠經過動態可視化的方式理解AVL