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

原創 csdn_chai 2020-02-22 21:00

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

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

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

二叉樹的大部分題目都應用了遞歸，時刻往遞歸結構去思考。

二叉樹的原子操作:

1. 

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

題目列表：

0. 求從根到指定結點的路徑
1. 求二叉樹中的節點個數

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

詳細解答

0. 

由於是二叉樹（沒說是BST）。我們把路徑保存在一個list中

bool GetNodePath(BinaryTreeNode * pRoot, BinaryTreeNode * pNode,
    list<BinaryTreeNode *> & path)
{
    if (pRoot == pNode)
    {
        path.push_back(pRoot);
        return true;
    }
    if (pRoot == NULL)
        return false;
    path.push_back(pRoot);
    bool found = false;
    found = GetNodePath(pRoot->m_pLeft, pNode, path);
    if (!found)
        found = GetNodePath(pRoot->m_pRight, pNode, path);
    if (!found)
        path.pop_back();
    return found;
}

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.     }  
  17.   
  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.     }  
  32.   
  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.     }  
  47.   
  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;  
  5.   
  6.     if(pRoot == pNode)  
  7.         return true;  
  8.   
  9.     bool found = FindNode(pRoot->m_pLeft, pNode);  
  10.     if(!found)  
  11.         found = FindNode(pRoot->m_pRight, pNode);  
  12.   
  13.     return found;  
  14. }  
  15.   
  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. }  
站內首發文章
csdn_chai
發佈了84 篇原創文章 · 獲贊 145 · 訪問量 9萬+
私信 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

劍指Offer-在排序數組中查找數字 I

46.在排序數組中查找數字 I 統計一個數字在排序數組中出現的次數。 示例 1: 輸入: nums = [5,7,7,8,8,10], target = 8 輸出: 2 示例 2: 輸入: nums = [5,7,7,8,8,

Ga_Lip 2020-07-08 12:20:23

LeetCode-452. 用最少數量的箭引爆氣球

LeetCode-452. 用最少數量的箭引爆氣球 在二維空間中有許多球形的氣球。對於每個氣球，提供的輸入是水平方向上，氣球直徑的開始和結束座標。由於它是水平的，所以y座標並不重要，因此只要知道開始和結束的x座標就足夠了。開始座標

Ga_Lip 2020-07-08 12:20:23

LeetCode-680. 驗證迴文字符串

LeetCode-680. 驗證迴文字符串 給定一個非空字符串 s，最多刪除一個字符。判斷是否能成爲迴文字符串。 示例 1: 輸入: "aba" 輸出: True 示例 2: 輸入: "abca" 輸出: True 解釋: 你可

Ga_Lip 2020-07-08 12:20:23

基本數據結構——線性結構（列表/無序表）

1.什麼是列表（List）? 一個數據項按照相對位置存放的數據集。特別的，被稱爲“無序表(unordered list)”，其中數據項只按照存放位置來索引，如第1個、第2個…、最後一個等。 如一個考試分數的集合“54,26,93,

weixin_38324954 2020-07-08 11:06:53

算法複雜度評價指標（大o表示法）

大O表示法（1）常見的大o數量級函數（2）其他算法複雜度表示法 基本操作數量函數T(n)的精確值並不是特別重要，重要的是Tn(n)中起決定性因素的主導部分。用動態的眼光看，就是當問題規模增大的時候，T(n)中的一些部分會蓋過其他部

weixin_38324954 2020-07-08 11:06:52

“變位詞”判斷問題及算法複雜度

解法1 逐字檢查 解法思路： 將詞1中的字符逐個到詞2中檢查是否存在，存在就打勾標記（防止重複檢查）。如果每個字符都能找到，則兩個詞是變位詞。只要有一個字符找不到，就不是變位詞。 實現打勾標記：將詞2對應字符設爲None,由於

weixin_38324954 2020-07-08 11:06:52

基本數據結構——線性結構（有序表）

1. 什麼是有序表（OrderedList） 有序表是一種數據項依照其某可比性質（如整數大小、字母表先後）來決定在列表中的位置。越“小”的數據項越靠近列表的頭，越靠“前”。 2.抽象數據類型有序表（OrderedList）定義的

weixin_38324954 2020-07-08 11:06:52

python兩種內置數據類型（列表list和字典dict）上各個操作的大O數量級

python兩種內置數據類型（列表list和字典dict）上各個操作的大O數量級 1.對比list和dict操作 2.list列表數據類型常用操作性能 (1)按索引取值和賦值（v=a[i],a[i]=v） 由於列表的隨機訪問特性

weixin_38324954 2020-07-08 11:06:52

基本數據結構——線性結構（棧）

1.什麼是線性結構 線性結構是一種有序數據項的集合，其中每個數據項都有唯一的前驅和後繼（除了第一個沒有前驅，最後一個沒有後繼）。新的數據項加入到數據集中時，只會加入到原有某個數據項之前或之後。具有這種性質的數據集，就稱爲線性結構。

weixin_38324954 2020-07-08 11:06:52

基本數據結構——線性結構（隊列、雙端隊列）

1. 什麼是隊列？ 隊列是一種有次序的數據集合，其特徵是新數據項的添加總髮生在一端（通常稱爲“尾端”），而現存數據項的移除總髮生在另一端（通常稱爲“首front”端）。 新加入的數據項必須在數據集末尾等待，而等待時間最長的數據項則

weixin_38324954 2020-07-08 11:06:52

遞歸(Recursion)及其應用

1. 什麼是遞歸 遞歸是一種解決問題的方法，其精髓在於將問題分解爲規模更小的相同問題，持續分解，直到問題規模小到可以用非常簡單直接的方式來解決。 遞歸問題分解方式非常獨特，其算法方面的明顯特徵就是：在算法流程中調用自身。 2. 遞

weixin_38324954 2020-07-08 11:06:52

未理解的題

關於樹的深度優先搜索算法描述錯誤的是 A : 按照某個條件往前試探搜索,如果前進中遭遇失敗, 則退回頭另選通路繼續搜索,直到找到條件目標爲止 B: 先訪問該節點所有的子節點, 遍歷完畢後選取它未訪問過的子節點重複上述過程,直到找到

harkecho 2020-07-08 10:56:02

按位與& 和 模運算 % 的關係

unsigned int MAX = 32; // 2的5次方 unsigned int index = 31; index = (index + 100) % MAX; printf ("inde

harkecho 2020-07-08 10:56:02

位運算判斷兩個數是否異號

首先介紹下負數在計算機中的表示和存儲 在計算機系統中，數值一律用補碼錶示和存儲。含符號位和數值位，符號位：0表示“正”； 1表示“負”。 正數的補碼 = 原碼 負數的補碼 = 負數的原碼取反（符號位保持不變）+ 1 列如 比如

harkecho 2020-07-08 10:56:01

按位或與加法的區別

0 | 0 = 0 1 | 1 = 1 0 | 1 = 1 1 | 0 = 1 0 ^ 0 = 0 1 ^ 1 = 0 0 ^ 1 = 1 1 ^ 0 = 1 0 & 0 = 0 1 &

harkecho 2020-07-08 10:56:01