剑指Offer（面试题38~39）

面试题38：数字在排序数组中出现的次数

题目：统计一个数字在排序数组中出现的次数。例如输入排序数组{1，2，3，3，3，3，4，5}和数字3，由于3在这个数组中出现了4次，因此输出4。

//递归的代码找到排列数组中的第一个k:
int GetFirstK(int* data,int length,int k,int start,int end)
{
    if(start > end)
        return -1;

    int middleIndex = (start + end) / 2;
    int middleData = data[middleIndex];

    if(middleData == k)
    {
        if((middleIndex > 0 && data[middleIndex - 1] != k)
           || middleIndex == 0)
            return middleIndex;
        else
            end = middleIndex - 1;
    }
    else if(middleData > k)
        end = middleIndex - 1;
    else
        start = middleIndex + 1;

    return GetFirstK(data,length,k,start,end);
}

int GetLastK(int* data,int length,int k,int start,int end)
{
    if(start > end)
        return -1;

    int middleIndex = (start + end) / 2;
    int middleData = data[middleIndex];

    if(middleData == k)
    {
        if((middleIndex < length - 1 && data[middleIndex +1 ] != k)
           || middleIndex == length - 1)
        {
            return middleIndex;
        }
        else
            start = middleIndex + 1;
    }
    else if(middleData < k)
        start =middleIndex + 1;
    else
        end = middleIndex - 1;

    return GetLastK(data,length,k,start,end);
}

//在分别找到第一个k和最后一个k的下标之后，我们就能计算出k在数组中出现的次数了。
int GetNumberOfK(int* data,int length, int k)
{
    int number = 0;

    if(data != NULL && length > 0)
    {
        int first = GetFirstK(data,length,k,0,length -1);
        int last = GetLastK(data,length,k,0,length - 1);

        if(first > -1 && last > -1)
            number = last - first +1;
    }

    return number;
}

在上述代码中，GetFirstK和GetLastK都是用二叉查找法在数组中查找一个合乎要求的数字，它们的时间复杂度都是O(logn)，因此GetNumberOfK的总的时间复杂度也只有O(logn)。

面试题39：二叉树的深度

题目一：输入一棵二叉树的根结点，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
二叉树的结点定义如下:

struct BinaryTreeNode
{
    int              m_nValue;
    BinaryTreeNode*  m_pLeft;
    BinaryTreeNode*  m_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);
}

题目二：输入一棵二叉树的根结点，判断该树是不是平衡二叉树。如果某二叉树中任意结点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。

方法一：调用函数TreeDepth得到它的左右子树的深度。如果每个结点的左右子树的深度相差都不超过1，按照定义它就是一棵平衡的二叉树。代码如下：

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

上面的代码固然简洁，但我们也要注意到由于一个结点会被重复遍历多次，这种思路的时间效率不高。

每个结点只遍历一次的解法，正是面试官喜欢的

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

在上面的代码中，我们用后序遍历的方式遍历整棵二叉树。在遍历某结点的左右子结点之后，我们可以根据它的左右子结点的深度判断它是不是平衡的，并得到当前结点的深度。当最后遍历到树的根结点的时候，也就判断整棵二叉树是不是平衡二叉树。

参考资料《剑指Offer》