Why do you need a data structure like a tree ?
Analytical advantages of array storage: accessing elements by subscripting is fast. For sorted arrays, binary search can also be used to improve retrieval speed. Disadvantage: If you want to retrieve a specific value, or insert the value (in a certain order), it will move as a whole, which is inefficient [schematic diagram] Analysis of chain storage method Advantages: To a certain extent, the array storage method is optimized (for example: inserting A numerical node only needs to link the inserted node to the linked list, and the deletion efficiency is also very good). Disadvantage: In retrieval, the efficiency is still low, for example (retrieving a certain value, you need to traverse from the head node) [Schematic diagram] The analysis of the tree storage method can improve the efficiency of data storage and reading, such as using a binary sorting tree ( Binary Sort Tree), which can not only ensure the retrieval speed of data, but also ensure the speed of data insertion, deletion and modification.
The concept of binary tree
- There are many kinds of trees, and a form in which each node can only have at most two children is called a binary tree.
- The child nodes of a binary tree are divided into left and right nodes.
- If all leaf nodes of the binary tree are at the last level, and the total number of nodes = 2^n -1 , n is the number of levels, then we call it a full binary tree.
- If all the leaf nodes of the binary tree are in the last layer or the penultimate layer, and the leaf nodes of the last layer are continuous on the left, and the leaf nodes of the penultimate layer are continuous on the right, we call it a complete binary tree.
Explanation of Binary Tree Traversal
Preorder traversal: output the parent node first, then traverse the left and right subtrees
In-order traversal: traverse the left subtree first, then output the parent node, and then traverse the right subtree
Post-order traversal: traverse the left subtree first, then the right subtree, and finally output the parent node
Summary: Look at the order of the output parent nodes to determine whether it is pre-order, mid-order or post-order
///编写前序遍历的方法
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);
}
Complete case
package com.tree.threadedbinarytree;
public class TreeDemo {
public static void main(String[] args) {
//先创建一颗二叉树
//先需要创建一颗二叉树
ThreadedBinaryTree2 binaryTree = new ThreadedBinaryTree2();
//创建需要的结点
HeroNode2 root = new HeroNode2(1, "宋江");
HeroNode2 node2 = new HeroNode2(2, "吴用");
HeroNode2 node3 = new HeroNode2(3, "卢俊义");
HeroNode2 node4 = new HeroNode2(4, "林冲");
HeroNode2 node5 = new HeroNode2(5, "关胜");
//说明，我们先手动创建该二叉树，后面我们学习递归的方式创建二叉树
root.setLeft(node2);
root.setRight(node3);
node3.setRight(node4);
node3.setLeft(node5);
binaryTree.setRoot(root);
System.out.println("前序遍历");
binaryTree.preOrder();
System.out.println("中序遍历");
binaryTree.infixOrder();
System.out.println("h后序遍历");
binaryTree.postOrder();
//前序遍历
//前序遍历的次数 ：4
System.out.println("前序遍历方式~~~");
HeroNode2 resNode = binaryTree.preOrderSearch(5);
if (resNode != null) {
System.out.printf("找到了，信息为 no=%d name=%s", resNode.getNo(), resNode.getName());
} else {
System.out.printf("没有找到 no = %d 的英雄", 5);
}
//中序遍历查找
//中序遍历3次
System.out.println("中序遍历方式~~~");
HeroNode2 resNode2 = binaryTree.infixOrderSearch(5);
if (resNode != null) {
System.out.printf("找到了，信息为 no=%d name=%s", resNode.getNo(), resNode.getName());
} else {
System.out.printf("没有找到 no = %d 的英雄", 5);
}
//后序遍历查找
//后序遍历查找的次数 2次
System.out.println("后序遍历方式~~~");
HeroNode2 resNode3 = binaryTree.postOrderSearch(5);
if (resNode != null) {
System.out.printf("找到了，信息为 no=%d name=%s", resNode.getNo(), resNode.getName());
} else {
System.out.printf("没有找到 no = %d 的英雄", 5);
}
//测试一把删除结点
System.out.println("删除前,前序遍历");
binaryTree.preOrder(); // 1,2,3,5,4
binaryTree.delNode(5);
//binaryTree.delNode(3);
System.out.println("删除后，前序遍历");
binaryTree.preOrder(); // 1,2,3,4
}
}
//定义ThreadedBinaryTree 实现了线索化功能的二叉树
class ThreadedBinaryTree2 {
private HeroNode2 root;
//为了实现线索化，需要创建要给指向当前结点的前驱结点的指针
//在递归进行线索化时，pre 总是保留前一个结点
private HeroNode2 pre = null;
public void setRoot(HeroNode2 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 delNode(int no) {
if(root != null) {
//如果只有一个root结点, 这里立即判断root是不是就是要删除结点
if(root.getNo() == no) {
root = null;
} else {
//递归删除
root.delNode(no);
}
}else{
System.out.println("空树，不能删除~");
}
}
//前序遍历查找
public HeroNode2 preOrderSearch(int no) {
if(root != null) {
return root.preOrderSearch(no);
} else {
return null;
}
}
//中序遍历查找
public HeroNode2 infixOrderSearch(int no) {
if(root != null) {
return root.infixOrderSearch(no);
}else {
return null;
}
}
//后序遍历查找
public HeroNode2 postOrderSearch(int no) {
if(root != null) {
return this.root.postOrderSearch(no);
}else {
return null;
}
}
}
//先创建HeroNode 结点
class HeroNode2 {
private int no;
private String name;
private HeroNode2 left; //默认null
private HeroNode2 right; //默认null
//说明
//1. 如果leftType == 0 表示指向的是左子树, 如果 1 则表示指向前驱结点
//2. 如果rightType == 0 表示指向是右子树, 如果 1表示指向后继结点
private int leftType;
private int rightType;
public HeroNode2(int no, String name) {
this.no = no;
this.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 HeroNode2 getLeft() {
return left;
}
public void setLeft(HeroNode2 left) {
this.left = left;
}
public HeroNode2 getRight() {
return right;
}
public void setRight(HeroNode2 right) {
this.right = right;
}
public int getLeftType() {
return leftType;
}
public void setLeftType(int leftType) {
this.leftType = leftType;
}
public int getRightType() {
return rightType;
}
public void setRightType(int rightType) {
this.rightType = rightType;
}
@Override
public String toString() {
return "HeroNode [no=" + no + ", name=" + name + "]";
}
///编写前序遍历的方法
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);
}
//递归删除结点
//1.如果删除的节点是叶子节点，则删除该节点
//2.如果删除的节点是非叶子节点，则删除该子树
public void delNode(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.我们就需要向左子树进行递归删除
if(this.left != null) {
this.left.delNode(no);
}
//5.则应当向右子树进行递归删除
if(this.right != null) {
this.right.delNode(no);
}
}
//前序遍历查找
/**
*
* @param no 查找no
* @return 如果找到就返回该Node ,如果没有找到返回 null
*/
public HeroNode2 preOrderSearch(int no) {
System.out.println("进入前序遍历");
//比较当前结点是不是
if(this.no == no) {
return this;
}
//1.则判断当前结点的左子节点是否为空，如果不为空，则递归前序查找
//2.如果左递归前序查找，找到结点，则返回
HeroNode2 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 HeroNode2 infixOrderSearch(int no) {
//判断当前结点的左子节点是否为空，如果不为空，则递归中序查找
HeroNode2 resNode = null;
if(this.left != null) {
resNode = this.left.infixOrderSearch(no);
}
if(resNode != null) {
return resNode;
}
System.out.println("进入中序查找");
//如果找到，则返回，如果没有找到，就和当前结点比较，如果是则返回当前结点
if(this.no == no) {
return this;
}
//否则继续进行右递归的中序查找
if(this.right != null) {
resNode = this.right.infixOrderSearch(no);
}
return resNode;
}
//后序遍历查找
public HeroNode2 postOrderSearch(int no) {
//判断当前结点的左子节点是否为空，如果不为空，则递归后序查找
HeroNode2 resNode = null;
if(this.left != null) {
resNode = this.left.postOrderSearch(no);
}
if(resNode != null) {//说明在左子树找到
return resNode;
}
//如果左子树没有找到，则向右子树递归进行后序遍历查找
if(this.right != null) {
resNode = this.right.postOrderSearch(no);
}
if(resNode != null) {
return resNode;
}
System.out.println("进入后序查找");
//如果左右子树都没有找到，就比较当前结点是不是
if(this.no == no) {
return this;
}
return resNode;
}
}