面试题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》