方法一:连通性判定
我们将验证二叉树的过程分为两步:第一步找到二叉树的根节点,第二步从根节点开始对二叉树进行遍历,判断其是否为一颗有效的二叉树。
找根节点
在第一步中,为了找到根节点,我们需要用数组 indeg 存放所有节点的入度,这是因为只有入度为 0 的点才能是根节点。我们遍历数组 leftChild 和 rightChild,如果数组中的某个元素 x 不为 -1,那么就表示有一条边指向节点 x,节点 x 的入度 indeg[x] 增加 1。在遍历完数组 leftChild 和 rightChild 后,我们在数组 indeg 中找到一个满足 index[root] == 0 的节点 root,即为二叉树的根节点。
如果有多个满足 index[root] == 0 的节点呢?在这种情况下,这 n 个节点一定不是一颗有效的二叉树。我们把这个问题放在第二步来考虑,而在第一步中,我们先不处理这个问题。
bfs
在第二步中,我们从根节点开始进行深度优先搜索或广度优先搜索,判定这 n 个节点的连通性,这是因为当这个 n 个节点是一颗有效的二叉树时,所有的节点会恰好被遍历一次。如果某一个节点被遍历了超过一次(有不止一个父节点)或零次(不连通),那么这 n 个节点都不是一颗有效的二叉树。我们可以使用哈希集合(HashSet)seen 来存放所有被遍历过的节点,如果在搜索时遍历到了 seen 中出现的节点,那么说明该节点被遍历了超过一次。如果在搜索完成后,seen 中的节点个数少于 n,那么说明有些节点没有被遍历过。
回到第一步中遗留的那个问题,如果有多个满足 index[root] == 0 的节点 r1, r2, …,那么我们可以任意选择一个节点,例如 r1,作为根节点。在搜索时,由于节点 r2, … 的入度为 0,因此不可能被遍历到。这样在搜索结束后,seen 中的节点个数一定少于 n。
class Solution {
public:
bool validateBinaryTreeNodes(int n, vector<int>& leftChild, vector<int>& rightChild) {
vector<int> indeg(n);
for (int i = 0; i < n; ++i) {
if (leftChild[i] != -1) {
++indeg[leftChild[i]];
}
if (rightChild[i] != -1) {
++indeg[rightChild[i]];
}
}
int root = -1;
for (int i = 0; i < n; ++i) {
if (!indeg[i]) {
root = i;
break;
}
}
if (root == -1) {
return false;
}
unordered_set<int> seen;
queue<int> q;
seen.insert(root);
q.push(root);
while (!q.empty()) {
int u = q.front();
q.pop();
if (leftChild[u] != -1) {
if (seen.count(leftChild[u])) {
return false;
}
seen.insert(leftChild[u]);
q.push(leftChild[u]);
}
if (rightChild[u] != -1) {
if (seen.count(rightChild[u])) {
return false;
}
seen.insert(rightChild[u]);
q.push(rightChild[u]);
}
}
return seen.size() == n;
}
};
方法一:连通性判定的另一种写法(dfs)
先通过统计各个节点的入度数,排除不满足上述入度数判断的情况
再从root开始扫一遍(下面我用的是dfs)之后判断是否所有的节点都被访问过。
class Solution {
int[] leftChild, rightChild;
boolean[] visited;
public boolean validateBinaryTreeNodes(int n, int[] leftChild, int[] rightChild) {
// 统计每个结点的父亲数:1. 若父亲数大于1则为false 2.若父亲数等于0的不是1个则为false
int[] indegreeCnt = new int[n];
for (int i = 0; i < n; i++) {
if((leftChild[i] != -1 && ++indegreeCnt[leftChild[i]] > 1)
|| (rightChild[i] != -1 && ++indegreeCnt[rightChild[i]] > 1)) {
return false;
}
}
int root = -1;
for (int i = 0; i < n; i++){
if (indegreeCnt[i] == 0) {
if (root != -1) {
return false;
}
root = i;
}
}
// 上面的判断可以解决单个连通域的树判断、及部分多连通域情况
// 例如下面的情况无法判断,需要再判断连通域的个数。从root一遍dfs之后,若存在结点未被访问说明多个连通域。
// 1 <--- 0 <---> 2, 4 --->3
this.leftChild = leftChild;
this.rightChild = rightChild;
visited = new boolean[n];
dfs(root);
for (boolean v: visited) {
if (!v) {
return false;
}
}
return true;
}
private void dfs(int v) {
if (v == -1) {
return;
}
visited[v] = true;
dfs(leftChild[v]);
dfs(rightChild[v]);
}
}
方法二:并查集第一种写法
不需要先统计入度数和找root了,对孩子节点和父亲节点进行合并之前先判断一下:
该孩子节点是否已经有父亲了(不能有多个父亲);
该孩子节点与父亲节点是否已经在一个连通域中(不能有环)。
class Solution {
public boolean validateBinaryTreeNodes(int n, int[] leftChild, int[] rightChild) {
UnionFind uf = new UnionFind(n);
for (int i = 0; i < n; i++) {
// 若i节点的孩子节点之前已经有父亲了,则false
// 若i节点和孩子节点已经在同一个连通域里了,说明形成了环,则fasle
if (leftChild[i] != -1) {
if (uf.find(leftChild[i]) != leftChild[i] || uf.connected(i, leftChild[i])) {
return false;
}
//单连通,
uf.union(leftChild[i],i);
}
if (rightChild[i] != -1) {
if (uf.find(rightChild[i]) != rightChild[i] || uf.connected(i, rightChild[i])) {
return false;
}
//单连通
uf.union(rightChild[i],i);
}
}
// 最后判断一下连通域的数量
return uf.size == 1;
}
}
class UnionFind {
int roots[];
int size;
public UnionFind(int n) {
roots = new int[n];
size = n;
for (int i = 0; i < n; i++) {
roots[i] = i;
}
}
public int find(int i) {
return i == roots[i]? i: (roots[i] = find(roots[i]));
}
public boolean connected(int p, int q) {
return find(p) == find(q);
}
public void union(int p, int q) {
int pRoot = find(p);
int qRoot = find(q);
if(pRoot != qRoot) {
roots[pRoot] = qRoot;
size--;
}
}
}
方法二:并查集第二种写法(推荐)
public class Solution {
int[] p;
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
public boolean validateBinaryTreeNodes(int n, int[] leftChild, int[] rightChild) {
p = new int[n];
for (int i = 0; i < n; i++) p[i] = i;
for (int i = 0; i < n; i++) {
// i->leftChild[i]
int Left = leftChild[i];
if (Left != -1) {
int pa = find(i), pb = find(Left);
if (pa == pb) return false; // 两个结点祖先相同
else {
if (pb == Left)
p[pb] = pa;
else // 箭头指向的结点已经有别的结点指向了,如示例2:结点3
return false;
}
}
int Right = rightChild[i];
if (Right != -1) {
int pa = find(i), pb = find(Right);
if (pa == pb) return false;
else {
if (pb == Right)
p[pb] = pa;
else
return false;
}
}
}
// 统计连通块个数
int ans = 0;
for (int i = 0; i < n; i++) {
if (p[i] == i) ans++;
}
return ans == 1;
}
}