PTA周测 二叉搜索树的最近公共祖先

给定一棵二叉搜索树的先序遍历序列，要求你找出任意两结点的最近公共祖先结点（简称 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完美通过，耗时也比较低，说明效率还是可以的。