二叉树面试题汇总(一)

title: 二叉树面试题汇总(一)

categories: 数据结构

date: 2016-08-18 9:16:00

版权声明：本站采用开放的[知识共享署名-非商业性使用-相同方式共享 许可协议]进行许可

所有文章出现的代码，将会出现在我的github中，名字可以根据类全名来找，我在github中的文件夹也会加目录备注。

计算二叉树的总结点数

树的定义：

public class BinaryTree {
int value;
BinaryTree leftChild;
BinaryTree rightChild;

public BinaryTree(int value) {
super();
this.value = value;
}

public int getValue() {
return value;
}

public void setValue(int value) {
this.value = value;
}

public BinaryTree getLeftChild() {
return leftChild;
}

public void setLeftChild(BinaryTree leftChild) {
this.leftChild = leftChild;
}

public BinaryTree getRightChild() {
return rightChild;
}

public void setRightChild(BinaryTree rightChild) {
this.rightChild = rightChild;
}

}

递归法

思路：

判断传过来的根节点是否为空，若为空直接返回0

把左子树+右子树总数再加上根节点，就是该树的总结点数

那么左子节点总数和右子节点总数怎样使用递归方式求？

每次把递归到的节点的左节点总数+右节点总数+1，其中1是指当前根节点，这样每次递归得到的结果都是当前节点中子节点的总数+当前节点

代码实现:

public class CountNodes {

/**
* 使用递归统计树的节点总数
*
* @param root
* @return
*/
public static int getCount(BinaryTree root) {
// 判断根节点是否为空
if (root == null) {
// 为空返回0
return 0;
} else {
// 不为空，
// 递归调用 左子树+右子树
return getCount(root.getLeftChild())
+ getCount(root.getRightChild()) + 1;
}
}

图解:













测试代码:

public class BinaryTreeCountNodesTest {

public static void main(String[] args) {
BinaryTree n1 = new BinaryTree(1);
BinaryTree n2 = new BinaryTree(2);
BinaryTree n3 = new BinaryTree(3);
BinaryTree n4 = new BinaryTree(4);
BinaryTree n5 = new BinaryTree(5);
BinaryTree n6 = new BinaryTree(6);

n1.setLeftChild(n2);
n1.setRightChild(n3);
n2.setLeftChild(n4);
n2.setRightChild(n5);
n3.setRightChild(n6);

System.out.println(CountNodes.getCount(n1));
}
}

运行结果：

循环

思路:

通过把节点存入某个“容器”中实现，这里考虑到要存进去的节点立刻能用，所以考虑队列

判断根节点是否为空，为空返回0；否则存进队列中

定义一个变量count，来记录节点的总数

接下来就是循环判断队列是否为空了

若不为空，首先得到队首的节点，即把头节点出队。

判断头节点的左节点是否为空，不为空，count+1，并且把左节点加入队列

判断头节点的右节点是否为空，不为空，count+1，并且把右节点加入队列

最后返回count

代码实现:

public static int getCountByIteration(BinaryTree root) {
int count = 1;
if (root == null) {
return 0;
}
// 创建一个队列，先把传进来的root节点加到队列中
Queue<BinaryTree> binaryTrees = new LinkedList<BinaryTree>();
binaryTrees.add(root);
// 当队列不为空的时候循环
while (!binaryTrees.isEmpty()) {
// 把队头节点出列
BinaryTree currentNode = binaryTrees.remove();
// 判断有没有子节点，有就把子节点存入队列，并把count加一
if (currentNode.getLeftChild() != null) {
count++;
binaryTrees.add(currentNode.getLeftChild());
}
if (currentNode.getRightChild() != null) {
count++;
binaryTrees.add(currentNode.getRightChild());
}
}
// 返回总数
return count;
}

测试代码：

public class BinaryTreeCountNodesTest {

public static void main(String[] args) {
BinaryTree n1 = new BinaryTree(1);
BinaryTree n2 = new BinaryTree(2);
BinaryTree n3 = new BinaryTree(3);
BinaryTree n4 = new BinaryTree(4);
BinaryTree n5 = new BinaryTree(5);
BinaryTree n6 = new BinaryTree(6);

n1.setLeftChild(n2);
n1.setRightChild(n3);
n2.setLeftChild(n4);
n2.setRightChild(n5);
n3.setRightChild(n6);

System.out.println(CountNodes.getCountByIteration(n1));
}

}

运行结果:

计算二叉树的深度

递归

思路：

分别得到左右子节点的深度，取较大值+1 就是该二叉树的深度

其中每个节点都可能有左右子节点

代码实现：

public static int countDeepness(BinaryTree root) {
// 判断根节点是否为空
// 为空返回0
if (root == null)
return 0;
int left = countDeepness(root.getLeftChild());
int right = countDeepness(root.getRightChild());
// 返回左子节点和右子节点较大数+1，1指当前节点
return Math.max(left, right) + 1;

}

图解:



测试代码：

public class BinaryTreeCountNodesTest {

public static void main(String[] args) {
BinaryTree n1 = new BinaryTree(1);
BinaryTree n2 = new BinaryTree(2);
BinaryTree n3 = new BinaryTree(3);
BinaryTree n4 = new BinaryTree(4);
BinaryTree n5 = new BinaryTree(5);
BinaryTree n6 = new BinaryTree(6);

n1.setLeftChild(n2);
n1.setRightChild(n3);
n2.setLeftChild(n4);
n2.setRightChild(n5);
n3.setRightChild(n6);

System.out.println(CountTheDeepness.countDeepness(n1));
}

}

运行结果:

迭代

思路：

判断根节点是否为空

定义三个变量，分别为层数，当前层的节点数，下一层的节点数

当队列不为空时，得到当前节点，把当前层节点数-1，判断当前节点有无左右节点，有的话放到队列里，并且修改下一层节点数

当当前层节点数为0时，把深度+1，把当前层移到下一层

public static int countDeepnessByIteration(BinaryTree root) {
// 判断根节点是否为空
if (root == null)
// 为空返回0
return 0;
// 定义三个变量，分别为层数，当前层的节点数，下一层的节点数
int depth = 0, currentLevelNodes = 1, nextLevelNodes = 0;
// 使用队列来实现
Queue<BinaryTree> binaryTrees = new LinkedList<BinaryTree>();
binaryTrees.add(root);
// 当队列不为空时
while (!binaryTrees.isEmpty()) {

// 得到当前节点
BinaryTree currentNode = binaryTrees.remove();
// 把当前层节点数-1
currentLevelNodes--;
// 判断当前节点有无左右节点
if (currentNode.getLeftChild() != null) {
// 有的话放到队列里，并且修改下一层节点数
binaryTrees.add(currentNode.getLeftChild());
nextLevelNodes++;
}

if (currentNode.getRightChild() != null) {
binaryTrees.add(currentNode.getRightChild());
nextLevelNodes++;
}
// 当当前层节点数为0时
if (currentLevelNodes == 0) {
// 把深度+1
depth++;
// 把当前层移到下一层
currentLevelNodes = nextLevelNodes;
nextLevelNodes = 0;
}
}
return depth;
}

测试代码:

package com.xinpaninjava.btree;

public class BinaryTreeCountNodesTest {

public static void main(String[] args) {
BinaryTree n1 = new BinaryTree(1);
BinaryTree n2 = new BinaryTree(2);
BinaryTree n3 = new BinaryTree(3);
BinaryTree n4 = new BinaryTree(4);
BinaryTree n5 = new BinaryTree(5);
BinaryTree n6 = new BinaryTree(6);

n1.setLeftChild(n2);
n1.setRightChild(n3);
n2.setLeftChild(n4);
n2.setRightChild(n5);
n3.setRightChild(n6);

System.out.println("iteration:"+CountTheDeepness.countDeepnessByIteration(n1));
}

}

运行结果：



【全文完】