483，完全二叉树的节点个数

Posted 2021-04-09 数据结构和算法

You got to put the past behind before you can move on. 

只有忘记过去，才能继续前行。

问题描述

给出一个完全二叉树，求出该树的节点个数。

说明：

完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^h 个节点。

示例:

输入:  1 /  2 3 /  /4 5 6
输出: 6

DFS解决

这题是让求完全二叉树的节点个数，最简单的一种方式就是使用DFS，也就是递归解决。如果当前节点为空，直接返回0即可，否则就返回左子节点的个数+右子节点的个数+1。原理比较简单，直接一行代码搞定

1public int countNodes(TreeNode root) {
2    return root == null ? 0 : countNodes(root.left) + countNodes(root.right) + 1;
3}

BFS解决

之前讲过二叉树的几种遍历方式，有前序遍历，中序遍历，后序遍历，BFS，DFS，每种写法都包含递归和非递归，我们只需要把所有的节点都遍历一遍就可以统计出来了，如果每个都写一遍，有点多了，这里就使用BFS来写一个，二叉树的BFS代码如下。

 1public void levelOrder(TreeNode tree) {
 2    if (tree == null)
 3        return;
 4    Queue<TreeNode> queue = new LinkedList<>();
 5    queue.add(tree);
 6    while (!queue.isEmpty()) {
 7        //poll方法相当于移除队列头部的元素
 8        TreeNode node = queue.poll();
 9        System.out.println(node.val);
10        //如果左子节点不为空就把他加入到队列中
11        if (node.left != null)
12            queue.add(node.left);
13        //如果右子节点不为空也把他加入到队列中
14        if (node.right != null)
15            queue.add(node.right);
16    }
17}

我们来对它进行改造一下，统计节点的个数

 1public int countNodes(TreeNode root) {
 2    if (root == null)
 3        return 0;
 4    int count = 0;
 5    Queue<TreeNode> queue = new LinkedList<>();
 6    queue.add(root);
 7    while (!queue.isEmpty()) {
 8        //poll方法相当于移除队列头部的元素
 9        TreeNode node = queue.poll();
10        count++;//统计节点的个数
11        if (node.left != null)
12            queue.add(node.left);
13        if (node.right != null)
14            queue.add(node.right);
15    }
16    return count;
17}

从左子树找树的高度

题中对完全二叉树的描述已经很清晰了，如果我们还是用上面的两种方式一个个遍历的话，效果明显不是很好，可以考虑下面这种方式

先计算树的高度height，然后计算右子树的高度

1，如果右子树的高度等于height-1，说明左子树是满二叉树（如下图所示），可以通过公式(2^(height-1))-1计算即可，不需要全部遍历，然后再通过递归的方式计算右子树……，

2，如果右子树的高度不等于height-1，说明右子树是满二叉树（如下图所示），只不过比上面那种少了一层，也就是height-2，也可以通过公式(2^(height-2))-1计算，然后再通过递归的方式计算左子树……，

搞懂了上面的原理，代码就简单多了

 1public int countNodes(TreeNode root) {
 2    //计算树的高度，
 3    int height = treeHeight(root);
 4    //如果树是空的，或者高度是1，直接返回
 5    if (height == 0 || height == 1)
 6        return height;
 7    //如果右子树的高度是树的高度减1，说明左子树是满二叉树，
 8    //左子树可以通过公式计算，只需要递归右子树就行了
 9    if (treeHeight(root.right) == height - 1) {
10        //注意这里的计算，左子树的数量是实际上是(1 << (height - 1))-1，
11        //不要把根节点给忘了，在加上1就是(1 << (height - 1))
12        return (1 << (height - 1)) + countNodes(root.right);
13    } else {
14        //如果右子树的高度不是树的高度减1，说明右子树是满二叉树，可以通过
15        //公式计算右子树，只需要递归左子树就行了
16        return (1 << (height - 2)) + countNodes(root.left);
17    }
18}
19
20//计算树的高度
21private int treeHeight(TreeNode root) {
22    return root == null ? 0 : 1 + treeHeight(root.left);
23}

或者我们还可以把它改为非递归的

 1public int countNodes(TreeNode root) {
 2    int count = 0, height = treeHeight(root);
 3    while (root != null) {
 4        //如果右子树的高度是树的高度减1，那么左子树就是满二叉树
 5        if (treeHeight(root.right) == height - 1) {//左子树是满二叉树
 6            count += 1 << height - 1;
 7            root = root.right;
 8        } else {//右子树是满二叉树
 9            count += 1 << height - 2;
10            root = root.left;
11        }
12        height--;
13    }
14    return count;
15}
16
17//计算树的高度
18private int treeHeight(TreeNode root) {
19    return root == null ? 0 : 1 + treeHeight(root.left);
20}

从右子树找树的高度

上面是先计算二叉树的高度，它是从左子节点一直往下走，找到树的高度。还可以换种思路从树的右子节点往下走，找到树的高度，原理都差不多，代码中有详细注释，就不在过多介绍

 1public int countNodes(TreeNode root) {
 2    if (root == null)
 3        return 0;
 4    //计算高度，注意这里不是树的实际高度
 5    int height = treeHeight(root);
 6    if (treeHeight(root.left) == height) {//左子树是满二叉树，通过公式计算
 7        return (1 << height) + countNodes(root.right);
 8    } else {//右子树是满二叉树，通过公式计算
 9        return (1 << height - 1) + countNodes(root.left);
10    }
11}
12
13//计算树的高度，注意这个结果不是树的实际高度，如果树是满二叉树，他就是树的
14//高度，如果不是满二叉树，他就是树的高度减1
15private int treeHeight(TreeNode root) {
16    return root == null ? 0 : 1 + treeHeight(root.right);//注意这里遍历的是树的右结点
17}

总结

二叉树的遍历方式除了之前讲中的前序，中序，后续，以及BFS以外，还有莫里斯的前中后3种遍历方式。这些遍历方式有的还包含递归以及非递归等多种写法，如果都写一遍的话答案就非常多了。但这里说的是完全二叉树，我们可以根据完全二叉树的特性来计算，没必要把所有的节点都要遍历一遍。

二叉树常见的几种遍历方式（包括前序，中序，后序，DFS，BFS）在第373题都有过介绍，并且都有递归和非递归等多种实现方式。关于二叉树的莫里斯（Morris）的3种遍历方式后面有时间也会做介绍，期待大家一块学习。

●

●

●

●

长按上图，识别图中二维码之后即可关注。

如果觉得有用就点个"赞"吧