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

最新推荐文章于 2024-07-22 22:12:00 发布

A201241302241

最新推荐文章于 2024-07-22 22:12:00 发布

阅读量64

点赞数

原文链接：http://www.cnblogs.com/codemylife/p/3756447.html

版权

【面试题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\n", pNode->m_nValue);

         if(pNode->m_pLeft != NULL)
            printf( "value of its left child is: %d.\n",
                   pNode->m_pLeft->m_nValue);
         else
            printf( "left child is null.\n");

         if(pNode->m_pRight != NULL)
            printf( "value of its right child is: %d.\n",
                   pNode->m_pRight->m_nValue);
         else
            printf( "right child is null.\n");
    }
     else
    {
        printf( "this node is null.\n");
    }

    printf( "\n");
}

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);
}