数据结构与算法学习十六：树的知识、二叉树、二叉树的遍历(前序、中序、后序、层次)、二叉树的查找(前序、中序、后序、层次)、二叉树的删除
文章目录
- 一、树的介绍
- 1.1 为什么需要树这种数据结构
- 1.1.1 数组存储方式的分析
- 1.1.2 链式存储方式的分析
- 1.1.3 树存储方式的分析
- 1.2 基本介绍
- 1.3 树的常用语
- 二、二叉树定义
- 三、二叉树的操作
- 3.1 二叉树遍历说明
- 3.2 实例
- 3.3 二叉树遍历
- 3.3.1 HeroNode.java 结点
- 3.3.2 BinaryTree.java 二叉树
- 3.3.3 T1_BinaryTreeMain.java 测试类
- 3.3.4 测试结果
- 3.4 二叉树的查找
- 3.4.1 HeroNode.java 节点类
- 3.4.2 BinaryTree.java 二叉树
- 3.4.3 T1_BinaryTreeMain.java 测试类
- 3.4.4 测试结果
- 3.5 二叉树的删除
- 3.4.1 HeroNode.java 节点类
- 3.5.2 BinaryTree.java 二叉树
- 3.5.3 T1_BinaryTreeMain.java 测试类
- 3.5.4 测试结果
一、树的介绍
1.1 为什么需要树这种数据结构
1.1.1 数组存储方式的分析
优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。检索、修改速度快。
缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低 [示意图]
画出操作示意图：
1.1.2 链式存储方式的分析
优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可， 删除效率也很好)。删除、添加快。
缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历)
画出操作示意图：
1.1.3 树存储方式的分析
能提高数据存储，读取的效率, 比如利用 二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度。【示意图，后面详细讲】
案例：[7, 3, 10, 1, 5, 9, 12]
1.2 基本介绍
这个的介绍是从百度上拿来的，定义比较简单。
树状图是一种数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
特点：
每个结点有零个或多个子结点；没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树
1.3 树的常用语
-
树示意图
-
树的常用术语(结合示意图理解):
1、节点
2、根节点
3、父节点
4、子节点
5、叶子节点 (没有子节点的节点)
6、节点的权(节点值)
7、路径(从root节点找到该节点的路线)
8、层
9、子树
10、树的高度(最大层数)
11、森林 :多颗子树构成森林
二、二叉树定义
-
树有很多种，每个节点最多只能有两个子节点的一种形式称为
二叉树。 -
二叉树的子节点分为
左节点和右节点。 -
示意图
-
如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为
满二叉树。
-
如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为
完全二叉树。
三、二叉树的操作
3.1 二叉树遍历说明
二叉树的遍历，分为 前序遍历、中序遍历、层次遍历。
- 前序遍历: 先输出父节点，再遍历左子树和右子树
- 中序遍历: 先遍历左子树，再输出父节点，再遍历右子树
- 后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点
- 层次遍历：先输出根结点，然后分层次的进行遍历。
小结: 看输出父节点的顺序，就确定是前序，中序还是后序
3.2 实例
和以往一样，对水浒传英雄进行构建二叉树。
创建8个节点，分别为1 2 3 4 5 6 7 8 。
开始是7个节点，然后后来测试添加，便在6节点左子树挂载 8 结点。
我绘制一下8个节点的二叉树
我们手动遍历一把，然后在与下面代码的输出进行对比。
前序遍历：1 2 4 5 3 6 8 7
中序遍历：4 2 5 1 8 6 3 7
后序遍历：4 5 2 8 6 7 3 1
层次遍历：1 2 3 4 5 6 7 8
事实证明，与下面代码输出一致。
3.3 二叉树遍历
思路分析：
图中文字：
分析二叉树的前序、中序、后序的遍历步骤
-
创建一颗二叉树
-
前序遍历
2.1先输出当前节点（初始的时候是root节点）
2.2 如果左子节点不为空，则递归继续前序遍历
2.3 如果右子节点不为空，则递归继续前序遍历 -
中序遍历
3.1 如果当前节点的右子节点不为空，则递归中序遍历，
3.2 输出当前节点
3.3 如果当前节点的右子节点不为空，则递归中序遍历 -
后序遍历
4.1 如果当前节点的左子节点不为空，则递归后序遍历，
4.2 如果当前节点的右子节点不为空，则递归后序遍历
4.3 输出当前节点
3.3.1 HeroNode.java 结点
这个类为 节点类。对英雄构建成结点实体类。
在这里面编写 前序、中序、后序遍历的底层方法。注释比较清晰。
package com.feng.ch12_tree.t1_binarytree;
/*
* 创建 HeroNode 结点
*
* 1、数据域 包含 编号 和 姓名
* 2、指针域包括 左子结点 和 右子结点
* */
public class HeroNode {
private int no;
private String name;
private HeroNode left;
private HeroNode right;
public HeroNode(int no, String name) {
this.no = no;
this.name = name;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
'}';
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public HeroNode getLeft() {
return left;
}
public void setLeft(HeroNode left) {
this.left = left;
}
public HeroNode getRight() {
return right;
}
public void setRight(HeroNode right) {
this.right = right;
}
// 编写前序遍历的方法
public void preOrder() {
System.out.println(this);// 先输出父结点
// 递归向左子树前序遍历
if (this.left != null) {
this.left.preOrder();
}
// 递归向右子树前序遍历
if (this.right != null) {
this.right.preOrder();
}
}
// 中序遍历
public void infixOrder() {
// 递归向左子树中序遍历
if (this.left != null) {
this.left.infixOrder();
}
// 输出父结点
System.out.println(this);
// 递归向右子树中序遍历
if (this.right != null) {
this.right.infixOrder();
}
}
// 后序遍历
public void postOrder() {
// 递归向遍历
if (this.left != null) {
this.left.postOrder();
}
// 递归向右子树中序遍历
if (this.right != null) {
this.right.postOrder();
}
// 输出父结点
System.out.println(this);
}
}
3.3.2 BinaryTree.java 二叉树
创建的二叉树，在这里 调用 HeroNode 结点类的 方法，实现二叉树的各种操作，前序、中序、后序的操作。
package com.feng.ch12_tree.t1_binarytree;
import java.util.LinkedList;
/*
* 定义BinaryTree 二叉树
* */
class BinaryTree {
private HeroNode root;
public void setRoot(HeroNode root) {
this.root = root;
}
// 前序遍历
public void preOrder() {
if (this.root != null) {
this.root.preOrder();
} else {
System.out.println("二叉树为空，无法遍历");
}
}
// 中序遍历
public void infixOrder() {
if (this.root != null) {
this.root.infixOrder();
} else {
System.out.println("二叉树为空，无法遍历");
}
}
// 后序遍历
public void postOrder() {
if (this.root != null) {
this.root.postOrder();
} else {
System.out.println("二叉树为空，无法遍历");
}
}
/*
* 层次遍历
* */
public void middleOrder() {
if (this.root != null) {
LinkedList<HeroNode> queue = new LinkedList();
queue.add(root);
HeroNode current = null;
while (!queue.isEmpty()) {
current = queue.poll();//出队队头元素并访问
System.out.println(current);
if (current.getLeft() != null) {//如果当前节点的左节点不为空入队
queue.offer(current.getLeft());
}
if (current.getRight() != null) {//如果当前节点的右节点不为空，把右节点入队
queue.offer(current.getRight());
}
}
} else {
System.out.println("二叉树为空，无法遍历");
}
}
}
3.3.3 T1_BinaryTreeMain.java 测试类
测试类，对前序中序后序，进行测试。打印输出，
构建二叉树时，是手动添加。这里主要测试二叉树的前序、中序、后序的遍历
public class T1_BinaryTreeMain {
public static void main(String[] args) {
// 先需要创建一颗二叉树
BinaryTree binaryTree = new BinaryTree();
// 创建需要的节点
HeroNode root = new HeroNode(1, "宋江");
HeroNode node2 = new HeroNode(2, "吴用");
HeroNode node3 = new HeroNode(3, "卢俊义");
HeroNode node4 = new HeroNode(4, "林冲");
HeroNode node5 = new HeroNode(5, "武松");
HeroNode node6 = new HeroNode(6, "武大郎");
HeroNode node7 = new HeroNode(7, "李逵");
/*
* 说明，我们先手动创建该二叉树，后面我们学习递归的方式创建二叉树
* */
binaryTree.setRoot(root);
root.setLeft(node2);
root.setRight(node3);
node2.setLeft(node4);
node2.setRight(node5);
node3.setLeft(node6);
node3.setRight(node7);
/*
* 测试 二叉树 的遍历
* */
System.out.println("前序遍历："); // 输出 1 2 4 5 3 6 7
binaryTree.preOrder();
System.out.println();
System.out.println("中序遍历："); // 输出 4 2 5 1 6 3 7
binaryTree.infixOrder();
System.out.println();
System.out.println("后序遍历："); // 输出 4 5 2 6 7 3 1
binaryTree.postOrder();
System.out.println();
System.out.println("层次遍历："); // 输出 1 2 3 4 5 6 7
binaryTree.middleOrder();
System.out.println();
/*
* 新添加一个节点
* */
HeroNode node8 = new HeroNode(8, "关胜");
node6.setLeft(node8);
/*
* 测试 新增加结点 后的遍历
* */
System.out.println("添加新节点后的 前序遍历："); // 输出 1 2 3 5 4
binaryTree.preOrder();
System.out.println();
System.out.println("添加新节点后的 中序遍历："); // 输出 2 1 5 3 4
binaryTree.infixOrder();
System.out.println();
System.out.println("添加新节点后的 后序遍历："); // 输出 2 5 4 3 1
binaryTree.postOrder();
System.out.println();
System.out.println("添加新节点后的 层次遍历："); // 输出 2 5 4 3 1
binaryTree.middleOrder();
System.out.println();
}
}
3.3.4 测试结果
这里截图的为测试中添加节点后的遍历：
3.4 二叉树的查找
- 要求
- 请编写前序查找，中序查找和后序查找的方法。
- 并分别使用 三种查找方式 ，查找 heroNO = 5 的节点
- 并分析各种查找方式，分别比较了多少次
-
二叉树的查找也分为前序查找、中序查找、后序查找。
层次查找直接在二叉树类 BinaryTree.java 中编写。 -
思路分析图解
图中文字如下：
使用前序，中序，后序的方式来查询指定的结点
前序查找思路
- 先判断当前节点的 no 是否等于要查找的no
- 如果是相等，则返回当前结点
- 如果不等，则判断当前结点的左子节点是否为空，如果不为空，则递归前序查找
- 如果左递归前序查找，找到节点，则返回，否则继续判断 当前节点的右子节点是否为空，如果不为空，则继续向右递归前序查找。
中序查找思路
- 判断当前节点的左子结点是否为空，如果不为空，则递归中序查找
- 如果找到，则返回，如果没有找到，就和当前结点比较，如果是则返回当前结点，否则继续进行右递归中序查找
- 如果右递归中序查找，找到就返回，否则返回null
后序查找思路
- 判断当前节点的左子结点是否为空，如果不为空，则递归后序查找
- 如果找到，则返回，如果没有找到，就判断当前节点的右子节点是否为空，如果不为空，则有递归进行后续查找，如果找到，就返回
- 如果左右节点都没有找到，就和当前节点进行比较，如果是则返回，否则返回 null
3.4.1 HeroNode.java 节点类
在这里进行编写底层查找的方法。
包括前序查找、中序查找、后序查找
/*
*前序遍历查找
* @param no 查找 no
* @return 如果找到就返回该 Node，如果没有找到就返回 null
* */
public HeroNode preOrderSearch(int no) {
System.out.println("进入前序遍历查找~~");
// 比较当前节点是不是
if (this.no == no) {
return this;
}
/*
* 1、则判断当前结点的左子节点是否为空，如果不为空，则递归前序查找
* 2、如果左递归前序查找，找到节点，则返回
* */
HeroNode resNode = null;
if (this.left != null) {
resNode = this.left.preOrderSearch(no);
}
if (resNode != null) {
return resNode;
}
// 1、左递归前序查找，找到节点，则返回，否则继续判断
// 2、当前节点的右子节点是否为空，如果不为空，则继续向右递归前序查找。
if (this.right != null) {
resNode = this.right.preOrderSearch(no);
}
return resNode;
}
/*
* 中序遍历查找
* */
public HeroNode infixOrderSearch(int no) {
//1、判断当前节点的左子结点是否为空，如果不为空，则递归中序查找
HeroNode resNode = null;
if (this.left != null) {
resNode = this.left.infixOrderSearch(no);
}
if (resNode != null) {
return resNode;
}
System.out.println("进入中序遍历查找~~");
// 2、如果找到，则返回，如果没有找到，就和当前结点比较，如果是则返回当前结点，
if (this.no == no) {
return this;
}
// 3、否则继续进行右递归中序查找
if (this.right != null) {
resNode = this.right.infixOrderSearch(no);
}
return resNode;
}
/*
* 后序遍历查找
* */
public HeroNode postOrderSearch(int no) {
//1、判断当前节点的左子结点是否为空，如果不为空，则递归后序查找,如果找到，则返回，
HeroNode resNode = null;
if (this.left != null) {
resNode = this.left.postOrderSearch(no);
}
if (resNode != null) {
return resNode;
}
// 2、如果没有找到，就判断当前节点的右子节点是否为空，如果不为空，则有递归进行后续查找，如果找到，就返回
if (this.right != null) {
resNode = this.right.postOrderSearch(no);
}
if (resNode != null) {
return resNode;
}
System.out.println("进入后序遍历查找");
// 3、如果左右节点都没有找到，就和当前节点进行比较，如果是则返回，否则返回 null
if (this.no == no) {
return this;
}
return resNode;
}
3.4.2 BinaryTree.java 二叉树
这里是二叉树类，对 结点类中进行包装。
/*
* 前序遍历查找
* */
public HeroNode preOrderSearch(int no) {
if (root != null) {
return root.preOrderSearch(no);
} else {
return null;
}
}
/*
* 中序遍历查找
* */
public HeroNode infixOrderSearch(int no) {
if (root != null) {
return root.infixOrderSearch(no);
} else {
return null;
}
}
/*
* 后序遍历查找
* */
public HeroNode postOrderSearch(int no) {
if (root != null) {
return root.postOrderSearch(no);
} else {
return null;
}
}
/*
* 层次遍历查找
* */
public HeroNode middleOrderSearch(int no) {
if (root != null) {
LinkedList<HeroNode> queue = new LinkedList();
queue.add(root);
HeroNode current = null;
HeroNode result = null;
while (!queue.isEmpty()) {
current = queue.poll();//出队队头元素并访问
if (no == current.getNo()){
result = current;
break;
}
if (current.getLeft() != null) {//如果当前节点的左节点不为空入队
queue.offer(current.getLeft());
}
if (current.getRight() != null) {//如果当前节点的右节点不为空，把右节点入队
queue.offer(current.getRight());
}
}
return result;
} else {
return null;
}
}
3.4.3 T1_BinaryTreeMain.java 测试类
在上面的测试类，后面写
/*
* 测试二叉树的 查找
* */
// 递归4次
System.out.println("二叉树的 前序遍历查找");
HeroNode heroNode = binaryTree.preOrderSearch(5);
if (null == heroNode) {
System.out.printf("没有找到 no = %d 的英雄", 5);
} else {
System.out.printf("找到了， 信息为 no= %d name=%s \n", heroNode.getNo(), heroNode.getName());
}
System.out.println();
// 递归 3次
System.out.println("二叉树的 中序遍历查找");
HeroNode heroNode1 = binaryTree.infixOrderSearch(5);
if (null == heroNode1) {
System.out.printf("没有找到 no = %d 的英雄", 5);
} else {
System.out.printf("找到了， 信息为 no= %d name=%s \n", heroNode1.getNo(), heroNode1.getName());
}
System.out.println();
// 递归 2次
System.out.println("二叉树的 后序遍历查找");
HeroNode heroNode2 = binaryTree.postOrderSearch(5);
if (null == heroNode2) {
System.out.printf("没有找到 no = %d 的英雄\n", 5);
} else {
System.out.printf("找到了， 信息为 no= %d name=%s \n", heroNode2.getNo(), heroNode2.getName());
}
System.out.println();
System.out.println("二叉树的 层次遍历查找");
HeroNode heroNode3 = binaryTree.middleOrderSearch(4);
if (null == heroNode3) {
System.out.printf("没有找到 no = %d 的英雄\n", 5);
} else {
System.out.printf("找到了， 信息为 no= %d name=%s \n", heroNode3.getNo(), heroNode3.getName());
}
System.out.println();
3.4.4 测试结果
3.5 二叉树的删除
- 要求
- 如果删除的节点是叶子节点，则删除该节点
- 如果删除的节点是非叶子节点，则删除该子树.
- 测试，删除掉 5号叶子节点 和 3号子树.
- 完成删除思路分析：
图中文字：
完成删除结点的操作
规定：
1、如果删除的结点是叶子节点，则删除该节点
2、如果删除的结点是非叶子节点，则删除该子树
思路：
首先先处理：考虑如果树是空树root，如果只有一个root结点，则等价将二叉树置空。
然后进行下面步骤
1、因为我们的二叉树是单向的，所以我们是判断当前节点的子节点是否需要删除节点，而不能取判断当前这个结点是不是需要删除结点。
2、如果当前节点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null即可；并且就返回(结束递归删除)
3、如果当前结点的右子节点不为空，并且左子结点就是要删除结点，就将this.right = null即可；并且就返回(结束递归删除)
4、如果第2步和第3步没有删除结点，那么我们就需要向左子树进行递归删除
5、如果第4步也没有删除结点，则应当向右子树进行递归删除。
3.4.1 HeroNode.java 节点类
删除结点时，需要考虑两种情况。
第一种：如果删除的结点是叶子节点，则删除该叶子节点
第二种：如果删除的结点是非叶子节点，则删除该子树
/*
* 递归删除结点
* 1、如果删除的结点是叶子节点，则删除该叶子节点
* 2、如果删除的结点是非叶子节点，则删除该子树
* 首先先处理：考虑如果树是空树root，如果只有一个root结点，则等价将二叉树置空。 这一部分放在上一层处理
* */
public void deleteNode(int no) {
// 第二第三步 为递归的 结束条件
/*
* 1、因为我们的二叉树是单向的，所以我们是判断当前节点的子节点是否需要删除节点，而不能取判断当前这个结点是不是需要删除结点。
* 2、如果当前节点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null 即可；并且就返回(结束递归删除)
* 3、如果当前结点的右子节点不为空，并且左子结点就是要删除结点，就将 this.right = null 即可；并且就返回(结束递归删除)
* 4、如果第2步和第3步没有删除结点，那么我们就需要向左子树进行递归删除
* 5、如果第4步也没有删除结点，则应当向右子树进行递归删除。
* */
// 2、如果当前节点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null 即可；并且就返回(结束递归删除)
if (this.left != null && this.left.no == no) {
this.left = null;
return;
}
//3、如果当前结点的右子节点不为空，并且左子结点就是要删除结点，就将 this.right = null 即可；并且就返回(结束递归删除)
if (this.right != null && this.right.no == no) {
this.right = null;
return;
}
// 4、如果第2步和第3步没有删除结点，那么我们就需要向左子树进行递归删除
if (this.left != null) {
this.left.deleteNode(no);
}
//5、如果第4步也没有删除结点，则应当向右子树进行递归删除。
if (this.right != null) {
this.right.deleteNode(no);
}
}
3.5.2 BinaryTree.java 二叉树
/*
* 递归删除结点
* */
public void deleteNode(int no) {
if (root != null) {
// 如果只有一个节点，这里立即判断root 是不是就是要删除结点
if (root.getNo() == no) {
root = null;
} else {
root.deleteNode(no);
}
} else {
System.out.println("空树，不能删除~~");
}
}
3.5.3 T1_BinaryTreeMain.java 测试类
/*
* 测试删除结点
* */
System.out.println("删除前，前序遍历");
binaryTree.preOrder(); // 1 2 3 5 4
//binaryTree.deleteNode(5);
binaryTree.deleteNode(3);
System.out.println("删除后，前序遍历");
binaryTree.preOrder(); // 1 2 3 4 // 1 2
3.5.4 测试结果
