【面试题039】二叉树的深度

【面试题039】二叉树的深度

题目一：

    输入一棵二叉树的根结点，求该树的深度。从根结点到叶结点依次经过的结点（含根，叶结点）形成树的一条路径，最长路径的长度为树的深度。

二叉树结点的结构如下：

1 2 3 4 5 6

struct BinaryTreeNode {     int m_nValue;     BinaryTreeNode *m_pLeft;     BinaryTreeNode *m_pRight; }

 

思路一：

    如果一个树只有一个结点，那么这个树的深度为1，

    如果根结点只有左子树而没有右子树，那么树的深度应该是其左子树的深度加1；

    同样如果根结点只有右子树而没有左子树，那么树的深度应该是其右子树的深度加1；

    如果基友左子树又有右子树，那么该树的深度就是其左、右子树深度的最大值再加1；

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

#include <iostream> #include "BinaryTree.h" using namespace std; int TreeDepth(BinaryTreeNode *pRoot) {     if(pRoot == NULL)         return 0;     int nLeft = TreeDepth(pRoot->m_pLeft);     int nRight = TreeDepth(pRoot->m_pRight);     return (nLeft > nRight) ? (nLeft + 1) : (nRight + 1); } //            1 //         /       //        2        3 //       /          //      4  5         6 //        / //       7 int main() {     BinaryTreeNode *pNode1 = CreateBinaryTreeNode(1);     BinaryTreeNode *pNode2 = CreateBinaryTreeNode(2);     BinaryTreeNode *pNode3 = CreateBinaryTreeNode(3);     BinaryTreeNode *pNode4 = CreateBinaryTreeNode(4);     BinaryTreeNode *pNode5 = CreateBinaryTreeNode(5);     BinaryTreeNode *pNode6 = CreateBinaryTreeNode(6);     BinaryTreeNode *pNode7 = CreateBinaryTreeNode(7);     ConnectTreeNodes(pNode1, pNode2, pNode3);     ConnectTreeNodes(pNode2, pNode4, pNode5);     ConnectTreeNodes(pNode3, NULL, pNode6);     ConnectTreeNodes(pNode5, pNode7, NULL);     cout << TreeDepth(pNode1) << endl;     DestroyTree(pNode1);     return 0; }

BinaryTree.h

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#ifndef _BINARY_TREE_H_ #define _BINARY_TREE_H_ struct BinaryTreeNode {     int                    m_nValue;     BinaryTreeNode        *m_pLeft;     BinaryTreeNode        *m_pRight; }; BinaryTreeNode *CreateBinaryTreeNode(int value); void ConnectTreeNodes(BinaryTreeNode *pParent,                       BinaryTreeNode *pLeft, BinaryTreeNode *pRight); void PrintTreeNode(BinaryTreeNode *pNode); void PrintTree(BinaryTreeNode *pRoot); void DestroyTree(BinaryTreeNode *pRoot); #endif //_BINARY_TREE_H_

BinaryTree.cpp

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78

#include <iostream> #include "BinaryTree.h" BinaryTreeNode *CreateBinaryTreeNode(int value) {     BinaryTreeNode *pNode = new BinaryTreeNode();     pNode->m_nValue = value;     pNode->m_pLeft = NULL;     pNode->m_pRight = NULL;     return pNode; } void ConnectTreeNodes(BinaryTreeNode *pParent,                       BinaryTreeNode *pLeft, BinaryTreeNode *pRight) {     if(pParent != NULL)     {         pParent->m_pLeft = pLeft;         pParent->m_pRight = pRight;     } } void PrintTreeNode(BinaryTreeNode *pNode) {     if(pNode != NULL)     {         printf("value of this node is: %d ", pNode->m_nValue);         if(pNode->m_pLeft != NULL)             printf("value of its left child is: %d. ",                    pNode->m_pLeft->m_nValue);         else             printf("left child is null. ");         if(pNode->m_pRight != NULL)             printf("value of its right child is: %d. ",                    pNode->m_pRight->m_nValue);         else             printf("right child is null. ");     }     else     {         printf("this node is null. ");     }     printf(" "); } void PrintTree(BinaryTreeNode *pRoot) {     PrintTreeNode(pRoot);     if(pRoot != NULL)     {         if(pRoot->m_pLeft != NULL)             PrintTree(pRoot->m_pLeft);         if(pRoot->m_pRight != NULL)             PrintTree(pRoot->m_pRight);     } } void DestroyTree(BinaryTreeNode *pRoot) {     if(pRoot != NULL)     {         BinaryTreeNode *pLeft = pRoot->m_pLeft;         BinaryTreeNode *pRight = pRoot->m_pRight;         delete pRoot;         pRoot = NULL;         DestroyTree(pLeft);         DestroyTree(pRight);     } }

题目二：

    输入一棵二叉树的根结点，判断该树是不是平衡二叉树。

如果某二叉树中任意结点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。

 

 

思路一：

    根据深度来做判断，但是结点重复遍历了很多次，效率不高。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

bool IsBalanced(BinaryTreeNode *pRoot) {     if (pRoot == NULL)     {         return true;     }     int left = TreeDepth(pRoot->m_pLeft);     int right = TreeDepth(pRoot->m_pRight);     int diff = left - right;     if (diff > 1 || diff < -1)     {         return false;     }     return IsBalanced(pRoot->m_pLeft)            && IsBalanced(pRoot->m_pRight); }

 

思路二：

    记住，每个结点都遍历一遍的解法才是高效的解法。

用后序遍历的方式遍历二叉树的每一个结点，在遍历到一个结点之前我们就已经遍历了它的左右子树。

只要在遍历每个结点的时候记录它的深度，我们就可以一边遍历，一边判断是不是平衡的。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

bool IsBalanced(BinaryTreeNode *pRoot, int *pDepth) {     if (pRoot == NULL)     {         *pDepth = 0;         return true;     }     int left, right;     if (IsBalanced(pRoot->m_pLeft, &left)             && IsBalanced(pRoot->m_pRight, &right))     {         int diff = left - right;         if (diff <= 1 && diff >= -1)         {             *pDepth = 1 + (left > right ? left : right);             return true;         }     }     return false; } bool IsBalanced(BinaryTreeNode *pRoot) {     int depth = 0;     return IsBalanced(pRoot, &depth); }