文章目录
- 1.二叉树
- 1.1 二叉树的概念和常用术语
- 1.2 前序中序后序遍历二叉树的步骤
- 1.2.1 代码实现
- 1.3 前序中序后序的查找思路图解
- 1.3.1 代码实现
- 1.4 二叉树删除结点的思路图解
- 1.4.1 代码实现
- 2.顺序存储二叉树
- 2.1 顺序存储二叉树的特点
- 2.2 代码实现
- 3.线索化二叉树
- 3.1 线索化二叉树基本介绍
- 3.2线索化二叉树的思路图解
- 3.3 遍历线索化二叉树
- 3.3.1 代码实现
1.二叉树
为什么需要树这种数据结构？
数组存储方式的分析
- 优点：通过下标方式
访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。 - 缺点：如果要检索具体某个值，或者
插入值(按一定顺序)会整体移动，效率较低 。
链式存储方式的分析
- 优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将
插入节点，链接到链表中即可，删除效率也很好)。 - 缺点：
在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历) 。
树存储方式的分析
- 能提高数据
存储，读取的效率, 比如利用二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度。
分析如果以二叉排序树来存储数据，那么对数据增删改查的效率都有所提高
案例: [7, 3, 10, 1, 5, 9, 12]
1.1 二叉树的概念和常用术语
树示意图
树的常用术语(结合示意图理解):
节点
根节点
父节点
子节点
叶子节点 (没有子节点的节点): H,E,F,G
节点的权(节点值)
路径(从root节点找到该节点的路线)：例如找D就是A->B->D
层
子树
树的高度(最大层数): 4
森林(多颗子树构成森林)
二叉树的概念
- 树有很多种，每个节点
最多只能有两个子节点的一种形式称为二叉树。 - 二叉树的子节点分为
左子节点和右子节点。
- 如果该二叉树的
所有的叶子节点都在最后一层，并且节点总数= 2^n -1 , n 为层数，则我们称为满二叉树。 - 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。
1.2 前序中序后序遍历二叉树的步骤
使用前序、中序和后序对下面的二叉树进行遍历.
- 前序遍历: 先输出父节点，再遍历左子树和右子树
- 中序遍历: 先遍历左子树，再输出父节点，再遍历右子树
- 后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点
小结：看输出父节点的顺序，就确定是前序，中序还是后序
前序遍历图解
中序遍历图解
后序遍历图解
分析二叉树的前序,中序,后序的遍历步骤：
1. 创建一颗二叉树
2. 前序遍历
2.1 先输出当前节点(初始的时候是root节点)
2.2 如果左子节点不为空,则递归继续前序遍历
2.3 如果右子节点不为空,则递归继续前序遍历
3. 中序遍历
3.1 如果当前节点的左子节点不为空,则递归中序遍历,
3.2 输出当前节点
3.3 如果当前节点的右子节点不为空,则递归中序遍历
4.后序遍历
4.1 如果当前节点的左子节点不为空,则递归后序遍历,
4.2 如果当前节点的右子节点不为空,则递归后序遍历
4.3
1.2.1 代码实现
/**
* @author xiexu
* @create 2020-11-11 10:39 上午
*/
public class BinaryTreeDemo {
public static void main(String[] args) {
//先创建一棵二叉树
BinaryTree binaryTree = new BinaryTree();
//创建需要的节点
HeroNode root = new HeroNode(1, "宋江");
HeroNode hero2 = new HeroNode(2, "吴用");
HeroNode hero3 = new HeroNode(3, "卢俊义");
HeroNode hero4 = new HeroNode(4, "林冲");
//说明：我们先手动创建二叉树，后面我们学习递归的方式创建二叉树
root.left = hero2;
root.right = hero3;
hero3.right = hero4;
binaryTree.setRoot(root);
//测试1
System.out.println("前序遍历:"); //1,2,3,4
binaryTree.perOrder();
//测试2
System.out.println("中序遍历:"); //2,1,3,4
binaryTree.infixOrder();
//测试3
System.out.println("后序遍历:"); //2,4,3,1
binaryTree.postOrder();
}
}
//创建一个HeroNode节点
class HeroNode {
int id;
String name;
HeroNode left; //默认为null，左子节点
HeroNode right; //默认为null，右子节点
public HeroNode() {
}
public HeroNode(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "HeroNode{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
//编写前序遍历的方法
public void perOrder() {
System.out.println(this); //输出父节点
//递归向左子树前序遍历
if (this.left != null) {
this.left.perOrder();
}
//递归向右子树前序遍历
if (this.right != null) {
this.right.perOrder();
}
}
// 编写中序遍历的方法
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);
}
}
//定义一个二叉树
class BinaryTree {
private HeroNode root;
public void setRoot(HeroNode root) {
this.root = root;
}
//前序遍历
public void perOrder() {
if (this.root != null) {
this.root.perOrder();
} 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("二叉树为空,无法遍历");
}
}
}
按照上图的 3号节点 “卢俊义” , 增加一个左子节点 [5, 关胜]
使用前序，中序，后序遍历，请写出各自输出的顺序是什么?
/**
* @author xiexu
* @create 2020-11-11 10:39 上午
*/
public class BinaryTreeDemo {
public static void main(String[] args) {
//先创建一棵二叉树
BinaryTree binaryTree = new BinaryTree();
//创建需要的节点
HeroNode root = new HeroNode(1, "宋江");
HeroNode hero2 = new HeroNode(2, "吴用");
HeroNode hero3 = new HeroNode(3, "卢俊义");
HeroNode hero4 = new HeroNode(4, "林冲");
HeroNode hero5 = new HeroNode(5, "关胜");
//说明：我们先手动创建二叉树，后面我们学习递归的方式创建二叉树
root.left = hero2;
root.right = hero3;
hero3.right = hero4;
hero3.left = hero5;
binaryTree.setRoot(root);
//测试1
System.out.println("前序遍历:"); //1,2,3,5,4
binaryTree.perOrder();
//测试2
System.out.println("中序遍历:"); //2,1,5,3,4
binaryTree.infixOrder();
//测试3
System.out.println("后序遍历:"); //2,5,4,3,1
binaryTree.postOrder();
}
}
//创建一个HeroNode节点
class HeroNode {
int id;
String name;
HeroNode left; //默认为null，左子节点
HeroNode right; //默认为null，右子节点
public HeroNode() {
}
public HeroNode(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "HeroNode{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
//编写前序遍历的方法
public void perOrder() {
System.out.println(this); //输出父节点
//递归向左子树前序遍历
if (this.left != null) {
this.left.perOrder();
}
//递归向右子树前序遍历
if (this.right != null) {
this.right.perOrder();
}
}
// 编写中序遍历的方法
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);
}
}
//定义一个二叉树
class BinaryTree {
private HeroNode root;
public void setRoot(HeroNode root) {
this.root = root;
}
//前序遍历
public void perOrder() {
if (this.root != null) {
this.root.perOrder();
} 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("二叉树为空,无法遍历");
}
}
}
1.3 前序中序后序的查找思路图解
二叉树-查找指定节点
- 请编写前序查找，中序查找和后序查找的方法。
- 并分别使用三种查找方式，查找
heroNo = 5 的节点 - 并分析各种查找方式，分别比较了多少次
- 思路分析图解如下：
1.3.1 代码实现
/**
* @author xiexu
* @create 2020-11-11 10:39 上午
*/
public class BinaryTreeDemo {
public static void main(String[] args) {
//先创建一棵二叉树
BinaryTree binaryTree = new BinaryTree();
//创建需要的节点
HeroNode root = new HeroNode(1, "宋江");
HeroNode hero2 = new HeroNode(2, "吴用");
HeroNode hero3 = new HeroNode(3, "卢俊义");
HeroNode hero4 = new HeroNode(4, "林冲");
HeroNode hero5 = new HeroNode(5, "关胜");
//说明：我们先手动创建二叉树，后面我们学习递归的方式创建二叉树
root.left = hero2;
root.right = hero3;
hero3.right = hero4;
hero3.left = hero5;
binaryTree.setRoot(root);
//前序遍历查找
//前序遍历查找的次数：4
System.out.println("前序遍历查找方式:");
HeroNode node = binaryTree.preOrderSearch(5);
if(node != null){
System.out.printf("找到了,信息为 id = %d name = %s\n",node.id,node.name);
} else {
System.out.printf("没有找到,相关信息的人物。\n");
}
//中序遍历查找
//中序遍历查找次数：3
System.out.println("中序遍历查找方式:");
HeroNode node2 = binaryTree.infixOrderSearch(5);
if(node2 != null){
System.out.printf("找到了,信息为 id = %d name = %s\n",node2.id,node2.name);
} else {
System.out.printf("没有找到,相关信息的人物。\n");
}
//后序遍历查找
//后序遍历查找次数：2
System.out.println("后序遍历查找方式:");
HeroNode node3 = binaryTree.postOrderSearch(5);
if(node3 != null){
System.out.printf("找到了,信息为 id = %d name = %s\n",node3.id,node3.name);
} else {
System.out.printf("没有找到,相关信息的人物。\n");
}
}
}
//创建一个HeroNode节点
class HeroNode {
int id;
String name;
HeroNode left; //默认为null，左子节点
HeroNode right; //默认为null，右子节点
public HeroNode() {
}
public HeroNode(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "HeroNode{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
//编写前序遍历的方法
public void perOrder() {
System.out.println(this); //输出父节点
//递归向左子树前序遍历
if (this.left != null) {
this.left.perOrder();
}
//递归向右子树前序遍历
if (this.right != null) {
this.right.perOrder();
}
}
// 编写中序遍历的方法
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);
}
//前序遍历查找
/**
* @param id 要查找的id
* @return 如果找到就返回该HeroNode，如果找不到就返回null
*/
public HeroNode preOrderSearch(int id) {
System.out.println("进入前序遍历...");
//比较当前节点
if (this.id == id) {
return this;
}
//1.判断当前结点的左子节点是否为空,如果不为空,则递归前序查找
//2.如果左递归前序查找,找到结点,则返回
HeroNode res = null;
if (this.left != null) {
res = this.left.preOrderSearch(id);
}
if (res != null) { //说明在左子树找到了
return res;
}
//3.否则继续判断,当前的结点的右子节点是否为空
//4.如果不空,则继续向右递归前序查找。
if (this.right != null) {
res = this.right.preOrderSearch(id);
}
return res;
}
//中序遍历查找
public HeroNode infixOrderSearch(int id) {
//1.判断当前结点的左子节点是否为空,如果不为空,则递归中序查找
HeroNode res = null;
if(this.left != null){
res = this.left.infixOrderSearch(id);
}
if(res != null){ //说明在左子树找到了
return res;
}
//2.如果找到,则返回,如果没有找到,就和当前结点比较,
//如果是则返回当前结点,否则继续进行右递归的中序查找
System.out.println("进入中序遍历...");
if(this.id == id){
return this;
}
//3.如果右递归中序查找,找到就返回,否则返回null
if(this.right != null){
res = this.right.infixOrderSearch(id);
}
return res;
}
//后序遍历查找
public HeroNode postOrderSearch(int id){
//1.判断当前节点的左子节点是否为空,如果不为空,则递归后序查找
HeroNode res = null;
if(this.left != null){
res = this.left.postOrderSearch(id);
}
if(res != null){ //说明在左子树找到了
return res;
}
//2.如果左子树没有找到,则向右递归进行后序查找,如果找到,就返回
if(this.right != null){
res = this.right.postOrderSearch(id);
}
if(res != null){ //说明在右子树找到了
return res;
}
System.out.println("进入后序遍历...");
//3.如果左右子树都没有找到,就比较当前节点是不是
if(this.id == id){
return this;
}
return res;
}
}
//定义一个二叉树
class BinaryTree {
private HeroNode root;
public void setRoot(HeroNode root) {
this.root = root;
}
//前序遍历
public void perOrder() {
if (this.root != null) {
this.root.perOrder();
} 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 HeroNode preOrderSearch(int id){
if(root != null){
return root.preOrderSearch(id);
}else{
return null;
}
}
//中序遍历查找
public HeroNode infixOrderSearch(int id){
if(root != null){
return root.infixOrderSearch(id);
}else{
return null;
}
}
//后序遍历查找
public HeroNode postOrderSearch(int id){
if(root != null){
return root.postOrderSearch(id);
}else{
return null;
}
}
}
1.4 二叉树删除结点的思路图解
- 如果删除的节点是叶子节点，则删除该节点
- 如果删除的节点是非叶子节点，则删除该子树
- 测试，删除掉 5号叶子节点 和 3号子树
- 相关思路分析如下:
1.4.1 代码实现
/**
* @author xiexu
* @create 2020-11-11 10:39 上午
*/
public class BinaryTreeDemo {
public static void main(String[] args) {
//先创建一棵二叉树
BinaryTree binaryTree = new BinaryTree();
//创建需要的节点
HeroNode root = new HeroNode(1, "宋江");
HeroNode hero2 = new HeroNode(2, "吴用");
HeroNode hero3 = new HeroNode(3, "卢俊义");
HeroNode hero4 = new HeroNode(4, "林冲");
HeroNode hero5 = new HeroNode(5, "关胜");
//说明：我们先手动创建二叉树，后面我们学习递归的方式创建二叉树
root.left = hero2;
root.right = hero3;
hero3.right = hero4;
hero3.left = hero5;
binaryTree.setRoot(root);
//测试删除
System.out.println("删除前,前序遍历:");
binaryTree.perOrder(); // 1,2,3,5,4
binaryTree.delNode(5);
// binaryTree.delNode(3); 如果删除3，就变成1,2
System.out.println("删除后，前序遍历:");
binaryTree.perOrder(); // 1,2,3,4
}
}
//创建一个HeroNode节点
class HeroNode {
int id;
String name;
HeroNode left; //默认为null，左子节点
HeroNode right; //默认为null，右子节点
public HeroNode() {
}
public HeroNode(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "HeroNode{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
//递归删除结点
//1.如果删除的节点是叶子节点,则删除该节点
//2.如果删除的节点是非叶子节点,则删除该子树
public void delNode(int id) {
/**
* 思路:
* 1.因为我们的二叉树是单向的，所以我们是判断当前结点的子结点是否需要删除结点，而不能去判断当前这个结点是不是需要删除结点.
* 2.如果当前结点的左子结点不为空，并且左子结点就是要删除结点，就将this.left = null;并且就返回(结束递归删除)
* 3.如果当前结点的右子结点不为空，并且右子结点就是要删除结点，就将this.right = null;并且就返回(结束递归删除)
* 4.如果第2和第3步没有删除结点，那么我们就需要向左子树进行递归删除
* 5.如果第4步也没有删除结点，则应当向右子树进行递归删除.
*/
// 2.如果当前结点的左子结点不为空，并且左子结点就是要删除结点，就将this.left = null;并且就返回(结束递归删除)
if (this.left != null && this.left.id == id) {
this.left = null;
return;
}
//3.如果当前结点的右子结点不为空，并且右子结点就是要删除结点，就将this.right = null;并且就返回(结束递归删除)
if (this.right != null && this.right.id == id) {
this.right = null;
return;
}
//4.如果第2和第3步没有删除结点，那么我们就需要向左子树进行递归删除
if (this.left != null) {
this.left.delNode(id);
}
//5.如果第4步也没有删除结点，则应当向右子树进行递归删除.
if (this.right != null) {
this.right.delNode(id);
}
}
}
//定义一个二叉树
class BinaryTree {
private HeroNode root;
public void setRoot(HeroNode root) {
this.root = root;
}
//删除节点
public void delNode(int id) {
if (root != null) {
//如果只有一个root结点，则等价将二叉树置空
if (root.id == id) {
root = null;
} else {
//递归删除
root.delNode(id);
}
} else {
System.out.println("空树,不能删除");
}
}
}
思考题(课后练习)
1.如果要删除的节点是非叶子节点，现在我们不希望将该非叶子节点为根节点的子树删除，需要指定规则, 假如规定如下:
2.如果该非叶子节点A只有一个子节点B，则子节点B替代节点A
3.如果该非叶子节点A有左子节点B和右子节点C，则让左子节点B替代节点A。
具体参考思路及代码等到"二叉排序树的删除"会详细介绍
2.顺序存储二叉树
从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组，
参考上面的示意图。
要求:
1.上图的二叉树的结点，要求以数组的方式来存放 arr : [1, 2, 3, 4, 5, 6, 7]
2.要求在遍历数组 arr时，仍然可以用前序遍历，中序遍历和后序遍历的方式完成结点的遍历
2.1 顺序存储二叉树的特点
1.顺序存储二叉树通常只考虑"完全二叉树"
2.第n个元素的左子节点为 2 * n + 1
3.第n个元素的右子节点为 2 * n + 2
4.第n个元素的父节点为 (n-1) / 2
5.n : 表示二叉树中的第几个元素(按0开始编号,如上图所示)
2.2 代码实现
需求: 给你一个数组 { 1,2,3,4,5,6,7 }，要求以二叉树前序、中序、后序遍历的方式进行遍历。
/**
* @author xiexu
* @create 2020-11-12 10:47 上午
*/
public class ArrBinaryTreeDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7};
//创建一个ArrBinaryTree
ArrBinaryTree tree = new ArrBinaryTree(arr);
System.out.println("前序遍历：");
tree.preOrder(0); // 1 2 4 5 3 6 7
System.out.println();
System.out.println("中序遍历：");
tree.infixOrder(0); // 4 2 5 1 6 3 7
System.out.println();
System.out.println("后序遍历：");
tree.postOrder(0); // 4 5 2 6 7 3 1
}
}
class ArrBinaryTree {
private int[] arr; //存储二叉树节点的数组
public ArrBinaryTree(int[] arr) {
this.arr = arr;
}
//编写方法：实现顺序存储二叉树的前序遍历
public void preOrder(int index) {
//如果数组为空，或arr.length == 0
if (arr == null || arr.length == 0) {
System.out.println("数组为空，无法遍历查找");
return;
}
//输出当前数组的元素
System.out.print(arr[index] + " ");
//向左递归遍历
if ((2 * index + 1) < arr.length) {
preOrder(2 * index + 1);
}
//向右递归遍历
if ((2 * index + 2) < arr.length) {
preOrder(2 * index + 2);
}
}
//编写方法：实现顺序存储二叉树的中序遍历
public void infixOrder(int index) {
//如果数组为空，或arr.length == 0
if (arr == null || arr.length == 0) {
System.out.println("数组为空，无法遍历查找");
return;
}
//向左递归遍历
if ((2 * index + 1) < arr.length) {
infixOrder(2 * index + 1);
}
//输出当前数组的元素
System.out.print(arr[index] + " ");
//向右递归遍历
if ((2 * index + 2) < arr.length) {
infixOrder(2 * index + 2);
}
}
//编写方法：实现顺序存储二叉树的中序遍历
public void postOrder(int index) {
//如果数组为空，或arr.length == 0
if (arr == null || arr.length == 0) {
System.out.println("数组为空，无法遍历查找");
return;
}
//向左递归遍历
if ((2 * index + 1) < arr.length) {
postOrder(2 * index + 1);
}
//向右递归遍历
if ((2 * index + 2) < arr.length) {
postOrder(2 * index + 2);
}
//输出当前数组的元素
System.out.print(arr[index] + " ");
}
}
3.线索化二叉树
3.1 线索化二叉树基本介绍
先看一个问题：
将数列 {1, 3, 6, 8, 10, 14 } 构建成一颗二叉树
空指针域：n+1 = 6 + 1 = 7
问题分析:
1.当我们对上面的二叉树进行中序遍历时，数列为 {8, 3, 10, 1, 14, 6}
2.但是 6, 8, 10, 14 这几个节点的 左右指针，并没有完全的利用上.
3.如果我们希望充分的利用 各个节点的左右指针， 让各个节点可以指向自己的前后节点,怎么办?
4.解决方案 --->
线索二叉树的基本介绍
- n个结点的二叉链表中含有n+1
【公式 2n-(n-1) = n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（ 这种附加的指针称为"线索" ) - 这种加上了线索的二叉链表称为
线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种 - 一个结点的前一个结点，称为
前驱结点 - 一个结点的后一个结点，称为
后继结点
3.2线索化二叉树的思路图解
将下面的二叉树，进行中序线索二叉树。中序遍历的数列为 {8, 3, 10, 1, 14, 6}
结果分析：中序遍历的结果：{8,3,10,1,14,6}
说明: 当线索化二叉树后，Node节点的 属性 left 和 right ，有如下情况:
1.left 指向的是左子树，也可能是指向 前驱节点. 比如 ① 节点 left 指向的左子树, 而 ⑩ 节点的 left 指向的就是前驱节点.
2.right指向的是右子树，也可能是指向 后继节点，比如 ① 节点right 指向的是右子树，而⑩ 节点的right 指向的是后继节点.
/**
* 线索化二叉树
*
* @author xiexu
* @create 2020-11-12 2:33 下午
*/
public class ThreadedBinaryTreeDemo {
public static void main(String[] args) {
//测试中序线索二叉树的功能
HeroNode root = new HeroNode(1, "tom");
HeroNode node2 = new HeroNode(3, "jack");
HeroNode node3 = new HeroNode(6, "smith");
HeroNode node4 = new HeroNode(8, "mary");
HeroNode node5 = new HeroNode(10, "king");
HeroNode node6 = new HeroNode(14, "dim");
//二叉树，后面我们会递归创建，所以先简单处理使用手动创建
root.left = node2;
root.right = node3;
node2.left = node4;
node2.right = node5;
node3.left = node6;
//测试中序线索化
ThreadTree threadTree = new ThreadTree();
threadTree.setRoot(root);
threadTree.treadNodes();
//测试:以10号节点测试
HeroNode left = node5.left;
HeroNode right = node5.right;
System.out.println("10号节点的前驱结点是:" + left);
System.out.println("10号节点的后继是结点是:" + right);
}
}
//创建一个HeroNode结点
class HeroNode {
int id;
String name;
HeroNode left; // 默认为null,左子节点
HeroNode right; // 默认为null,右子节点
//说明:
//1.如果leftType == 0 表示指向的是左子树, 如果 1 则表示指向前驱结点
//2.如果rightType == 0 表示指向是右子树, 如果 1 则表示指向后继结点
int leftType;
int rightType;
public HeroNode() {
super();
}
public HeroNode(int id, String name) {
super();
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "HeroNode [id=" + id + ", name=" + name + "]";
}
}
//定义一个ThreadTree,实现了线索化功能的二叉树
class ThreadTree {
private HeroNode root;
//为了实现线索化,需要创建一个指向当前结点的前驱结点的指针
//在递归进行线索化时,pre 总是保留前一个结点
private HeroNode pre = null;
public void setRoot(HeroNode root) {
this.root = root;
}
//重载 线索化的方法treadNodes
public void treadNodes() {
this.treadNodes(root);
}
//编写对二叉树进行"中序线索化"的方法
//node 即当前需要线索化的结点
public void treadNodes(HeroNode node) {
//如果node==null，无法线索化
if (node == null) {
return;
}
//1.先线索化左子树
treadNodes(node.left);
//2.线索化当前节点
//处理当前结点的前驱结点
if (node.left == null) {
//让当前结点的左指针指向前驱结点
node.left = pre;
//修改当前结点的左指针的类型，指向前驱结点
node.leftType = 1;
}
//处理后继结点
if (pre != null && pre.right == null) {
pre.right = node; //让前驱结点的右指针指向当前结点
pre.rightType = 1;
}
//重要：每处理一个结点后，让当前结点是下一个结点的前驱结点
pre = node;
//3.再线索化右子树
treadNodes(node.right);
}
}
3.3 遍历线索化二叉树
- 说明：对前面的
中序线索化二叉树， 进行遍历 - 分析：因为线索化后，各个结点指向有变化，因此原来的遍历方式不能使用，这时需要使用新的方式遍历线索化二叉树，各个节点可以通过线型方式遍历，因此无需使用递归方式，这样也提高了遍历的效率。 遍历的次序应当和中序遍历保持一致。
3.3.1 代码实现
/**
* 线索化二叉树
* @author xiexu
* @create 2020-11-12 2:33 下午
*/
public class ThreadedBinaryTreeDemo {
public static void main(String[] args) {
//测试中序线索二叉树的功能
HeroNode root = new HeroNode(1, "tom");
HeroNode node2 = new HeroNode(3, "jack");
HeroNode node3 = new HeroNode(6, "smith");
HeroNode node4 = new HeroNode(8, "mary");
HeroNode node5 = new HeroNode(10, "king");
HeroNode node6 = new HeroNode(14, "dim");
//二叉树，后面我们会递归创建，所以先简单处理使用手动创建
root.left = node2;
root.right = node3;
node2.left = node4;
node2.right = node5;
node3.left = node6;
//测试中序线索化
ThreadTree threadTree = new ThreadTree();
threadTree.setRoot(root);
threadTree.treadNodes();
//测试:以10号节点测试
HeroNode left = node5.left;
HeroNode right = node5.right;
System.out.println("10号节点的前驱结点是:" + left);
System.out.println("10号节点的后继是结点是:" + right);
//当线索化二叉树后，不能再使用初始遍历方式
// threadTree.infixOrder(); //会报错,死循环栈溢出
System.out.println("使用线索化的方式遍历线索化二叉树:");
threadTree.threadedList();
}
}
//创建一个HeroNode结点
class HeroNode {
int id;
String name;
HeroNode left; // 默认为null,左子节点
HeroNode right; // 默认为null,右子节点
//说明:
//1.如果leftType == 0 表示指向的是左子树, 如果 1 则表示指向前驱结点
//2.如果rightType == 0 表示指向是右子树, 如果 1 则表示指向后继结点
int leftType;
int rightType;
public HeroNode() {
super();
}
public HeroNode(int id, String name) {
super();
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "HeroNode [id=" + id + ", name=" + name + "]";
}
//中序遍历
public void infixOrder() {
//递归向左子树中序遍历
if (this.left != null) {
this.left.infixOrder();
}
//输出父节点
System.out.println(this);
//递归向右子树中序遍历
if (this.right != null) {
this.right.infixOrder();
}
}
}
//定义一个ThreadTree,实现了线索化功能的二叉树
class ThreadTree {
private HeroNode root;
//为了实现线索化,需要创建一个指向当前结点的前驱结点的指针
//在递归进行线索化时,pre 总是保留前一个结点
private HeroNode pre = null;
public void setRoot(HeroNode root) {
this.root = root;
}
//重载 线索化的方法treadNodes
public void treadNodes() {
this.treadNodes(root);
}
//遍历线索化二叉树的方法
public void threadedList() {
//定义一个变量，用于存储当前遍历的结点，从root开始
HeroNode node = root;
while (node != null) {
//循环的找到leftType == 1的结点,第一个找到就是8结点
//后面随着遍历而变化,因为当leftType==1时,说明该结点是按照线索化处理后的有效结点
while (node.leftType == 0) {
node = node.left;
}
//打印当前结点
System.out.println(node);
//如果当前结点的右指针指向的是后继结点,则会一直输出
while (node.rightType == 1) {
//获得当前节点的后继节点
node = node.right;
System.out.println(node);
}
//替换这个遍历节点
node = node.right;
}
}
//编写对二叉树进行"中序线索化"的方法
//node 即当前需要线索化的结点
public void treadNodes(HeroNode node) {
//如果node==null，无法线索化
if (node == null) {
return;
}
//1.先线索化左子树
treadNodes(node.left);
//2.线索化当前节点
//处理当前结点的前驱结点
if (node.left == null) {
//让当前结点的左指针指向前驱结点
node.left = pre;
//修改当前结点的左指针的类型，指向前驱结点
node.leftType = 1;
}
//处理后继结点
if (pre != null && pre.right == null) {
pre.right = node; //让前驱结点的右指针指向当前结点
pre.rightType = 1;
}
//重要：每处理一个结点后，让当前结点是下一个结点的前驱结点
pre = node;
//3.再线索化右子树
treadNodes(node.right);
}
}
