2. 程式人生 > >轉載 輕松搞定面試中的二叉樹題目

轉載 輕松搞定面試中的二叉樹題目

阿新 • • 發佈：2018-06-16
相同 tree otp article ref position too -c rri

版權所有，轉載請註明出處，謝謝！
http://blog.csdn.net/walkinginthewind/article/details/7518888

樹是一種比較重要的數據結構，尤其是二叉樹。二叉樹是一種特殊的樹，在二叉樹中每個節點最多有兩個子節點，一般稱為左子節點和右子節點（或左孩子和右孩子），並且二叉樹的子樹有左右之分，其次序不能任意顛倒。二叉樹是遞歸定義的，因此，與二叉樹有關的題目基本都可以用遞歸思想解決，當然有些題目非遞歸解法也應該掌握，如非遞歸遍歷節點等等。本文努力對二叉樹相關題目做一個較全的整理總結，希望對找工作的同學有所幫助。

二叉樹節點定義如下：
struct BinaryTreeNode
{
int m_nValue;
BinaryTreeNode* m_pLeft;
BinaryTreeNode* m_pRight;
};

相關鏈接：
輕松搞定面試中的鏈表題目

題目列表：

1. 求二叉樹中的節點個數
2. 求二叉樹的深度
3. 前序遍歷，中序遍歷，後序遍歷
4.分層遍歷二叉樹（按層次從上往下，從左往右）
5. 將二叉查找樹變為有序的雙向鏈表
6. 求二叉樹第K層的節點個數
7. 求二叉樹中葉子節點的個數
8. 判斷兩棵二叉樹是否結構相同
9. 判斷二叉樹是不是平衡二叉樹
10. 求二叉樹的鏡像
11. 求二叉樹中兩個節點的最低公共祖先節點
12. 求二叉樹中節點的最大距離
13. 由前序遍歷序列和中序遍歷序列重建二叉樹
14.判斷二叉樹是不是完全二叉樹

詳細解答

1. 求二叉樹中的節點個數
遞歸解法：
（1）如果二叉樹為空，節點個數為0
（2）如果二叉樹不為空，二叉樹節點個數 = 左子樹節點個數 + 右子樹節點個數 + 1
參考代碼如下：

[cpp] view plain copy
  1. int GetNodeNum(BinaryTreeNode * pRoot)
  2. {
  3. if(pRoot == NULL) // 遞歸出口
  4. return 0;
  5. return GetNodeNum(pRoot->m_pLeft) + GetNodeNum(pRoot->m_pRight) + 1;
  6. }

2. 求二叉樹的深度
遞歸解法：
（1）如果二叉樹為空，二叉樹的深度為0
（2）如果二叉樹不為空，二叉樹的深度 = max(左子樹深度， 右子樹深度) + 1
參考代碼如下：

[cpp]
view plain copy
  1. int GetDepth(BinaryTreeNode * pRoot)
  2. {
  3. if(pRoot == NULL) // 遞歸出口
  4. return 0;
  5. int depthLeft = GetDepth(pRoot->m_pLeft);
  6. int depthRight = GetDepth(pRoot->m_pRight);
  7. return depthLeft > depthRight ? (depthLeft + 1) : (depthRight + 1);
  8. }

3. 前序遍歷，中序遍歷，後序遍歷
前序遍歷遞歸解法：
（1）如果二叉樹為空，空操作
（2）如果二叉樹不為空，訪問根節點，前序遍歷左子樹，前序遍歷右子樹
參考代碼如下：

[cpp] view plain copy
  1. void PreOrderTraverse(BinaryTreeNode * pRoot)
  2. {
  3. if(pRoot == NULL)
  4. return;
  5. Visit(pRoot); // 訪問根節點
  6. PreOrderTraverse(pRoot->m_pLeft); // 前序遍歷左子樹
  7. PreOrderTraverse(pRoot->m_pRight); // 前序遍歷右子樹
  8. }

中序遍歷遞歸解法
（1）如果二叉樹為空，空操作。
（2）如果二叉樹不為空，中序遍歷左子樹，訪問根節點，中序遍歷右子樹
參考代碼如下：

[cpp] view plain copy
  1. void InOrderTraverse(BinaryTreeNode * pRoot)
  2. {
  3. if(pRoot == NULL)
  4. return;
  5. InOrderTraverse(pRoot->m_pLeft); // 中序遍歷左子樹
  6. Visit(pRoot); // 訪問根節點
  7. InOrderTraverse(pRoot->m_pRight); // 中序遍歷右子樹
  8. }

後序遍歷遞歸解法
（1）如果二叉樹為空，空操作
（2）如果二叉樹不為空，後序遍歷左子樹，後序遍歷右子樹，訪問根節點
參考代碼如下：

[cpp] view plain copy
  1. void PostOrderTraverse(BinaryTreeNode * pRoot)
  2. {
  3. if(pRoot == NULL)
  4. return;
  5. PostOrderTraverse(pRoot->m_pLeft); // 後序遍歷左子樹
  6. PostOrderTraverse(pRoot->m_pRight); // 後序遍歷右子樹
  7. Visit(pRoot); // 訪問根節點
  8. }

4.分層遍歷二叉樹（按層次從上往下，從左往右）

相當於廣度優先搜索，使用隊列實現。隊列初始化，將根節點壓入隊列。當隊列不為空，進行如下操作：彈出一個節點，訪問，若左子節點或右子節點不為空，將其壓入隊列。

[cpp] view plain copy
  1. void LevelTraverse(BinaryTreeNode * pRoot)
  2. {
  3. if(pRoot == NULL)
  4. return;
  5. queue<BinaryTreeNode *> q;
  6. q.push(pRoot);
  7. while(!q.empty())
  8. {
  9. BinaryTreeNode * pNode = q.front();
  10. q.pop();
  11. Visit(pNode); // 訪問節點
  12. if(pNode->m_pLeft != NULL)
  13. q.push(pNode->m_pLeft);
  14. if(pNode->m_pRight != NULL)
  15. q.push(pNode->m_pRight);
  16. }
  17. return;
  18. }

5. 將二叉查找樹變為有序的雙向鏈表

要求不能創建新節點，只調整指針。
遞歸解法：
（1）如果二叉樹查找樹為空，不需要轉換，對應雙向鏈表的第一個節點是NULL，最後一個節點是NULL
（2）如果二叉查找樹不為空：

如果左子樹為空，對應雙向有序鏈表的第一個節點是根節點，左邊不需要其他操作；
如果左子樹不為空，轉換左子樹，二叉查找樹對應雙向有序鏈表的第一個節點就是左子樹轉換後雙向有序鏈表的第一個節點，同時將根節點和左子樹轉換後的雙向有序鏈 表的最後一個節點連接；
如果右子樹為空，對應雙向有序鏈表的最後一個節點是根節點，右邊不需要其他操作；
如果右子樹不為空，對應雙向有序鏈表的最後一個節點就是右子樹轉換後雙向有序鏈表的最後一個節點，同時將根節點和右子樹轉換後的雙向有序鏈表的第一個節點連 接。

參考代碼如下：

[cpp] view plain copy
  1. /******************************************************************************
  2. 參數：
  3. pRoot: 二叉查找樹根節點指針
  4. pFirstNode: 轉換後雙向有序鏈表的第一個節點指針
  5. pLastNode: 轉換後雙向有序鏈表的最後一個節點指針
  6. ******************************************************************************/
  7. void Convert(BinaryTreeNode * pRoot,
  8. BinaryTreeNode * & pFirstNode, BinaryTreeNode * & pLastNode)
  9. {
  10. BinaryTreeNode *pFirstLeft, *pLastLeft, * pFirstRight, *pLastRight;
  11. if(pRoot == NULL)
  12. {
  13. pFirstNode = NULL;
  14. pLastNode = NULL;
  15. return;
  16. }
  18. if(pRoot->m_pLeft == NULL)
  19. {
  20. // 如果左子樹為空，對應雙向有序鏈表的第一個節點是根節點
  21. pFirstNode = pRoot;
  22. }
  23. else
  24. {
  25. Convert(pRoot->m_pLeft, pFirstLeft, pLastLeft);
  26. // 二叉查找樹對應雙向有序鏈表的第一個節點就是左子樹轉換後雙向有序鏈表的第一個節點
  27. pFirstNode = pFirstLeft;
  28. // 將根節點和左子樹轉換後的雙向有序鏈表的最後一個節點連接
  29. pRoot->m_pLeft = pLastLeft;
  30. pLastLeft->m_pRight = pRoot;
  31. }
  33. if(pRoot->m_pRight == NULL)
  34. {
  35. // 對應雙向有序鏈表的最後一個節點是根節點
  36. pLastNode = pRoot;
  37. }
  38. else
  39. {
  40. Convert(pRoot->m_pRight, pFirstRight, pLastRight);
  41. // 對應雙向有序鏈表的最後一個節點就是右子樹轉換後雙向有序鏈表的最後一個節點
  42. pLastNode = pLastRight;
  43. // 將根節點和右子樹轉換後的雙向有序鏈表的第一個節點連接
  44. pRoot->m_pRight = pFirstRight;
  45. pFirstRight->m_pLeft = pRoot;
  46. }
  48. return;
  49. }

6. 求二叉樹第K層的節點個數
遞歸解法：
（1）如果二叉樹為空或者k<1返回0
（2）如果二叉樹不為空並且k==1，返回1
（3）如果二叉樹不為空且k>1，返回左子樹中k-1層的節點個數與右子樹k-1層節點個數之和
參考代碼如下：

[cpp] view plain copy
  1. int GetNodeNumKthLevel(BinaryTreeNode * pRoot, int k)
  2. {
  3. if(pRoot == NULL || k < 1)
  4. return 0;
  5. if(k == 1)
  6. return 1;
  7. int numLeft = GetNodeNumKthLevel(pRoot->m_pLeft, k-1); // 左子樹中k-1層的節點個數
  8. int numRight = GetNodeNumKthLevel(pRoot->m_pRight, k-1); // 右子樹中k-1層的節點個數
  9. return (numLeft + numRight);
  10. }

7. 求二叉樹中葉子節點的個數
遞歸解法：
（1）如果二叉樹為空，返回0
（2）如果二叉樹不為空且左右子樹為空，返回1
（3）如果二叉樹不為空，且左右子樹不同時為空，返回左子樹中葉子節點個數加上右子樹中葉子節點個數
參考代碼如下：

[cpp] view plain copy
  1. int GetLeafNodeNum(BinaryTreeNode * pRoot)
  2. {
  3. if(pRoot == NULL)
  4. return 0;
  5. if(pRoot->m_pLeft == NULL && pRoot->m_pRight == NULL)
  6. return 1;
  7. int numLeft = GetLeafNodeNum(pRoot->m_pLeft); // 左子樹中葉節點的個數
  8. int numRight = GetLeafNodeNum(pRoot->m_pRight); // 右子樹中葉節點的個數
  9. return (numLeft + numRight);
  10. }

8. 判斷兩棵二叉樹是否結構相同
不考慮數據內容。結構相同意味著對應的左子樹和對應的右子樹都結構相同。
遞歸解法：
（1）如果兩棵二叉樹都為空，返回真
（2）如果兩棵二叉樹一棵為空，另一棵不為空，返回假
（3）如果兩棵二叉樹都不為空，如果對應的左子樹和右子樹都同構返回真，其他返回假
參考代碼如下：

[cpp] view plain copy
  1. bool StructureCmp(BinaryTreeNode * pRoot1, BinaryTreeNode * pRoot2)
  2. {
  3. if(pRoot1 == NULL && pRoot2 == NULL) // 都為空，返回真
  4. return true;
  5. else if(pRoot1 == NULL || pRoot2 == NULL) // 有一個為空，一個不為空，返回假
  6. return false;
  7. bool resultLeft = StructureCmp(pRoot1->m_pLeft, pRoot2->m_pLeft); // 比較對應左子樹
  8. bool resultRight = StructureCmp(pRoot1->m_pRight, pRoot2->m_pRight); // 比較對應右子樹
  9. return (resultLeft && resultRight);
  10. }

9. 判斷二叉樹是不是平衡二叉樹
遞歸解法：
（1）如果二叉樹為空，返回真
（2）如果二叉樹不為空，如果左子樹和右子樹都是AVL樹並且左子樹和右子樹高度相差不大於1，返回真，其他返回假
參考代碼：

[cpp] view plain copy
  1. bool IsAVL(BinaryTreeNode * pRoot, int & height)
  2. {
  3. if(pRoot == NULL) // 空樹，返回真
  4. {
  5. height = 0;
  6. return true;
  7. }
  8. int heightLeft;
  9. bool resultLeft = IsAVL(pRoot->m_pLeft, heightLeft);
  10. int heightRight;
  11. bool resultRight = IsAVL(pRoot->m_pRight, heightRight);
  12. if(resultLeft && resultRight && abs(heightLeft - heightRight) <= 1) // 左子樹和右子樹都是AVL，並且高度相差不大於1，返回真
  13. {
  14. height = max(heightLeft, heightRight) + 1;
  15. return true;
  16. }
  17. else
  18. {
  19. height = max(heightLeft, heightRight) + 1;
  20. return false;
  21. }
  22. }

10. 求二叉樹的鏡像
遞歸解法：
（1）如果二叉樹為空，返回空
（2）如果二叉樹不為空，求左子樹和右子樹的鏡像，然後交換左子樹和右子樹
參考代碼如下：

[cpp] view plain copy
  1. BinaryTreeNode * Mirror(BinaryTreeNode * pRoot)
  2. {
  3. if(pRoot == NULL) // 返回NULL
  4. return NULL;
  5. BinaryTreeNode * pLeft = Mirror(pRoot->m_pLeft); // 求左子樹鏡像
  6. BinaryTreeNode * pRight = Mirror(pRoot->m_pRight); // 求右子樹鏡像
  7. // 交換左子樹和右子樹
  8. pRoot->m_pLeft = pRight;
  9. pRoot->m_pRight = pLeft;
  10. return pRoot;
  11. }

11. 求二叉樹中兩個節點的最低公共祖先節點
遞歸解法：
（1）如果兩個節點分別在根節點的左子樹和右子樹，則返回根節點
（2）如果兩個節點都在左子樹，則遞歸處理左子樹；如果兩個節點都在右子樹，則遞歸處理右子樹
參考代碼如下：

[cpp] view plain copy
  1. bool FindNode(BinaryTreeNode * pRoot, BinaryTreeNode * pNode)
  2. {
  3. if(pRoot == NULL || pNode == NULL)
  4. return false;
  6. if(pRoot == pNode)
  7. return true;
  9. bool found = FindNode(pRoot->m_pLeft, pNode);
  10. if(!found)
  11. found = FindNode(pRoot->m_pRight, pNode);
  13. return found;
  14. }
  16. BinaryTreeNode * GetLastCommonParent(BinaryTreeNode * pRoot,
  17. BinaryTreeNode * pNode1,
  18. BinaryTreeNode * pNode2)
  19. {
  20. if(FindNode(pRoot->m_pLeft, pNode1))
  21. {
  22. if(FindNode(pRoot->m_pRight, pNode2))
  23. return pRoot;
  24. else
  25. return GetLastCommonParent(pRoot->m_pLeft, pNode1, pNode2);
  26. }
  27. else
  28. {
  29. if(FindNode(pRoot->m_pLeft, pNode2))
  30. return pRoot;
  31. else
  32. return GetLastCommonParent(pRoot->m_pRight, pNode1, pNode2);
  33. }
  34. }

遞歸解法效率很低，有很多重復的遍歷，下面看一下非遞歸解法。
非遞歸解法：
先求從根節點到兩個節點的路徑，然後再比較對應路徑的節點就行，最後一個相同的節點也就是他們在二叉樹中的最低公共祖先節點
參考代碼如下：

[cpp] view plain copy
  1. bool GetNodePath(BinaryTreeNode * pRoot, BinaryTreeNode * pNode,
  2. list<BinaryTreeNode *> & path)
  3. {
  4. if(pRoot == pNode)
  5. {
  6. path.push_back(pRoot);
  7. return true;
  8. }
  9. if(pRoot == NULL)
  10. return false;
  11. path.push_back(pRoot);
  12. bool found = false;
  13. found = GetNodePath(pRoot->m_pLeft, pNode, path);
  14. if(!found)
  15. found = GetNodePath(pRoot->m_pRight, pNode, path);
  16. if(!found)
  17. path.pop_back();
  18. return found;
  19. }
  20. BinaryTreeNode * GetLastCommonParent(BinaryTreeNode * pRoot, BinaryTreeNode * pNode1, BinaryTreeNode * pNode2)
  21. {
  22. if(pRoot == NULL || pNode1 == NULL || pNode2 == NULL)
  23. return NULL;
  24. list<BinaryTreeNode*> path1;
  25. bool bResult1 = GetNodePath(pRoot, pNode1, path1);
  26. list<BinaryTreeNode*> path2;
  27. bool bResult2 = GetNodePath(pRoot, pNode2, path2);
  28. if(!bResult1 || !bResult2)
  29. return NULL;
  30. BinaryTreeNode * pLast = NULL;
  31. list<BinaryTreeNode*>::const_iterator iter1 = path1.begin();
  32. list<BinaryTreeNode*>::const_iterator iter2 = path2.begin();
  33. while(iter1 != path1.end() && iter2 != path2.end())
  34. {
  35. if(*iter1 == *iter2)
  36. pLast = *iter1;
  37. else
  38. break;
  39. iter1++;
  40. iter2++;
  41. }
  42. return pLast;
  43. }


在上述算法的基礎上稍加變化即可求二叉樹中任意兩個節點的距離了。
12. 求二叉樹中節點的最大距離
即二叉樹中相距最遠的兩個節點之間的距離。
遞歸解法：
（1）如果二叉樹為空，返回0，同時記錄左子樹和右子樹的深度，都為0
（2）如果二叉樹不為空，最大距離要麽是左子樹中的最大距離，要麽是右子樹中的最大距離，要麽是左子樹節點中到根節點的最大距離+右子樹節點中到根節點的最大距離，同時記錄左子樹和右子樹節點中到根節點的最大距離。

參考代碼如下：

[cpp] view plain copy
  1. int GetMaxDistance(BinaryTreeNode * pRoot, int & maxLeft, int & maxRight)
  2. {
  3. // maxLeft, 左子樹中的節點距離根節點的最遠距離
  4. // maxRight, 右子樹中的節點距離根節點的最遠距離
  5. if(pRoot == NULL)
  6. {
  7. maxLeft = 0;
  8. maxRight = 0;
  9. return 0;
  10. }
  11. int maxLL, maxLR, maxRL, maxRR;
  12. int maxDistLeft, maxDistRight;
  13. if(pRoot->m_pLeft != NULL)
  14. {
  15. maxDistLeft = GetMaxDistance(pRoot->m_pLeft, maxLL, maxLR);
  16. maxLeft = max(maxLL, maxLR) + 1;
  17. }
  18. else
  19. {
  20. maxDistLeft = 0;
  21. maxLeft = 0;
  22. }
  23. if(pRoot->m_pRight != NULL)
  24. {
  25. maxDistRight = GetMaxDistance(pRoot->m_pRight, maxRL, maxRR);
  26. maxRight = max(maxRL, maxRR) + 1;
  27. }
  28. else
  29. {
  30. maxDistRight = 0;
  31. maxRight = 0;
  32. }
  33. return max(max(maxDistLeft, maxDistRight), maxLeft+maxRight);
  34. }

13. 由前序遍歷序列和中序遍歷序列重建二叉樹
二叉樹前序遍歷序列中，第一個元素總是樹的根節點的值。中序遍歷序列中，左子樹的節點的值位於根節點的值的左邊，右子樹的節點的值位
於根節點的值的右邊。
遞歸解法：
（1）如果前序遍歷為空或中序遍歷為空或節點個數小於等於0，返回NULL。
（2）創建根節點。前序遍歷的第一個數據就是根節點的數據，在中序遍歷中找到根節點的位置，可分別得知左子樹和右子樹的前序和中序遍
歷序列，重建左右子樹。

[cpp] view plain copy
  1. BinaryTreeNode * RebuildBinaryTree(int* pPreOrder, int* pInOrder, int nodeNum)
  2. {
  3. if(pPreOrder == NULL || pInOrder == NULL || nodeNum <= 0)
  4. return NULL;
  5. BinaryTreeNode * pRoot = new BinaryTreeNode;
  6. // 前序遍歷的第一個數據就是根節點數據
  7. pRoot->m_nValue = pPreOrder[0];
  8. pRoot->m_pLeft = NULL;
  9. pRoot->m_pRight = NULL;
  10. // 查找根節點在中序遍歷中的位置，中序遍歷中，根節點左邊為左子樹，右邊為右子樹
  11. int rootPositionInOrder = -1;
  12. for(int i = 0; i < nodeNum; i++)
  13. if(pInOrder[i] == pRoot->m_nValue)
  14. {
  15. rootPositionInOrder = i;
  16. break;
  17. }
  18. if(rootPositionInOrder == -1)
  19. {
  20. throw std::exception("Invalid input.");
  21. }
  22. // 重建左子樹
  23. int nodeNumLeft = rootPositionInOrder;
  24. int * pPreOrderLeft = pPreOrder + 1;
  25. int * pInOrderLeft = pInOrder;
  26. pRoot->m_pLeft = RebuildBinaryTree(pPreOrderLeft, pInOrderLeft, nodeNumLeft);
  27. // 重建右子樹
  28. int nodeNumRight = nodeNum - nodeNumLeft - 1;
  29. int * pPreOrderRight = pPreOrder + 1 + nodeNumLeft;
  30. int * pInOrderRight = pInOrder + nodeNumLeft + 1;
  31. pRoot->m_pRight = RebuildBinaryTree(pPreOrderRight, pInOrderRight, nodeNumRight);
  32. return pRoot;
  33. }

同樣，有中序遍歷序列和後序遍歷序列，類似的方法可重建二叉樹，但前序遍歷序列和後序遍歷序列不同恢復一棵二叉樹，證明略。
14.判斷二叉樹是不是完全二叉樹
若設二叉樹的深度為h，除第 h 層外，其它各層 (1～h-1) 的結點數都達到最大個數，第 h 層所有的結點都連續集中在最左邊，這就是完全
二叉樹。
有如下算法，按層次（從上到下，從左到右）遍歷二叉樹，當遇到一個節點的左子樹為空時，則該節點右子樹必須為空，且後面遍歷的節點左
右子樹都必須為空，否則不是完全二叉樹。

[cpp] view plain copy
    1. bool IsCompleteBinaryTree(BinaryTreeNode * pRoot)
    2. {
    3. if(pRoot == NULL)
    4. return false;
    5. queue<BinaryTreeNode *> q;
    6. q.push(pRoot);
    7. bool mustHaveNoChild = false;
    8. bool result = true;
    9. while(!q.empty())
    10. {
    11. BinaryTreeNode * pNode = q.front();
    12. q.pop();
    13. if(mustHaveNoChild) // 已經出現了有空子樹的節點了，後面出現的必須為葉節點（左右子樹都為空）
    14. {
    15. if(pNode->m_pLeft != NULL || pNode->m_pRight != NULL)
    16. {
    17. result = false;
    18. break;
    19. }
    20. }
    21. else
    22. {
    23. if(pNode->m_pLeft != NULL && pNode->m_pRight != NULL)
    24. {
    25. q.push(pNode->m_pLeft);
    26. q.push(pNode->m_pRight);
    27. }
    28. else if(pNode->m_pLeft != NULL && pNode->m_pRight == NULL)
    29. {
    30. mustHaveNoChild = true;
    31. q.push(pNode->m_pLeft);
    32. }
    33. else if(pNode->m_pLeft == NULL && pNode->m_pRight != NULL)
    34. {
    35. result = false;
    36. break;
    37. }
    38. else
    39. {
    40. mustHaveNoChild = true;
    41. }
    42. }
    43. }
    44. return result;
    45. }

轉載 輕松搞定面試中的二叉樹題目

相關推薦

轉載 輕松搞定面試中的二叉樹題目

相同 tree otp article ref position too -c rri 版權所有，轉載請註明出處，謝謝！http://blog.csdn.net/walkinginthewind/article/details/7518888 樹是一種比較重要的數據結構，尤

搞定面試中的連結串列題目(Java實現)

本文轉載自：https://www.jianshu.com/p/a64d1ef95980這是一篇關於連結串列的文章，總結了連結串列資料結構和演算法相關的一些題目。先上鍊表的資料結構：class ListNode { ListNode next; int val; ListNode(in

面試大總結之一：Java搞定面試中的連結串列題目

連結串列是面試中常出現的一類題目，本文用Java實現了面試中常見的連結串列相關題目。本文主要參考整合重寫了《輕鬆搞定面試中的連結串列題目》和 《演算法大全（1）單鏈表》兩篇大作。兩篇大神的實現分別是C和C#，因為我更喜歡用Java面試，所以用Java重寫了所有實現，並附上自己

一篇文章搞定面試中的連結串列題目(java實現)

連結串列的資料結構 class ListNode { ListNode next; int val; ListNode(int x){ val = x; next = null;

搞定面試中的二叉樹題目(Java實現)

本文轉載自：https://www.jianshu.com/p/0190985635eb這是一篇關於二叉樹的文章，總結了二叉樹資料結構和演算法的相關題目。先上二叉樹的資料結構：class TreeNode{ int val; //左孩子 TreeNode left; //右孩子

面試大總結之二：Java搞定面試中的二叉樹題目

這是本系列的第二篇，與前一篇 面試大總結之一：Java搞定面試中的連結串列題目 相比，二叉樹的題目可以變化的就更多了。本文還是參考整合重寫了《輕鬆搞定面試中的二叉樹題目》和《演算法大全（3） 二叉樹》兩篇大作。本文一個小亮點就是幾乎每一道題都用了遞迴和迭代兩種方法寫過一遍

輕鬆搞定面試中的二叉樹題目

樹是一種比較重要的資料結構，尤其是二叉樹。二叉樹是一種特殊的樹，在二叉樹中每個節點最多有兩個子節點，一般稱為左子節點和右子節點（或左孩子和右孩子），並且二叉樹的子樹有左右之分，其次序不能任意顛倒。二叉樹是遞迴定義的，因此，與二叉樹有關的題目基本都可以用遞迴思想解決，當

一篇文章搞定面試中的二叉樹題目(java實現)

結構 cer dea mat lastcomm ++ mir let balanced 最近總結了一些數據結構和算法相關的題目，這是第一篇文章，關於二叉樹的。 先上二叉樹的數據結構： class TreeNode{ int val; //左孩子 Tr

寫文章賺錢34期：用100個問答輕松搞定1個領域！

輕松賺錢 很多人聽說做自媒體很賺錢，在網絡上只要一部手機、一臺電腦就可以輕松賺錢，紛紛跑到網絡上去嘗試做。 他們選擇了一個領域就開始寫文章，但是寫了一段時間後，卻發現寫得文章沒人看，吸引不到精準粉絲，根本沒有粉絲可以成交，非常痛苦，就覺得做自媒體根本不能賺錢，是騙人的。 俊哥說：只有先搞定一個領域，把你變成專

輕松搞定對容器實例日誌設置定期清理和回卷

實現 drive 所有 存在 磁盤 hour 日誌文件 tar 文件 說明：該文轉載自騰訊雲技術社區騰雲閣，已征求作者本人同意。 引言 Kubernetes對於容器實例的日誌收集，並沒有提供原生的解決方案。但提供使用kubectl logs命令查看容器實例運行時的日誌。ku

輕松搞定RabbitMQ（五）——路由選擇

byte[] view 轉發器 ews 磁盤空間 表示 info 直接 net 轉自 http://blog.csdn.net/xiaoxian8023/article/details/48733249 翻譯地址：http://www.rabbitmq.com/tutori

從零開始，輕松搞定SpringCloud微服務系列

markdown class net 配置中心 html div .html href .com 本系列博文目錄 【微服務】之一：從零開始，輕松搞定SpringCloud微服務系列–開山篇（spring boot 小demo） 【微服務】之二：從零開始，輕松搞定Spring

Elasticsearch JAVA api輕松搞定groupBy聚合

ont text 遇到 初始化 演示 是我 getprop square 遍歷 本文給出如何使用Elasticsearch的Java API做類似SQL的group by聚合。 為了簡單起見，只給出一級groupby即group by field1(而不涉及到多級，例如

【微服務】之七：輕松搞定SpringCloud微服務-API權限控制

cat https lte urn 錯誤碼 netflix req ons 體系 權限控制，是一個系統當中必須的重要功能。張三只能訪問輸入張三的特定功能，李四不能訪問屬於趙六的特定菜單。這就要求對整個體系做一個完善的權限控制體系。該體系應該具備針區分用戶、權限、角色等各種

【微服務】之六：輕松搞定SpringCloud微服務-API網關zuul

公司 create lan ice 子項目 專題 系統 如果 rose 通過前面幾篇文章的介紹，我們可以輕松搭建起來微服務體系中比較重要的幾個基礎構建服務。那麽，在本篇博文中，我們重點講解一下，如何將所有微服務的API同意對外暴露，這個就設計API網關的概念。 本系列教

網頁被限制無法復制？除了開發者工具還可以用瀏覽器插件輕松搞定

代碼 怎樣 ima 方式 程序 blank allow ble 開發 有些網站總是會用些JavaScript 或特殊的技巧將網路瀏覽器的文字選取、文字復制或滑鼠右鍵…等功能給鎖起來，以為這樣真的能禁止其他人復制、盜用文章。小編的每天的工作就是尋找各種素材遇到這樣的網站自然是

這群超酷的開發者，是如何輕松搞定軟件開發？

webide 不容易 XML nba MF 模型設計 分享 min-width eating 前些日子我看到兩則有關線上Office的新聞，一是空客的十三萬員工將全部遷移到谷歌的在線文檔套件G Suite；二是騰訊發布在線文檔產品，可以與微軟Excel和Wor

報表工具輕松搞定票據單據套打

項目開發 分享圖片 畫圖軟件 什麽 class 畫圖 根據 接下來 需要 實際項目開發中，很多情況會涉及到票據的打印。即在一張印刷好的空白票據上，準確無誤地打印上票據的內容。用傳統的報表工具，我們通常會用尺子量每一個數據區域的位置，然後在屏幕上根據尺子量出的尺寸設計每一個格

報表工具輕松搞定卡片式報表

分享圖片 size 遇到的問題 神器 con font 報表設計器 com 能夠 在我們日常生活或工作中，經常會看到這樣一個個小卡片，上面記載著某件商品或者某個人的基本信息。如同名片一般，看起來簡單明了。而在數據庫中，這些信息實際上是密密麻麻的一條條記錄，直接查看非常容易看

10點小tip幫你輕松搞定頭疼的服務器日常維護！

硬件故障 機器 掃描 時間表 一點 創建 磁盤容量 挑戰 報表 服務器真不簡單，每天“哼唱”24個小時，每周七天，好像有無限能量，但其實它也不過是一臺機器，是機器都是需要維護的，不維護的話怎麽能夠和它“長相廝守”呢？ 有些人可能一聽到要維護服務器就感到頭疼，因為不懂就會束