给定一棵二叉搜索树的先序遍历序列,要求你找出任意两结点的最近公共祖先结点(简称 LCA)。
输入格式:
输入的第一行给出两个正整数:待查询的结点对数 M(≤ 1 000)和二叉搜索树中结点个数 N(≤ 10 000)。随后一行给出 N 个不同的整数,为二叉搜索树的先序遍历序列。最后 M 行,每行给出一对整数键值 U 和 V。所有键值都在整型int范围内。
输出格式:
对每一对给定的 U 和 V,如果找到 A 是它们的最近公共祖先结点的键值,则在一行中输出 LCA of U and V is A.。但如果 U 和 V 中的一个结点是另一个结点的祖先,则在一行中输出 X is an ancestor of Y.,其中 X 是那个祖先结点的键值,Y 是另一个键值。如果 二叉搜索树中找不到以 U 或 V 为键值的结点,则输出 ERROR: U is not found. 或者 ERROR: V is not found.,或者 ERROR: U and V are not found.。
输入样例:
6 8
6 3 1 2 5 4 8 7
2 5
8 7
1 9
12 -3
0 8
99 99
输出样例:
LCA of 2 and 5 is 3.
8 is an ancestor of 7.
ERROR: 9 is not found.
ERROR: 12 and -3 are not found.
ERROR: 0 is not found.
ERROR: 99 and 99 are not found.
原题地址暂无
因为这个是博主PTA周测题库里的一道题目。
大致思路:
我们知道先序序列的规律一定是:第一个数字是根节点的值,后面跟着一连串左子树的值,再然后跟着一串右子树的值。又因为这个序列是一个排序树的序列,所以我们很容易就能根据序列创建出一颗树来。
就拿样例输入来说:6 3 1 2 5 4 8 7
我们很容易知道根节点是6,然后后面一连串比6小的数字一定是左子树(这里就是3 1 2 5 4),再然后一连串比6大的数字一定是右子树(这里是8 7)。
所以这个6 3 1 2 5 4 8 7就很容易拆分成 6,3 1 2 5 4,8 7这三部分,分别代表根,左子树,右子树。而对于3 1 2 5 4和8 7来说也可以利用相同的规律拆分成(3,1 2,5 4)和(8 ,7,空)。如此递归下去,就可以创建树。下面给出创建树的代码:
Node* createTree(int* seq, int from, int to, map<int, Node*>& nodeMap)
{
Node* newNode = new Node;
newNode->val = seq[from];
nodeMap[newNode->val] = newNode;
int minPos = -1;
int maxPos = -1;
for (int i = from + 1; i <= to; i++)
{
if (seq[i] < seq[from])
{
minPos = i;
}
}
for (int i = (minPos == -1 ? from + 1 : minPos + 1); i <= to; i++)
{
if (seq[i] > seq[from])
{
maxPos = i;
break;
}
}
if (minPos == -1)
{
newNode->l = NULL;
}
else
{
Node* l = createTree(seq, from + 1, minPos, nodeMap);
newNode->l = l;
l->p = newNode;
}
if (maxPos == -1)
{
newNode->r == NULL;
}
else
{
Node* r = createTree(seq, maxPos, to, nodeMap);
newNode->r = r;
r->p = newNode;
}
return newNode;
}
这里有一个map<int, Node*>& nodeMap参数,我们每插入一个节点都把这个节点的值属性作为键,这个节点的地址作为值(注意此值的概念不是值节点的值,是map里键值对的值)传入nodeMap里面,这样子做是为了我们之后查找节点的效率从O(logn)降到O(1),虽然O(logn)也能接受,但是如果样例输入的树结构比较差,可能查找效率会退化成O(1),所以我们还是以防万一。
树建好了,接下来的工作就简单了。如何找两个节点公共祖先呢。我们可以从根节点开始遍历:
1)如果两个节点的值比当前节点的值都大,那么说明两个节点的公共祖先一定在右子树上,我们把当前节点转向右子树继续遍历
2)同理如果两个节点的值比当前节点的值都小,我们转向左子树继续遍历
3)如果当前节点介于两者之间(我们考虑当前节点的值和两个节点其中之一的值相等的情况,比如8也视为介于7和8之间),那么当前节点就是公共祖先,遍历完毕。
下面给出搜索祖先的函数:
Node* findAncestor(Node* tree, Node* node1, Node* node2)
{
if (tree == NULL)
{
return NULL;
}
if (tree->val > node1->val && tree->val > node2->val)
{
return findAncestor(tree->l, node1, node2);
}
if (tree->val < node1->val && tree->val < node2->val)
{
return findAncestor(tree->r, node1, node2);
}
if (tree->val >= min(node1->val, node2->val) && tree->val <= max(node1->val, node2->val))
{
return tree;
}
}
这两个函数写完接下来的事情都是水到渠成。我们只需要做一些输入输出的操作就行了。
完整代码如下:
#include<iostream>
#include<map>
#include<cmath>
using namespace std;
struct Node
{
Node* p = NULL;
Node* l = NULL;
Node* r = NULL;
int val;
};
Node* findAncestor(Node* tree, Node* node1, Node* node2)
{
if (tree == NULL)
{
return NULL;
}
if (tree->val > node1->val && tree->val > node2->val)
{
return findAncestor(tree->l, node1, node2);
}
if (tree->val < node1->val && tree->val < node2->val)
{
return findAncestor(tree->r, node1, node2);
}
if (tree->val >= min(node1->val, node2->val) && tree->val <= max(node1->val, node2->val))
{
return tree;
}
}
Node* createTree(int* seq, int from, int to, map<int, Node*>& nodeMap)
{
Node* newNode = new Node;
newNode->val = seq[from];
nodeMap[newNode->val] = newNode;
int minPos = -1;
int maxPos = -1;
for (int i = from + 1; i <= to; i++)
{
if (seq[i] < seq[from])
{
minPos = i;
}
}
for (int i = (minPos == -1 ? from + 1 : minPos + 1); i <= to; i++)
{
if (seq[i] > seq[from])
{
maxPos = i;
break;
}
}
if (minPos == -1)
{
newNode->l = NULL;
}
else
{
Node* l = createTree(seq, from + 1, minPos, nodeMap);
newNode->l = l;
l->p = newNode;
}
if (maxPos == -1)
{
newNode->r == NULL;
}
else
{
Node* r = createTree(seq, maxPos, to, nodeMap);
newNode->r = r;
r->p = newNode;
}
return newNode;
}
int main()
{
ios::sync_with_stdio(false);
int m, n;
cin >> m >> n;
int* seq = new int[n];
for (int i = 0; i < n; i++)
{
cin >> seq[i];
}
map<int, Node*> nodeMap;
Node* tree = createTree(seq, 0, n - 1, nodeMap);
for (int i = 0; i < m; i++)
{
int x, y;
cin >> x >> y;
int xCount = nodeMap.count(x), yCount = nodeMap.count(y);
if (xCount == 0 && yCount == 0)
{
printf("ERROR: %d and %d are not found.\n", x, y);
continue;
}
if (xCount == 0)
{
printf("ERROR: %d is not found.\n", x);
continue;
}
if (yCount == 0)
{
printf("ERROR: %d is not found.\n", y);
continue;
}
Node* ancestor = findAncestor(tree, nodeMap[x], nodeMap[y]);
if (ancestor->val == x)
{
printf("%d is an ancestor of %d.\n", x, y);
continue;
}
if (ancestor->val == y)
{
printf("%d is an ancestor of %d.\n", y, x);
continue;
}
printf("LCA of %d and %d is %d.\n", x, y, ancestor->val);
}
}
看起来很多实际上核心的东西就那么二三十行
最后提交PTA完美通过,耗时也比较低,说明效率还是可以的。