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

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

struct BinaryTreeNode

{

    int                    m_nValue;

    BinaryTreeNode*        m_pLeft;  

    BinaryTreeNode*        m_pRight;

};

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 DestroyTree(BinaryTreeNode* pRoot)

{

    if(pRoot != NULL)

    {

        BinaryTreeNode* pLeft = pRoot->m_pLeft;

        BinaryTreeNode* pRight = pRoot->m_pRight;

        delete pRoot;

        pRoot = NULL;

        DestroyTree(pLeft);

        DestroyTree(pRight);

    }

}

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

}

bool IsBalanced_1(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_1(pRoot->m_pLeft) && IsBalanced_1(pRoot->m_pRight);

}

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_2(BinaryTreeNode* pRoot)

{

    int depth = 0;

    return IsBalanced(pRoot,&depth);

}

void Test(char* testName, BinaryTreeNode* pRoot, bool expected)

{

    if(testName != NULL)

        printf(“%s begins:\n”, testName);

    printf(“Solution1 begins: “);

    if(IsBalanced_1(pRoot) == expected)

        printf(“Passed.\n”);

    else

        printf(“Failed.\n”);

    printf(“Solution2 begins: “);

    if(IsBalanced_2(pRoot) == expected)

        printf(“Passed.\n”);

    else

        printf(“Failed.\n”);

}

void Test1()

{

    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, pNode6, pNode7);

    Test(“Test1”, pNode1, true);

    DestroyTree(pNode1);

}

void Test2()

{

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

    Test(“Test2”, pNode1, true);

    DestroyTree(pNode1);

}

void Test3()

{

    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);

    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);

    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);

    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);

    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);

    BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6);

    ConnectTreeNodes(pNode1, pNode2, pNode3);

    ConnectTreeNodes(pNode2, pNode4, pNode5);

    ConnectTreeNodes(pNode5, pNode6, NULL);

    Test(“Test3”, pNode1, false);

    DestroyTree(pNode1);

}

void Test4()

{

    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);

    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);

    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);

    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);

    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);

    ConnectTreeNodes(pNode1, pNode2, NULL);

    ConnectTreeNodes(pNode2, pNode3, NULL);

    ConnectTreeNodes(pNode3, pNode4, NULL);

    ConnectTreeNodes(pNode4, pNode5, NULL);

    Test(“Test4”, pNode1, false);

    DestroyTree(pNode1);

}

void Test5()

{

    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);

    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);

    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);

    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);

    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);

    ConnectTreeNodes(pNode1, NULL, pNode2);

    ConnectTreeNodes(pNode2, NULL, pNode3);

    ConnectTreeNodes(pNode3, NULL, pNode4);

    ConnectTreeNodes(pNode4, NULL, pNode5);

    Test(“Test5”, pNode1, false);

    DestroyTree(pNode1);

}

void Test6()

{

    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);

    Test(“Test6”, pNode1, true);

    DestroyTree(pNode1);

}

void Test7()

{

    Test(“Test7”, NULL, true);

}

int main()

{

    Test1();

    Test2();

    Test3();

    Test4();

    Test5();

    Test6();

    Test7();

    return 0;

}