文章目录
前言
hello，大家好，我是阿旭啊。今天给大家带来数据结构第九篇：二叉树。希望能给大家一些小帮助~
一．树形结构
1.树的简介
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
有一个特殊的结点，称为根结点，根结点没有前驱结点。
除根结点外，其余结点被分成M(M > 0)个互不相交的集合T1、T2、…、Tm，其中每一个集合Ti (1 <= i <=m) 又是一棵与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。
树是递归定义的。
前面三个相交了，所以不是树。一个结点的前驱就是他的父节点。如：M的父节点是I，I的父节点是D。根节点是没有父节点的。
2.树的重要概念
结点的度：一个结点含有子树的个数称为该结点的度；如上图：A的度为6
树的度：一棵树中，所有结点度的最大值称为树的度；如上图：树的度为6
叶结点或终端结点或者外部结点或者树叶：度为0的结点称为叶结点；如上图：B、C、H、I…等节点为叶结点
双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点；如上图：A是B的父结点
孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点；如上图：B是A的孩子结点
根结点：一棵树中，没有双亲结点的结点；如上图：A
结点的层数：从根结点到某个结点的路径长度称为结点的层数。根节点为第0层，依次加1。
树的深度：树的最大层数。如上图深度为3。
树的高度：深度加一。
非终端结点或分支结点或内部结点：度不为0的结点；如上图：D、E、F、G…等节点为分支结点
兄弟结点：具有相同父结点的结点互称为兄弟结点；如上图：B、C是兄弟结点
堂兄弟结点：双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点
结点的祖先：从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先
子孙：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙
森林：由m（m>=0）棵互不相交的树组成的集合称为森林
要注意不同的书可能树的深度，高度，层数概念不一样，大家按需求来记。
3.树的表示形式
孩子兄弟表示法
4.树的应用
文件系统管理（目录和文件）
二．二叉树
1.概念
一棵二叉树是结点的一个有限集合，该集合：或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
从上图可以看出：二叉树不存在度大于2的结点，二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树。
二叉树有五种情况：
大自然中的二叉树。
2.三种特殊的二叉树
满二叉树：如果一颗二叉树的任何结点的度是0或者2，那么就叫做满二叉树。
完全二叉树：如果一颗二叉树最多只最下面的两层结点度数可以小于2，并且最下面一层的节点都集中在盖层最左边的连续位置上，则此二叉树称作完全二叉树。（除最后一层可能不满，其它层都满，且最后一层若是不满时都集中在最左侧。）
扩充二叉树：原二叉树的所有节点都是2度，如果不是就补齐。
圆圈为原来节点，正方形是扩充节点。
3.二叉树的性质
性质1：在二叉树中，第i层上最多有2i个结点（i>=0）。
性质2：深度为K的二叉树最多有2k+1-1个节点（k >=0）。
证明：20 +21+22+23+… …+2k = 2k+1-1
性质3：任何一棵二叉树，若其终端节点数为n0，度为2的节点数为n2，则n0 = n2 + 1。
性质4：满二叉树定理：非空满二叉树树叶数目等于其分支节点数加1。
性质5：满二叉树定理推论：一个非空二叉树的空子数目等于其结点数加1。
性质6：有n个结点(>0)的完全二叉树的高度为log2(n +1)向上取整,深度为log2(n +1)-1向上取整。
性质7：对于具有n 个结点的完全二叉树,结点按层次由左到右编号,则对任一结点i(0<i<n-1)有:
(1)如果i=0,则结点是二叉树的根结点;若i>0,则其父结点编号是(i-1)/2向上取整。
(2)当2i+1≤n-1 时,结点i的左子结点是 2i+1,否则结点i没有左子结点。
当2i+2≤n-1 时,结点i的右子结点是 2i+2,否则结点i没有右子结点。
(3)当i为偶数且0<i<n时,结点i的左兄弟是结点i-1否则结点i没有左兄弟。
当i为奇数且i+1<n时,结点的右兄弟是结点 i+1,否则结点i没有右兄弟。
4.练习
如果奇数个节点，那么2n = n0 + n2。
三.二叉树的实现
我们实现下面这棵二叉树
1.二叉树的储存
我们先使用链式储存进行实现。
二叉树的链式存储是通过一个一个的节点引用起来的，常见的表示方式有二叉和三叉表示方式，具体如下：
// 孩子表示法
class Node {
int val; // 数据域
Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
} / / 孩子双亲表示法
class Node {
int val; // 数据域
Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
Node parent; // 当前节点的根节点
}
孩子双亲表示法后序在平衡树位置介绍，本次我们采用孩子表示法来构建二叉树。
2.手动快速创建二叉树（并不是真正的创建方式）
我们以下图来创建二叉树：
在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。
二叉树中有节点，所以我们可以使用外部类嵌套内部类的方式进行创建。
public class BinaryTree {
static class TreeNode{
public char val;
public TreeNode left;
public TreeNode right;
public TreeNode(char val){
this.val = val;
}
}
public TreeNode createTree(){
TreeNode A = new TreeNode('A');
TreeNode B = new TreeNode('B');
TreeNode C = new TreeNode('C');
TreeNode D = new TreeNode('D');
TreeNode E = new TreeNode('E');
TreeNode F = new TreeNode('F');
TreeNode G = new TreeNode('G');
TreeNode H = new TreeNode('H');
A.left = B;
A.right = C;
B.left = D;
B.right = E;
C.left = F;
C.right = G;
E.right = H;
return A;
}
}
3.二叉树的遍历
学习二叉树结构，最简单的方式就是遍历。所谓遍历是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题(比如：打印节点内容、节点内容加1)。 遍历是二叉树上最重要的操作之一，是二叉树上进行其它运算之基础。
3.1前中后序遍历
都是从A开始，从A结束。我们使用递归来进行代码的实现。
（1）前序遍历：根—>根的左子树—>根的右子树。
遍历顺序：A（打印）-B（打印）-D（打印）-D的左空树-D-D的右空树-D-B-B的右空树-B-A-C（打印）-E（打印）-E的左空树-E-E的右空树-E-C-F（打印）-F的左空树-F-F的右空树-F-C-A（先左后右，遇空返回，根进根出去）。打印顺序：A-B-D-C-E-F(根—>根的左子树—>根的右子树)。
代码实现：
前序遍历打印顺序：根—>根的左子树—>根的右子树。当root为空时直接返回，当root不为空时，先打印出来root，然后以这个root的左子树为root再次执行函数。左子树完成后再以这个root的右子树为root再次执行函数最后返回。
下面是没有返回值和有返回值的两种方法的实现。
//前序遍历
public void preOrder(TreeNode root){
if (root == null) return;
System.out.print(root.val + " ");
preOrder(root.left);
preOrder(root.right);
}
public List<Character> preOrderTraversal(TreeNode root){
List<Character> list = new ArrayList<>();
if (root == null) return list;
list.add(root.val);
list.addAll(preOrderTraversal(root.left));
list.addAll(preOrderTraversal(root.right));
return list;
}
下面是非递归实现：
思路：我们需要一个栈来进行实现。因为不用递归所以我们必须给root一个替身cur来保证这个二叉树不会乱掉。
Stack<TreeNode> stack = new Stack<>();
TreeNode cur = root;
当cur不等于空的时候我们将cur压栈然后打印cur的val。因为是前序遍历，所以根打印完是左子树，所以将cur设成cur.left。直到cur循环为空，此时二叉树的最左子树遍历完成。
stack.push(cur);
System.out.print(cur.val + " ");
cur = cur.left;
}
遍历完成时候需要回溯到根节点。此时，我们可以将栈顶元素弹出，然后记录下来，将cur设成node.right。此时cur就开始遍历右树。我们会发现在遍历左子树的时候循环已经结束了，此时我们需要将所有的内容再放到一个循环中。当cur为空结束循环。
while (cur != null){
while (cur != null) {
stack.push(cur);
System.out.print(cur.val + " ");
cur = cur.left;
}
TreeNode node = stack.pop();
cur = node.right;
}
此时我们会发现一种情况：
D的右子树为空，按照循环条件直接跳出循环了，但是很显然并没有完成遍历。所以条件不对。我们会发现当右子树为空且栈为空时，遍历完成，所以条件要改：
while (cur != null || !stack.empty()){
while (cur != null) {
stack.push(cur);
System.out.print(cur.val + " ");
cur = cur.left;
}
TreeNode node = stack.pop();
cur = node.right;
}
以下是完整代码：
public void preOrder1(TreeNode root){
if (root == null) return;
Stack<TreeNode> stack = new Stack<>();
TreeNode cur = root;
while (cur != null || !stack.empty()){
while (cur != null) {
stack.push(cur);
System.out.print(cur.val + " ");
cur = cur.left;
}
TreeNode node = stack.pop();
cur = node.right;
}
System.out.println();
}
（2）中序遍历：根的左子树—>根—>根的右子树。
遍历顺序：A-B-D-D的左空树-D（打印）-D的右空树-D-B（打印）-B的右空树-B-A（打印）-C-E-E的左空树-E（打印）-E的右空树-E-C（打印）-F（打印）-F的左空树-F-F的右空树-F-C-A。打印顺序：D-B-A-E-C-F（根的左子树—>根—>根的右子树）。
代码实现：
中序遍历打印顺序：根的左子树—>根—>根的右子树。当root为空时直接返回，当root不为空时先以这个root的左子树为root再次执行函数。然后打印root。再以这个root的右子树为root再次执行函数最后返回。
下面是没有返回值和有返回值的两种方法的实现。
//中序遍历
public void inOrder(TreeNode root){
if (root == null) return;
inOrder(root.left);
System.out.print(root.val + " ");
inOrder(root.right);
}
public List<Character> inOrderTraversal(TreeNode root){
List<Character> list = new ArrayList<>();
if (root == null) return list;
list.addAll(inOrderTraversal(root.left));
list.add(root.val);
list.addAll(inOrderTraversal(root.right));
return list;
}
下面是非递归实现：
在前序遍历的非递归实现中，我们先进行cur的打印，此时cur为根节点，然后cur = cur.left再次进入循环打印左结点。中序遍历与前序遍历的不同就是先打印左子树，再打印根。所以我们可以先把左子树（A，B，D）全部放进栈中，然后当cur为空时跳出循环，此时栈顶元素为D，我们就可以直接打印D（对于B来说D是左节点。）。然后再将cur设置成D的右节点再次进入循环。
public void inOrder1(TreeNode root){
if (root == null) return;
Stack<TreeNode> stack = new Stack<>();
TreeNode cur = root;
while (cur != null || !stack.empty()){
while (cur != null) {
stack.push(cur);
cur = cur.left;
}
TreeNode node = stack.pop();
System.out.print(node.val + " ");
cur = node.right;
}
System.out.println();
}
（3）后序遍历：根的左子树—>根的右子树—>根。
遍历顺序：A-B-D-D的左空树-D-D的右空树-D（打印）-B-B的右空树-B（打印）-A-C-E-E的左空树-E-E的右空树-E（打印）-C-F-F的左空树-F-F的右空树-F（打印）-C（打印）-A（打印）。打印顺序：D-B-E-F-C-A（根的左子树—>根的右子树—>根）。
代码实现：
后序遍历打印顺序：根的左子树—>根的右子树—>根。当root为空时直接返回，当root不为空时先以这个root的左子树为root再次执行函数。左子树完成后再以这个root的右子树为root再次执行函数最后返回。然后打印root。
下面是没有返回值和有返回值的两种方法的实现。
//后序遍历
public void postOrder(TreeNode root){
if (root == null) return;
postOrder(root.left);
postOrder(root.right);
System.out.print(root.val + " ");
}
public List<Character> postOrderTraversal(TreeNode root){
List<Character> list = new ArrayList<>();
if (root == null) return list;
list.addAll(postOrderTraversal(root.left));
list.addAll(postOrderTraversal(root.right));
list.add(root.val);
return list;
}
下面是非递归实现：
后序遍历：左子树-根-右子树。所以还是先遍历左子树，归还于左子树的那一部分没有变：
while (cur != null || !stack.empty()){
while (cur != null) {
stack.push(cur);
cur = cur.left;
}
TreeNode node = stack.peek();
while (cur != null || !stack.empty()){
while (cur != null) {
stack.push(cur);
cur = cur.left;
}
此时我们要去想右子树。此时栈顶元素的左子树为空，我们要判断右子树是否为空，如果不会空那么我们将cur设置成cur.right再次进入循环，此时我们会发现这一过程中并没有任何的打印，所以我们就不能在这里弹出元素。但是我们需要获取栈顶元素，所以我们在这里使用peek方法。
while (cur != null || !stack.empty()){
while (cur != null) {
stack.push(cur);
cur = cur.left;
}
TreeNode node = stack.peek();
如果右子树为空，那么我们就可以打印根了。此时的node就是根。所以打印node的val。打印完直接弹出。
if (node.right == null){
System.out.print(node.val + " ");
stack.pop();
}else{
cur = node.right;
}
}
但是还有一个问题：
当node等于H时候。从判断H的右子树是否为空开始。H的右子树为空，打印H，弹出H，然后栈不会空再次进循环，node等于E，E的右子树为 H不为空，压栈。然后再次进入循环，node等于H…我们会发现死循环了，一直在打印H。所以我们要设置一个条件使得E的右节点H上次打印后就不要打印。我们可以新设置一个prev来保存上一次打印的内容，然后判断如果打印了那么就不要再让cur等于node的右子树，而是直接打印。
if (node.right == null || node.right == prev){
System.out.print(node.val + " ");
prev = node;
stack.pop();
}else{
cur = node.right;
}
完整代码：
public void postOrder1(TreeNode root){
if (root == null) return;
Stack<TreeNode> stack = new Stack<>();
TreeNode cur = root;
TreeNode prev = null;
while (cur != null || !stack.empty()){
while (cur != null) {
stack.push(cur);
cur = cur.left;
}
TreeNode node = stack.peek();
if (node.right == null || node.right == prev){
System.out.print(node.val + " ");
prev = node;
stack.pop();
}else{
cur = node.right;
}
}
System.out.println();
}
3.2层序遍历
除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为0，层序遍历就是从所在二叉树的根节点出发，首先访问第0层的树根节点，然后从左到右访问第1层上的节点，接着是第2层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。
要注意：根据前序遍历和后序遍历不能确定一个二叉树，因为前序遍历和后序遍历确定的都是根，只有中序遍历确定的才是左右子树。
代码实现：
我们可以定义一个队列，将A入队列，然后弹出队列顶元素并记录为node并打印A，然后将其左右节点（B，C）入队列。然后弹出队列顶元素并记录为node并打印A，然后将其左右节点（D，E）入队列。然后弹出队列顶元素并记录为node并打印C，然后将其左右节点（F，G）入队列…依次循环，直到队列为空完成遍历。要注意左右节点为空时不入队列。
代码：
public void levelOrder(TreeNode root){
Queue<TreeNode> queue = new LinkedList<>();
if (root != null) queue.offer(root);
while (!queue.isEmpty()){
TreeNode node = queue.poll();
System.out.print(node.val + " ");
if (node.left != null) queue.offer(node.left);
if (node.right != null) queue.offer(node.right);
}
}
4.获取树中节点个数
有两种方法：递归计数，子问题。
递归计数法：我们去遍历这棵数，每遇到一个root不为空计数器就加加。
//递归计数
public int usedSize;
public int size1(TreeNode root){
if (root == null) return 0;
usedSize++;
size1(root.left);
size1(root.right);
return usedSize;
}
子问题法：左子树节点个数加上右子树节点个数加一。
//子问题方法
public int size(TreeNode root){
if (root == null) return 0;
return size(root.left) + size(root.right) + 1;
5.获取叶子结点的个数
有两种方法：递归计数，子问题。
递归计数法：我们去遍历这棵树，每遇到一个root的左子树和右子树都为空计数器就加加。
public int leftNodeSize;
public int getLeafNodeCount(TreeNode root){
if (root == null) return 0;
if (root.right == null && root.left == null) leftNodeSize++;
getLeafNodeCount(root.left);
getLeafNodeCount(root.right);
return leftNodeSize;
}
子问题法：左子树叶子节点个数加上右子树叶子节点个数。
public int getLeafNodeCount1(TreeNode root){
if (root == null){
return 0;
}else if (root.right == null && root.left == null){
return 1;
}
return getLeafNodeCount1(root.left) + getLeafNodeCount1(root.right);
}
6.获取第k层节点的个数
思路：我们仍然使用递归的方法来进行解答。
如果我们求以A为根的第2层的节点个数，我们就是求A的左子树（以B为节点）的第1层节点个数加上A的右子树（以C为节点）的第1层节点个数…。当k等于0的时候，第0层只有一个结点。
//6.获取第k层节点的个数
public int getKLevelNodeCount(TreeNode root,int k){
if (root == null) return 0;
if (k == 0) return 1;
return getKLevelNodeCount(root.left, k - 1) + getKLevelNodeCount(root.right, k - 1);
}
7.获取二叉树的高度
思路：我们仍然使用递归的方法来进行解答。
求整棵树的高度，就是求左子树和右子树高度的最大值。当没有节点时候，就是高度为0：
//7.获取二叉树的高度
public int getHeight(TreeNode root){
if (root == null) return 0;
return Math.max(getHeight(root.left), getHeight(root.right)) + 1;
}
8.获取二叉树的深度
众所粥汁，二叉树的深度等于高度减一。
//8.获取二叉树的深度
public int getDepth(TreeNode root){
return getHeight(root) - 1;
}
9.检测值为value的元素是否存在
如果A节点的val不等于key值，那么我们去A的左子树中寻找，没有就去右子树中寻找。
//9.检测值为value的元素是否存在
public TreeNode find(TreeNode root, char value){
if (root == null) return null;
if (root.val == value) return root;
TreeNode left = find(root.left,value);
TreeNode right= find(root.right,value);
return left == null ? right : left;
}
10.判断是否为完全二叉树
思路：我们使用队列来完成这个方法。将A入队列，然后弹出队列顶元素并记录为node，然后将其左右节点（B，C）入队列。然后弹出队列顶元素并记录为node，然后将其左右节点（D，E）入队列。然后弹出队列顶元素并记录为node，然后将其左右节点（F，G）入队列…当栈顶元素为E的时候，弹出E，将其左右节点（null，H）入队列（要注意null也要入队列）。此时队列顶元素为null，我们退出循环。此时的队列中还有一个H没有弹出，说明这个二叉树不是完全二叉树，如果队列中全是null，那么这个二叉树是完全二叉树。
public boolean isCompleteTree(TreeNode root){
Queue<TreeNode> queue = new LinkedList<>();
if (root == null) return false;
queue.offer(root);
TreeNode node = queue.poll();
while ( node != null){
queue.offer(node.left);
queue.offer(node.right);
node = queue.poll();
}
while (!queue.isEmpty()){
if (node != null){
return false;
}
node = queue.poll();
}
return true;
}
完整代码：
public class BinaryTree {
static class TreeNode{
public char val;
public TreeNode left;
public TreeNode right;
public TreeNode(char val){
this.val = val;
}
}
public TreeNode createTree(){
TreeNode A = new TreeNode('A');
TreeNode B = new TreeNode('B');
TreeNode C = new TreeNode('C');
TreeNode D = new TreeNode('D');
TreeNode E = new TreeNode('E');
TreeNode F = new TreeNode('F');
TreeNode G = new TreeNode('G');
TreeNode H = new TreeNode('H');
A.left = B;
A.right = C;
B.left = D;
B.right = E;
C.left = F;
C.right = G;
E.right = H;
return A;
}
//1.前序遍历
//递归
public void preOrder(TreeNode root){
if (root == null) return;
System.out.print(root.val + " ");
preOrder(root.left);
preOrder(root.right);
}
public List<Character> preOrderTraversal(TreeNode root){
List<Character> list = new ArrayList<>();
if (root == null) return list;
list.add(root.val);
list.addAll(preOrderTraversal(root.left));
list.addAll(preOrderTraversal(root.right));
return list;
}
//非递归
public void preOrder1(TreeNode root){
if (root == null) return;
Stack<TreeNode> stack = new Stack<>();
TreeNode cur = root;
while (cur != null || !stack.empty()){
while (cur != null) {
stack.push(cur);
System.out.print(cur.val + " ");
cur = cur.left;
}
TreeNode node = stack.pop();
cur = node.right;
}
System.out.println();
}
//2.中序遍历
//递归
public void inOrder(TreeNode root){
if (root == null) return;
inOrder(root.left);
System.out.print(root.val + " ");
inOrder(root.right);
}
public List<Character> inOrderTraversal(TreeNode root){
List<Character> list = new ArrayList<>();
if (root == null) return list;
list.addAll(inOrderTraversal(root.left));
list.add(root.val);
list.addAll(inOrderTraversal(root.right));
return list;
}
//非递归
public void inOrder1(TreeNode root){
if (root == null) return;
Stack<TreeNode> stack = new Stack<>();
TreeNode cur = root;
while (cur != null || !stack.empty()){
while (cur != null) {
stack.push(cur);
cur = cur.left;
}
TreeNode node = stack.pop();
System.out.print(node.val + " ");
cur = node.right;
}
System.out.println();
}
//3.后序遍历
//递归
public void postOrder(TreeNode root){
if (root == null) return;
postOrder(root.left);
postOrder(root.right);
System.out.print(root.val + " ");
}
public List<Character> postOrderTraversal(TreeNode root){
List<Character> list = new ArrayList<>();
if (root == null) return list;
list.addAll(postOrderTraversal(root.left));
list.addAll(postOrderTraversal(root.right));
list.add(root.val);
return list;
}
//非递归
public void postOrder1(TreeNode root){
if (root == null) return;
Stack<TreeNode> stack = new Stack<>();
TreeNode cur = root;
TreeNode prev = null;
while (cur != null || !stack.empty()){
while (cur != null) {
stack.push(cur);
cur = cur.left;
}
TreeNode node = stack.peek();
if (node.right == null || node.right == prev){
System.out.print(node.val + " ");
prev = node;
stack.pop();
}else{
cur = node.right;
}
}
System.out.println();
}
//4.获取树的节点个数
//子问题方法
public int size(TreeNode root){
if (root == null) return 0;
return size(root.left) + size(root.right) + 1;
}
//递归计数
private int usedSize;
public int size1(TreeNode root){
if (root == null) return 0;
usedSize++;
size1(root.left);
size1(root.right);
return usedSize;
}
//5.获取叶子结点的个数
//遍历树，当root左边和右边都是空的时候，就是叶子。
private int leftNodeSize;
public int getLeafNodeCount(TreeNode root){
if (root == null) return 0;
if (root.right == null && root.left == null) leftNodeSize++;
getLeafNodeCount(root.left);
getLeafNodeCount(root.right);
return leftNodeSize;
}
//子问题
public int getLeafNodeCount1(TreeNode root){
if (root == null){
return 0;
}else if (root.right == null && root.left == null){
return 1;
}
return getLeafNodeCount1(root.left) + getLeafNodeCount1(root.right);
}
//6.获取第k层节点的个数
public int getKLevelNodeCount(TreeNode root,int k){
if (root == null) return 0;
if (k == 0) return 1;
return getKLevelNodeCount(root.left, k - 1) + getKLevelNodeCount(root.right, k - 1);
}
//7.获取二叉树的高度
public int getHeight(TreeNode root){
if (root == null) return 0;
return Math.max(getHeight(root.left), getHeight(root.right)) + 1;
}
//8.获取二叉树的深度
public int getDepth(TreeNode root){
return getHeight(root) - 1;
}
//9.检测值为value的元素是否存在
public TreeNode find(TreeNode root, char value){
if (root == null) return null;
if (root.val == value) return root;
TreeNode left = find(root.left,value);
TreeNode right= find(root.right,value);
return left == null ? right : left;
}
//10.层序遍历
public void levelOrder(TreeNode root){
Queue<TreeNode> queue = new LinkedList<>();
if (root != null) queue.offer(root);
while (!queue.isEmpty()){
TreeNode node = queue.poll();
System.out.print(node.val + " ");
if (node.left != null) queue.offer(node.left);
if (node.right != null) queue.offer(node.right);
}
}
public List<List<Character>> levelOrder1(TreeNode root) {
Queue<TreeNode> queue = new LinkedList<>();
List<List<Character>> listAll = new ArrayList<>();
if (root == null) return listAll;
queue.offer(root);
while (!queue.isEmpty()){
int count = queue.size();
List<Character> list = new ArrayList<>();
for (int i = 0; i < count; i++){
TreeNode node = queue.poll();
list.add(node.val);
if (node.left != null) queue.offer(node.left);
if (node.right != null) queue.offer(node.right);
}
listAll.add(list);
}
return listAll;
}
//11.判断是否为完全二叉树
public boolean isCompleteTree(TreeNode root){
Queue<TreeNode> queue = new LinkedList<>();
if (root == null) return false;
queue.offer(root);
TreeNode node = queue.poll();
while ( node != null){
queue.offer(node.left);
queue.offer(node.right);
node = queue.poll();
}
while (!queue.isEmpty()){
if (node != null){
return false;
}
node = queue.poll();
}
return true;
}
}
测试代码：
public static void main(String[] args) {
BinaryTree binaryTree = new BinaryTree();
BinaryTree.TreeNode root = binaryTree.createTree();
System.out.println("1.============================");
binaryTree.preOrder(root);
System.out.println();
binaryTree.inOrder(root);
System.out.println();
binaryTree.postOrder(root);
System.out.println();
binaryTree.levelOrder(root);
System.out.println();
System.out.println("2.============================");
binaryTree.preOrder1(root);
binaryTree.inOrder1(root);
binaryTree.postOrder1(root);
System.out.println("3.============================");
System.out.println(binaryTree.preOrderTraversal(root));
System.out.println(binaryTree.inOrderTraversal(root));
System.out.println(binaryTree.postOrderTraversal(root));
List<List<Character>> list = binaryTree.levelOrder1(root);
System.out.println(list);
System.out.println("4.============================");
System.out.println(binaryTree.size(root));
System.out.println(binaryTree.size1(root));
System.out.println("5.============================");
System.out.println(binaryTree.getLeafNodeCount(root));
System.out.println(binaryTree.getLeafNodeCount1(root));
System.out.println("6.============================");
System.out.println(binaryTree.getKLevelNodeCount(root, 0));
System.out.println("7.============================");
System.out.println(binaryTree.getHeight(root));
System.out.println(binaryTree.getDepth(root));
System.out.println("8.============================");
System.out.println(binaryTree.isCompleteTree(root));
System.out.println("9.============================");
}
运行结果：
1.============================
A B D E H C F G
D B E H A F C G
D H E B F G C A
A B C D E F G H
2.============================
A B D E H C F G
D B E H A F C G
D H E B F G C A
3.============================
[A, B, D, E, H, C, F, G]
[D, B, E, H, A, F, C, G]
[D, H, E, B, F, G, C, A]
[[A], [B, C], [D, E, F, G], [H]]
4.============================
8
8
5.============================
4
4
6.============================
1
7.============================
4
3
8.============================
false
9.============================
总结
好啦~本篇文章就到此结束。希望能够帮到大家，也希望大家能够多多点赞，多多评论，多多批评，大家下一篇再见!!!
（这一篇绝对是我写的最多的一篇了！）
3307
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
