百度测试开发算法题

最新推荐文章于 2024-04-30 17:58:34 发布

「已注销」

最新推荐文章于 2024-04-30 17:58:34 发布

阅读量739

点赞数

分类专栏：学习文章标签：笔试题

本文链接：https://blog.csdn.net/snyyjiao/article/details/39496803

版权

学习专栏收录该内容

52 篇文章 0 订阅

订阅专栏

百度开发测试的笔试算法题，第一大题为简答，第二大题是三个算法题，第三大题是分布式的不会做，介于本人不是计算机专业，所以看不懂题目。。。

1.输入二叉树中的两个结点，输出这两个结点在数中最低的共同父结点。

分析：求数中两个结点的最低共同结点是面试中经常出现的一个问题。这个问题至少有两个变种。

第一变种是二叉树是一种特殊的二叉树：查找二叉树。也就是树是排序过的，位于左子树上的结点都比父结点小，而位于右子树的结点都比父结点大。我们只需要从根结点开始和两个结点进行比较。如果当前结点的值比两个结点都大，则最低的共同父结点一定在当前结点的左子树中。如果当前结点的值比两个结点都小，则最低的共同父结点一定在当前结点的右子树中。

第二个变种是树不一定是二叉树，每个结点都有一个指针指向它的父结点。于是我们可以从任何一个结点出发，得到一个到达树根结点的单向链表。因此这个问题转换为两个单向链表的第一个公共结点。

现在我们回到这个问题本身。所谓共同的父结点，就是两个结点都出现在这个结点的子树中。因此我们可以定义一函数，来判断一个结点的子树中是不是包含了另外一个结点。这不是件很难的事，我们可以用递归的方法来实现：

// If the tree with head pHead has a node pNode, return true.

// Otherwise return false.

bool HasNode(TreeNode* pHead, TreeNode* pNode)

{

if(pHead == pNode)

return true;

bool has = false;

if(pHead->m_pLeft != NULL)

has = HasNode(pHead->m_pLeft, pNode);

if(!has && pHead->m_pRight != NULL)

has = HasNode(pHead->m_pRight, pNode);

return has;

}

我们可以从根结点开始，判断以当前结点为根的树中左右子树是不是包含我们要找的两个结点。如果两个结点都出现在它的左子树中，那最低的共同父结点也出现在它的左子树中。如果两个结点都出现在它的右子树中，那最低的共同父结点也出现在它的右子树中。如果两个结点一个出现在左子树中，一个出现在右子树中，那当前的结点就是最低的共同父结点。基于这个思路，我们可以写出如下代码：

// Find the last parent of pNode1 and pNode2 in a tree with head pHead

TreeNode* LastCommonParent_1(TreeNode* pHead, TreeNode* pNode1, TreeNode* pNode2)

{

if(pHead == NULL || pNode1 == NULL || pNode2 == NULL)

return NULL;

// check whether left child has pNode1 and pNode2

bool leftHasNode1 = false;

bool leftHasNode2 = false;

if(pHead->m_pLeft != NULL)

{

leftHasNode1 = HasNode(pHead->m_pLeft, pNode1);

leftHasNode2 = HasNode(pHead->m_pLeft, pNode2);

}

if(leftHasNode1 && leftHasNode2)

{

if(pHead->m_pLeft == pNode1 || pHead->m_pLeft == pNode2)

return pHead;

return LastCommonParent_1(pHead->m_pLeft, pNode1, pNode2);

}

// check whether right child has pNode1 and pNode2

bool rightHasNode1 = false;

bool rightHasNode2 = false;

if(pHead->m_pRight != NULL)

{

if(!leftHasNode1)

rightHasNode1 = HasNode(pHead->m_pRight, pNode1);

if(!leftHasNode2)

rightHasNode2 = HasNode(pHead->m_pRight, pNode2);

}

if(rightHasNode1 && rightHasNode2)

{

if(pHead->m_pRight == pNode1 || pHead->m_pRight == pNode2)

return pHead;

return LastCommonParent_1(pHead->m_pRight, pNode1, pNode2);

}

if((leftHasNode1 && rightHasNode2)

|| (leftHasNode2 && rightHasNode1))

return pHead;

return NULL;

}

接着我们来分析一下这个方法的效率。函数HasNode的本质就是遍历一棵树，其时间复杂度是O(n)（n是树中结点的数目）。由于我们根结点开始，要对每个结点调用函数HasNode。因此总的时间复杂度是O(n2)。

我们仔细分析上述代码，不难发现我们判断以一个结点为根的树是否含有某个结点时，需要遍历树的每个结点。接下来我们判断左子结点或者右结点为根的树中是否含有要找结点，仍然需要遍历。第二次遍历的操作其实在前面的第一次遍历都做过了。由于存在重复的遍历，本方法在时间效率上肯定不是最好的。

前面我们提过如果结点中有一个指向父结点的指针，我们可以把问题转化为求两个链表的共同结点。现在我们可以想办法得到这个链表。

// Get the path form pHead and pNode in a tree with head pHead

bool GetNodePath(TreeNode* pHead, TreeNode* pNode, std::list<TreeNode*>& path)

{

if(pHead == pNode)

return true;

path.push_back(pHead);

bool found = false;

if(pHead->m_pLeft != NULL)

found = GetNodePath(pHead->m_pLeft, pNode, path);

if(!found && pHead->m_pRight)

found = GetNodePath(pHead->m_pRight, pNode, path);

if(!found)

path.pop_back();

return found;

}

由于这个路径是从跟结点开始的。最低的共同父结点就是路径中的最后一个共同结点：

// Get the last common Node in two lists: path1 and path2

TreeNode* LastCommonNode

(

const std::list<TreeNode*>& path1,

const std::list<TreeNode*>& path2

)

{

std::list<TreeNode*>::const_iterator iterator1 = path1.begin();

std::list<TreeNode*>::const_iterator iterator2 = path2.begin();

TreeNode* pLast = NULL;

while(iterator1 != path1.end() && iterator2 != path2.end())

{

if(*iterator1 == *iterator2)

pLast = *iterator1;

iterator1++;

iterator2++;

}

return pLast;

}

有了前面两个子函数之后，求两个结点的最低共同父结点就很容易了。我们先求出从根结点出发到两个结点的两条路径，再求出两条路径的最后一个共同结点。代码如下：

// Find the last parent of pNode1 and pNode2 in a tree with head pHead

TreeNode* LastCommonParent_2(TreeNode* pHead, TreeNode* pNode1, TreeNode* pNode2)

{

if(pHead == NULL || pNode1 == NULL || pNode2 == NULL)

return NULL;

std::list<TreeNode*> path1;

GetNodePath(pHead, pNode1, path1);

std::list<TreeNode*> path2;

GetNodePath(pHead, pNode2, path2);

return LastCommonNode(path1, path2);

}

这种思路的时间复杂度是O(n)，时间效率要比第一种方法好很多。但同时我们也要注意到，这种思路需要两个链表来保存路径，空间效率比不上第一个方法。

建立三个工作指针p,q,r，然后p遍历全表。p每到一个结点，q就从这个结点往后遍历，并与p的数值比较，相同的话就free掉那个结点。

<pre name="code" class="html"><span style="font-size:18px;background-color: rgb(255, 255, 255);"></span>

LinkList RemoveDupNode(LinkList L)//删除重复结点的算法
{
LinkList p,q,r;
p=L->next;
while(p) // p用于遍历链表
{
q=p;
while(q->next) // q遍历p后面的结点，并与p数值比较
{
if(q->next->data==p->data)
{
r=q->next; // r保存需要删掉的结点
q->next=r->next; // 需要删掉的结点的前后结点相接
free(r);
}
else
q=q->next;
}
p=p->next;
}
return L;
}

3.输入一棵二叉树的根结点，判断该树是不是平衡二叉树。如果某二叉树中任意结点的左右子树的深度相差不超过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);

}

上面的代码固然简洁，但我们也要注意到由于一个节点会被重复遍历多次，这种思路的时间效率不高。例如在函数IsBalance中输入上图中的二叉树，首先判断根结点（值为1的结点）的左右子树是不是平衡结点。此时我们将往函数TreeDepth输入左子树根结点（值为2的结点），需要遍历结点4、5、7。接下来判断以值为2的结点为根结点的子树是不是平衡树的时候，仍然会遍历结点4、5、7。毫无疑问，重复遍历同一个结点会影响性能。接下来我们寻找不需要重复遍历的算法。