在二叉树中找近期公共父节点。分为两种情况,一种是有父指针,一种没有父指针。
1、有父指针
这样的情况比較简单。计算两个结点的深度,再把深度大的向上移。移到同一深度。在同一时候向上移动,直到两个结点同样,这样便找到了父节点。
这个算法时间复杂度为O(N)。
代码实现:
#include<iostream>
struct Node
{
int data;
Node* left;
Node* right;
Node* parent;
Node() :left(NULL), right(NULL), parent(NULL)
{}
};
int getDpeth(Node *n)//结点n到根节点深度
{
int count = 0;
while (n)
{
++count;
n = n->parent;
}
return count;
}
Node* findNearestCommonAncestor(Node* n1, Node* n2)
{
int depth1 = getDpeth(n1);
int depth2 = getDpeth(n2);
//移动同一深度
while (depth1 > depth2)
{
n1 = n1->parent;
--depth1;
}
while (depth1 < depth2)
{
n2 = n2->parent;
--depth2;
}
//向上找
while (n1 != n2)
{
n1 = n1->parent;
n2 = n2->parent;
}
return n1;
}
int main()
{
//測试
Node* A[11];
for (int i = 0; i < 11; ++i)
{
A[i] = new Node();
A[i]->data = i;
}
for (int i = 0; i < 5; ++i)
{
A[i]->left = A[i * 2 + 1];
A[i * 2 + 1]->parent = A[i];
A[i]->right = A[i * 2 + 2];
A[i * 2 + 2]->parent = A[i];
}
Node* Ancestor = findNearestCommonAncestor(A[7], A[6]);
}
2、没有父指针
这样的情况有点难。
首先从根节点開始向下找,假设根节点等于当中一个子节点,那么根节点便是近期公共父结点。
否则计算左子树和右子树中包括n1或n2的个数。假设左子树包括n1、n2那么近期公共父结点在左子树,假设右子树包括n1和n2,那么在右子树。假设左右子树各包括一个,那么近期公共父结点就是当前结点。假设二叉树是平衡的,那么算法复杂度为O(logN)。
最坏情况就是树成了链表。算法时间负责度为O(N^2)。
思路清晰了,能够编写代码:
#include<iostream>
struct Node
{
int data;
Node* left;
Node* right;
Node() :left(NULL), right(NULL)
{}
};
//计算当前结点包括n1、n2个数
int countMatch(Node *current, Node* n1, Node* n2)
{
if (current == NULL)
return 0;
int count = countMatch(current->left, n1, n2) + countMatch(current->right, n1, n2);
if (current == n1 || current == n2)
return 1 + count;
return count;
}
Node* findLCA(Node* root, Node* n1, Node* n2)
{
if (root == NULL)
return NULL;
if (root == n1 || root == n2)
return root;
int count = countMatch(root->left, n1, n2);//左子树包括n1和n2的个数
if (count == 1)
return root;//左子树一个,右子树肯定也有一个
else if (count == 2)//都在左子树
return findLCA(root->left, n1, n2);
else//都在右子树
return findLCA(root->right, n1, n2);
}
int main()
{
//測试
Node* A[11];
for (int i = 0; i < 11; ++i)
{
A[i] = new Node();
A[i]->data = i;
}
for (int i = 0; i < 5; ++i)
{
A[i]->left = A[i * 2 + 1];
A[i]->right = A[i * 2 + 2];
}
Node* Ancestor = findLCA(A[0],A[7], A[10]);
}
另一种方法,从下向上找。假设找到n1或n2,就把它传给它的父结点,假设向下到头都没有找到,那么返回NULL。假设当前结点左右子树都返回非NULL,那么当前结点就是近期公共父结点。这样仅仅须要遍历一遍。算法时间复杂度为O(N)。
#include<iostream>
struct Node
{
int data;
Node* left;
Node* right;
Node() :left(NULL), right(NULL)
{}
};
Node* findLCA(Node *root, Node* n1, Node* n2)
{
if (root == NULL)//没找到
return NULL;
if (root == n1 || root == n2)//找到
return root;
Node* L = findLCA(root->left, n1, n2);//左子树
Node* R = findLCA(root->right, n1, n2);//右子树
//当前结点左右子树都找到了n1和n2。那么这个结点就是LCA结点
if (L != NULL&R != NULL)
return root;
//否则是不为NULL的结点。或者两个都为NULL
else
return L !=NULL ? L : R;
}
int main()
{
//測试
Node* A[11];
for (int i = 0; i < 11; ++i)
{
A[i] = new Node();
A[i]->data = i;
}
for (int i = 0; i < 5; ++i)
{
A[i]->left = A[i * 2 + 1];
A[i]->right = A[i * 2 + 2];
}
Node* Ancestor = findLCA(A[0], A[7], A[10]);
}