树结构
1、二叉树
为什么需要树
-
数组通过下标方式访问元素,查找效率高,但是插入效率低,需要整体移动。
-
-
链表的插入效率高,查找效率低(查找某个值需要从头结点开始遍历)。
需要一种数据结构来平衡查找与插入效率,使得查找速度和插入速度都能得到提升,因此有了树这种数据结构。
树的基本概念
树的常用术语(结合图知)
1)节点
2)根节点
3)父节点
4)子节点
5)叶子节点(没有子节点的节点)
6)节点的权(节点值)
7)路径(从root节点找到该节点的路线)
8)层
9)子树
10)树的高度(最大层数)
11)森林:多颗子树构成森林
二叉树的基本概念
每个节点最多只能有两个子节点的一种形式称为二叉树
二叉树子节点分为左右节点
满二叉树
如果该二叉树的所有叶子节点都在最后一层,并且结点总数= 2n -1 , n为层数,则我们称为满二叉树。
完全二叉树
如果该二叉树的所有叶子节点都在最后一层或者倒数第二层,而且最后一层的叶子节点在左边连续,倒数第二层的叶子节点在右边连续,我们称为完全二叉树
二叉树的遍历
前序遍历
先遍历父节点,再遍历左子节点,最后遍历右子节点
中序遍历
先遍历左子节点,再遍历父节点,最后遍历右子节点
后序遍历
先遍历左子节点,再遍历右子节点,最后遍历父节点
根据父节点数据,确定是前中后
说明图
前序遍历结果:1、2、5、6、3
中序遍历结果:5、2、6、1、3
后序遍历结果:5、6、2、3、1
遍历步骤
1.创建一颗二叉树
前序遍历
1先输出当前节点(初始的时候是root节点)
2如果左子节点不为空,则递归继续前序遍历
2如果右子节点不为空,则递归继续前序遍历
中序遍历
1如果当前节点的左子节点不为空,则递归中序遍历
2输出当前节点
2如果当前节点的右子节点不为空,则递归中序遍历
后序遍历
1如果当前节点的左子节点不为空,则递归后序遍历,
2如果当前节点的右子节点不为空,则递归后序遍历
3输出当前节点
实际代码
此代码使用手动的方式创建二叉树,使用递归的方式遍历二叉树
递归终止条件,节点的左右子节点都为空
每次递归的要做的事 如上遍历步骤
无返回值
public class Demo1 {
public static void main(String[] args) {
//创建二叉树
BinaryTree binaryTree = new BinaryTree();
//手动创建节点,并放入二叉树中
StuNode stu1 = new StuNode(1, "A");
StuNode stu2 = new StuNode(2, "B");
StuNode stu3 = new StuNode(3, "C");
StuNode stu4 = new StuNode(4, "D");
stu1.setLeft(stu2);
stu1.setRight(stu3);
stu3.setRight(stu4);
binaryTree.setRoot(stu1);
//遍历二叉树
binaryTree.preTraverse();
binaryTree.midTraverse();
binaryTree.lastTraverse();
}
}
class BinaryTree {
/**
* 根节点
*/
private StuNode root;
//set方法
public void setRoot(StuNode root) {
this.root = root;
}
//前序遍历
public void preTraverse() {
if(root != null) {
System.out.println("前序遍历");
root.preTraverse();
System.out.println();
}else {
System.out.println("二叉树为空!");
}
}
//中序遍历
public void midTraverse() {
if(root != null) {
System.out.println("中序遍历");
root.midTraverse();
System.out.println();
}else {
System.out.println("二叉树为空!");
} }
public void lastTraverse() {
if(root != null) {
System.out.println("后序遍历");
root.lastTraverse();
System.out.println();
}else {
System.out.println("二叉树为空!");
} }
}
/**
* 二叉树中的一个节点
* 保存了学生信息和左右孩子信息
*/
class StuNode {
int id;
String name;
StuNode left;
StuNode right;
public StuNode(int id, String name) {
this.id = id;
this.name = name;
}
//省略了getter、setter方法
@Override//不带上左右指针了,会递归调用的
public String toString() {
return "StuNode{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
/**
* 前序遍历
*/
public void preTraverse() {
//父节点的位置
System.out.println(this);
if(left != null) {
left.preTraverse();
}
if(right != null) {
right.preTraverse();
}
}
/**
* 中序遍历
*/
public void midTraverse() {
if(left != null) {
left.midTraverse();
}
//父节点的位置
System.out.println(this);
if(right != null) {
right.midTraverse();
}
}
public void lastTraverse() {
if(left != null) {
left.lastTraverse();
}
if(right != null) {
right.lastTraverse();
}
//父节点的位置
System.out.println(this);
}
}
运行结果
前序遍历
StuNode{id=1, name='A'}
StuNode{id=2, name='B'}
StuNode{id=3, name='C'}
StuNode{id=4, name='D'}
中序遍历
StuNode{id=2, name='B'}
StuNode{id=1, name='A'}
StuNode{id=3, name='C'}
StuNode{id=4, name='D'}
后序遍历
StuNode{id=2, name='B'}
StuNode{id=4, name='D'}
StuNode{id=3, name='C'}
StuNode{id=1, name='A'}
比较下面代码,上面的更严密,做了传入根节点的非空验证,否的若是传入null,null.left会报空指针异常
// if (root == null) {
// return;
// }
// inorder(root.left, result);
// result.add(root.val);
// inorder(root.right, result);
if(root.left!=null){
inorder(root.left,result);
}
result.add(root.val);
if(root.right!=null){
inorder(root.right,result);
}
二叉树的查找
前、中、后序查找的思路与遍历相似,当找到对应的元素时,直接返回即可。
实现代码
public class Demo2 {
public static void main(String[] args) {
//创建根节点
BinarySearchTree tree = new BinarySearchTree();
//手动创建节点
Student student1 = new Student(1, "A");
Student student2 = new Student(2, "B");
Student student3 = new Student(3, "C");
Student student4 = new Student(4, "D");
Student student5 = new Student(5, "E");
student1.setLeft(student2);
student1.setRight(student3);
student2.setLeft(student4);
student3.setRight(student5);
//指定根节点
tree.setRoot(student1);
//查找
tree.preSearch(3);
tree.midSearch(4);
tree.lastSearch(7);
}
}
class BinarySearchTree {
private Student root;
public void setRoot(Student root) {
this.root = root;
}
public void preSearch(int id) {
System.out.println("前序查找");
if(root == null) {
System.out.println("树为空!");
return;
}
Student result = root.preSearch(id);
if(result == null) {
System.out.println("未找到该元素");
System.out.println();
return;
}
System.out.println(result);
System.out.println();
}
public void midSearch(int id) {
System.out.println("中序查找");
if(root == null) {
System.out.println("树为空!");
return;
}
Student result = root.midSearch(id);
if(result == null) {
System.out.println("未找到该元素");
System.out.println();
return;
}
System.out.println(result);
System.out.println();
}
public void lastSearch(int id) {
System.out.println("后序查找");
if(root == null) {
System.out.println("树为空!");
return;
}
Student result = root.lastSearch(id);
if(result == null) {
System.out.println("未找到该元素");
System.out.println();
return;
}
System.out.println(result);
System.out.println();
}
}
class Student {
int id;
String name;
Student left;
Student right;
public Student(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
/**
* 前序查找
* @param id 要查找的学生id
* @return 查找到的学生
*/
public Student preSearch(int id) {
//如果找到了,就返回
if(this.id == id) {
return this;
}
//在左子树中查找,如果找到了就返回
Student student = null;
if(left != null) {
student = left.preSearch(id);
}
if(student != null) {
return student;
}
//在右子树中查找,无论是否找到,都需要返回
if(right != null) {
student = right.preSearch(id);
}
return student;
}
/**
* 中序查找
* @param id 要查找的学生id
* @return 查找到的学生
*/
public Student midSearch(int id) {
Student student = null;
if(left != null) {
student = left.midSearch(id);
}
if(student != null) {
return student;
}
//找到了就返回
if(this.id == id) {
return this;
}
if(right != null) {
student = right.midSearch(id);
}
return student;
}
/**
* 后序查找
* @param id 要查找的学生id
* @return 查找到的学生
*/
public Student lastSearch(int id) {
Student student = null;
if(left != null) {
student = left.lastSearch(id);
}
if(student !=null) {
return student;
}
if(right != null) {
student = right.lastSearch(id);
}
if(this.id == id) {
return this;
}
return student;
}
}
运行结果
前序查找
Student{id=3, name='C'}
中序查找
Student{id=4, name='D'}
后序查找
未找到该元素
二叉树的删除
删除要求
- 如果删除的是叶子节点,则直接删除即可
- 如果删除的是非叶子节点,则删除该子树
删除思路
- 因为我们的二叉树是单向的,所以我们是判断当前结点的子结点是否需要删除结点,而不能去判断当前这个结点是不是需要删除结点
- 如果当前结点的左子结点不为空,并且左子结点就是要删除结点,就将 this.left = null; 并且就返回 (结束递归删除)
- 如果当前结点的右子结点不为空,并且右子结点就是要删除结点,就将 this.right= null ;并且就返回 (结束递归删除)
- 如果第2和第3步没有删除结点,那么我们就需要向左子树进行递归删除
- 如果 4步也没有删除结点,则应当向右子树进行递归删除
实现代码
public class Demo3 {
public static void main(String[] args) {
//创建根节点
BinaryDeleteTree deleteTree = new BinaryDeleteTree();
//手动创建节点
StudentNode student1 = new StudentNode(1, "A");
StudentNode student2 = new StudentNode(2, "B");
StudentNode student3 = new StudentNode(3, "C");
StudentNode student4 = new StudentNode(4, "D");
StudentNode student5 = new StudentNode(5, "E");
student1.setLeft(student2);
student1.setRight(student3);
student2.setLeft(student4);
student3.setRight(student5);
//指定根节点
deleteTree.setRoot(student1);
//删除节点
deleteTree.deleteNode(3);
}
}
class BinaryDeleteTree {
StudentNode root;
public void setRoot(StudentNode root) {
this.root = root;
}
/**
* 删除节点
* @param id 删除节点的id
*/
public void deleteNode(int id) {
System.out.println("删除节点");
if(root.id == id) {
root = null;
System.out.println("根节点被删除");
return;
}
//调用删除方法
root.deleteNode(id);
}
}
class StudentNode {
int id;
String name;
StudentNode left;
StudentNode right;
public StudentNode(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "StudentNode{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
/**
* 删除节点
* @param id 删除节点的id
*/
public void deleteNode(int id) {
//如果左子树不为空且是要查找的节点,就删除
if(left != null && left.id == id) {
left = null;
System.out.println("删除成功");
return;
}
//如果右子树不为空且是要查找的节点,就删除
if(right != null && right.id == id) {
right = null;
System.out.println("删除成功");
return;
}
//左递归,继续查找
if(left != null) {
left.deleteNode(id);
}
//右递归,继续查找
if(right != null) {
right.deleteNode(id);
}
}
}
顺序存储二叉树
基本说明
从数据存储来看,数组存储方式和树的存储方式可以相互转换,即数组可以转换成树,树也可以转换成数组
特点
-
顺序二叉树通常只考虑完全二叉树
-
第 n个元素的左子节点为 2 × n + 1
-
第 n个元素的右子节点为 2 × n + 2
-
第 n个元素的父节点为 (n-1) ÷2
- 其中n 表示二叉树中的第几个元素(从0开始编号)
遍历过程和二叉树的遍历类似,只不过递归的条件有所不同
实现代码
public class Demo4 {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7};
ArrBinaryTree arrBinaryTree = new ArrBinaryTree(arr);
//前序遍历
System.out.println("数组前序遍历");
arrBinaryTree.preTraverse();
System.out.println();
//中序遍历
System.out.println("数组中序遍历");
arrBinaryTree.midTraverse();
System.out.println();
//后序遍历
System.out.println("数组后序遍历");
arrBinaryTree.lastTraverse();
System.out.println();
}
}
class ArrBinaryTree {
int[] arr;
final int STEP = 2;
public ArrBinaryTree(int[] arr) {
this.arr = arr;
}
/**
* 数组的前序遍历
*/
public void preTraverse() {
preTraverse(0);
}
/**
* 数组的前序遍历
* @param index 遍历到的数组元素下标
*/
private void preTraverse(int index) {
if(arr == null || arr.length == 0) {
System.out.println("数组为空!");
return;
}
System.out.print(arr[index] + " ");
//向左递归
if((index * STEP) + 1 < arr.length) {
preTraverse((index * STEP) + 1);
}
//向右递归
if((index * STEP) + 2 < arr.length) {
preTraverse((index * STEP) + 2);
}
}
public void midTraverse() {
midTraverse(0);
}
private void midTraverse(int index) {
if(arr == null || arr.length == 0) {
System.out.println("数组为空!");
}
//左递归
if((index * STEP) + 1 < arr.length) {
midTraverse((index * STEP) + 1);
}
System.out.print(arr[index] + " ");
//右递归
if((index * STEP) + 2 < arr.length) {
midTraverse((index * STEP) + 2);
}
}
public void lastTraverse() {
lastTraverse(0);
}
private void lastTraverse(int index) {
if(arr == null || arr.length == 0) {
System.out.println("数组为空!");
}
//左递归
if((index * STEP) + 1 < arr.length) {
lastTraverse((index * STEP) + 1);
}
//右递归
if((index * STEP) + 2 < arr.length) {
lastTraverse((index * STEP) + 2);
}
System.out.print(arr[index] + " ");
}
}
运行结果
数组前序遍历
1 2 4 5 3 6 7
数组中序遍历
4 2 5 1 6 3 7
数组后序遍历
4 5 2 6 7 3 1
线索化二叉树
基本概念
因为一般的二叉树,叶子节点的左右指针都为空,这样就会造成空间的浪费。为了减少浪费,便有了线索化二叉树
n个结点有2n个指针,n-1条边;剩下的都是没用到的指针
- n个结点的二叉链表中含有 n+1 【公式 2n-(n-1)=n+1】个空指针域。利用二叉链表中的空指针域,存放指向该结点在某种遍历次序下的前驱和后继结点的指针
- 这种加上了线索的二叉链表称为线索链表,相应的二叉树称为线索二叉树
- 根据线索性质的不同,线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种
- 如果一个节点已经有了左右孩子,那么该节点就不能被线索化了,所以线索化二叉树后,节点的left和right有如下两种情况
- left可能指向的是左孩子,也可能指向的是前驱节点
- right可能指向的是右孩子,也可能指向的是后继节点
图解
中序线索化前
[
中序线索化后
实现代码
线索化思路
- 每个节点需要用两个变量来表示左右指针的类型(保存左右子树,还是前驱后继)
- 需要用两个变量来表示当前节点和当前节点的前驱节点
- 通过将当前节点的左指针指向前驱节点,来实现前驱节点的绑定
- 通过将前驱节点的右指针指向当前节点,来实现后继节点的绑定
遍历方式
- 各个节点可以通过线性的方式遍历,无需使用递归的方式遍历
- 首先有一个外循环,代替递归操作,循环条件的暂存节点不为空
- 第一个内循环用于找到第一个元素,然后打印
- 第二个循环用于找到节点的后继元素
- 最后将暂存节点令为右孩子
public class Demo1 {
public static void main(String[] args) {
//初始化节点
Student student1 = new Student(1, "1");
Student student2 = new Student(2, "3");
Student student3 = new Student(3, "6");
Student student4 = new Student(4, "8");
Student student5 = new Student(5, "10");
Student student6 = new Student(6, "14");
//手动创建二叉树
ThreadedBinaryTree tree = new ThreadedBinaryTree();
student1.setLeft(student2);
student1.setRight(student3);
student2.setLeft(student4);
student2.setRight(student5);
student3.setLeft(student6);
tree.setRoot(student1);
tree.midThreaded();
//得到第五个节点的前驱节点和后继节点
System.out.println("第五个节点的前驱节点和后继节点");
System.out.println(student5.getLeft());
System.out.println(student5.getRight());
//遍历线索化二叉树
System.out.println("遍历线索化二叉树");
tree.midThreadedTraverse();
}
}
class ThreadedBinaryTree {
private Student root;
/**
* 指向当前节点的前一个节点
*/
private Student pre;
public void setRoot(Student root) {
this.root = root;
}
/**
* 中序线索化
* @param node 当前节点
*/
private void midThreaded(Student node) {
if(node == null) {
return;
}
//左线索化
midThreaded(node.getLeft());
//线索化当前节点
//如果当前节点的左指针为空,就指向前驱节点,并改变左指针类型
if(node.getLeft() == null) {
node.setLeft(pre);
node.setLeftType(1);
}
//通过前驱节点来将右指针的值令为后继节点
if(pre != null && pre.getRight() == null) {
pre.setRight(node);
pre.setRightType(1);
}
//处理一个节点后,让当前节点变为下一个节点的前驱节点
pre = node;
//右线索化
midThreaded(node.getRight());
}
public void midThreaded() {
midThreaded(root);
}
/**
* 遍历线索化后的二叉树
*/
public void midThreadedTraverse() {
//暂存遍历到的节点
Student tempNode = root;
//非递归的方法遍历,如果tempNode不为空就一直循环
while(tempNode != null) {
//一直访问二叉树的左子树,直到某个节点的左子树指向前驱节点
while(tempNode.getLeftType() != 1) {
tempNode = tempNode.getLeft();
}
//找到了第一个节点
System.out.println(tempNode);
//再访问该节点的右子树,看是否保存了后继节点
//如果是,则打印该节点的后继节点信息
while(tempNode.getRightType() == 1) {
tempNode = tempNode.getRight();
System.out.println(tempNode);
}
tempNode = tempNode.getRight();
}
}
}
class Student {
private int id;
private String name;
private Student left;
private Student right;
/**
* 左、右指针的类型,0-->指向的是左右孩子,1-->指向的是前驱、后续节点
*/
private int leftType = 0;
private int rightType = 0;
public Student(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
运行结果
第五个节点的前驱节点和后继节点
Student{id=2, name='3'}
Student{id=1, name='1'}
遍历线索化二叉树
Student{id=4, name='8'}
Student{id=2, name='3'}
Student{id=5, name='10'}
Student{id=1, name='1'}
Student{id=6, name='14'}
Student{id=3, name='6'}
2、树的应用
堆排序
哈夫曼树
基本介绍
- 给定 n个权值作为 n个叶子结点,构造一棵二叉树,若该树的带权路径长度(wpl)达到最小,称这样的二叉树为最优二叉树,也称为哈夫曼树(Huffman Tree)
- 哈夫曼树是带权路径长度最短的树,权值较大的结点离根较近
重要概念
-
路径和路径长度:在一棵树中,从一个结点往下可以达到的孩子或孙子结点之间的通路,称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1,则从根结点到第L层结点的路径长度为 L-1
-
结点的权及带权路径长度
:若将树中结点赋给一个有着某种含义的数值,则这个数值称为该
结点的权
。
- 结点的带权路径长度为:从根结点到该结点之间的路径长度与该结点的权的乘积(W×L)
-
树的带权路径长度:树的带权路径长度规定为所有叶子结点的带权路径长度之和(W1×L1+W2×L2…),记为WPL(weighted pathlength) ,权值越大的结点离根结点越近的二叉树才是最优二叉树。
-
WPL最小的就是哈夫曼树
创建思路及图解
创建思路
- 从小到大进行排序, 将每一个数据,每个数据都是一个节点 , 每个节点可以看成是一颗最简单的二叉树
- 取出根节点权值最小的两颗二叉树
- 组成一颗新的二叉树, 该新的二叉树的根节点的权值是前面两颗二叉树根节点权值的和
- 再将这颗新的二叉树,以根节点的权值大小 再次排序,不断重复 1-2-3-4 的步骤,直到数列中,所有的数据都被处理,就得到一颗赫夫曼树
图解
以{3, 6, 7, 1, 8, 29, 13}为例
首先排序:{1, 3, 6, 7, 8, 13, 29}
[
实现代码
public class Demo1 {
public static void main(String[] args) {
int[] arr = {3, 6, 7, 1, 8, 29, 13};
HuffmanTree huffmanTree = new HuffmanTree();
Node root = huffmanTree.createHuffmanTree(arr);
root.preTraverse();
}
}
class HuffmanTree {
public Node createHuffmanTree(int[] arr) {
//创建数组用于存放Node
ArrayList<Node> nodes = new ArrayList<>(arr.length);
for(int value : arr) {
nodes.add(new Node(value));
}
//对集合中的元素进行排序
Collections.sort(nodes);
while(nodes.size() > 1) {
//左右子树在集合中对应的下标
int leftIndex = 0;
int rightIndex = 1;
//取出最小的两个节点
Node leftNode = nodes.get(leftIndex);
Node rightNode = nodes.get(rightIndex);
//创建父节点,并创建左右子树
Node parent = new Node(leftNode.value + rightNode.value);
parent.left = leftNode;
parent.right = rightNode;
//从集合中移除两个最小的节点,并将父节点放入集合中
nodes.add(parent);
nodes.remove(leftNode);
nodes.remove(rightNode);
//再次比较
Collections.sort(nodes);
}
//返回根节点
return nodes.get(0);
}
}
class Node implements Comparable<Node> {
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
/**
* 重写比较函数,用于排序
*/
@Override
public int compareTo(Node o) {
return value - o.value;
}
public void preTraverse() {
System.out.print(this.value + " ");
if (this.left != null) {
this.left.preTraverse();
}
if (this.right != null) {
this.right.preTraverse();
}
}
}
运行结果
前序遍历哈夫曼树
67 29 38 15 7 8 23 10 4 1 3 6 13
哈夫曼编码
原理及图解
前缀编码:任何一个字符的编码,都不会是其它的字符的前缀
- 统计需编码的字符串中,各个字符出现的次数:如helloworld
- h:1 e:1 w:1 r:1 d:1 o:2 l:3
- 将字符出现的次数作为权值,构建哈弗曼树。如下图
- 根据哈弗曼树进行编码,向左的路径为0,向右的路径为1
- 字符编码结果为:h:000 e:001 w:100 d:1010 r:1011 l:11 o:01
- 字符串编码结果为:000001111101100011011111010
实现代码
此处代码只实现了哈弗曼树的创建与每个字符的编码
public class Demo2 {
public static void main(String[] args) {
String str = "helloworld";
//哈夫曼编码
HuffmanCode huffmanCode = new HuffmanCode();
ArrayList<Code> list = huffmanCode.getList(str);
//构建哈弗曼树
Code root = huffmanCode.createHuffmanTree(list);
System.out.println("前序遍历哈弗曼树");
root.preTraverse();
//进行哈弗曼编码
Map<Byte, String> codeMap = root.getCodeMap();
System.out.println("哈弗曼编码");
System.out.println(codeMap);
}
}
class HuffmanCode {
public ArrayList<Code> getList(String codes) {
//得到字符串对应的字节数组
byte[] byteCodes = codes.getBytes();
//创建哈希表,用于存放数据及其权值(出现次数)
Map<Byte, Integer> dataAndWight = new HashMap<>();
for(byte b : byteCodes) {
Integer wight = dataAndWight.get(b);
//如果还没有该数据,就创建并让其权值为1
if(dataAndWight.get(b) == null) {
dataAndWight.put(b, 1);
}else {
//如果已经有了该数据,就让其权值加一
dataAndWight.put(b, wight+1);
}
}
//创建List,用于返回
ArrayList<Code> list = new ArrayList<>();
//遍历哈希表,放入List集合中
for(Map.Entry<Byte, Integer> entry : dataAndWight.entrySet()) {
list.add(new Code(entry.getKey(), entry.getValue()));
}
return list;
}
public Code createHuffmanTree(ArrayList<Code> lists) {
int leftIndex = 0;
int rightIndex = 1;
//根据权值进行排序
Collections.sort(lists);
while (lists.size() > 1) {
Code leftCode = lists.get(leftIndex);
Code rightCode = lists.get(rightIndex);
Code parent = new Code(null,leftCode.weight + rightCode.weight);
parent.left = leftCode;
parent.right = rightCode;
lists.add(parent);
lists.remove(leftCode);
lists.remove(rightCode);
//再次排序
Collections.sort(lists);
}
return lists.get(0);
}
}
class Code implements Comparable<Code> {
Byte data;
int weight;
Code left;
Code right;
private Map<Byte, String> codeMap = new HashMap<>();
public Code(Byte data, int weight) {
this.data = data;
this.weight = weight;
}
@Override
public String toString() {
return "Code{" +
"data=" + data +
", weight=" + weight +
'}';
}
public void preTraverse() {
System.out.println(this);
if(left != null) {
left.preTraverse();
}
if(right != null) {
right.preTraverse();
}
}
public Map<Byte, String> getCodeMap() {
return getCode(this, "", new StringBuilder());
}
/**
* 对哈弗曼树中的叶子节点进行编码
* @param node 根节点
* @param code 左子树为0,右子树为1
* @param stringBuilder 用于拼接的字符串
* @return
*/
private Map<Byte, String> getCode(Code node, String code, StringBuilder stringBuilder) {
//新建拼接路径
StringBuilder appendCode = new StringBuilder(stringBuilder);
appendCode.append(code);
if(node != null) {
//如果是非叶子结点,就继续向下遍历
if(node.data == null) {
getCode(node.left, "0", appendCode);
getCode(node.right, "1", appendCode);
}else {
//如果是叶子节点,就将哈弗曼编码放入哈希表中
codeMap.put(node.data, appendCode.toString());
}
}
return codeMap;
}
@Override
public int compareTo(Code o) {
return weight - o.weight;
}
}
运行结果
前序遍历哈弗曼树
Code{data=null, weight=10}
Code{data=null, weight=4}
Code{data=null, weight=2}
Code{data=114, weight=1}
Code{data=100, weight=1}
Code{data=null, weight=2}
Code{data=101, weight=1}
Code{data=119, weight=1}
Code{data=null, weight=6}
Code{data=108, weight=3}
Code{data=null, weight=3}
Code{data=104, weight=1}
Code{data=111, weight=2}
每个字符对应的哈弗曼编码
{114=000, 100=001, 101=010, 119=011, 104=110, 108=10, 111=111}
二叉排序树
基本介绍
二叉排序树:BST: (Binary Sort(Search) Tree), 对于二叉排序树的任何一个非叶子节点,要求左子节点的值比当前节点的值小,右子节点的值比当前节点的值大
- 特别说明:如果有相同的值,可以将该节点放在左子节点或右子节点
比如针对前面的数据 (7, 3, 10, 12, 5, 1, 9) ,对应的二叉排序树为:
操作思路
添加
- 根据插入节点的值来寻找其应该插入的位置
- 新插入的节点都是叶子节点
删除
删除叶子节点(如删除值为2节点)
- 找到待删除的节点
- 找到待删除节点的父节点
- 判断待删除节点是其父节点的左孩子还是右孩子,然后让其令为空
删除只有一颗子树的节点(如删除值为1的节点)
- 找到待删除的节点
- 找到待删除的节点的父节点
- 判断待删除节点是其父节点的左孩子还是右孩子
- 判断待删除节点的子树是其左孩子还是右孩子
- 让父节点指向待删除节点的子树指向待删除节点的子树
删除有两颗子树的节点(如删除值为3的节点)
- 找到待删除的节点
- 找到待删除的节点的父节点
- 判断待删除节点是其父节点的左孩子还是右孩子
- 顺着待删除节点的右子树,找到一个值最小的节点(该值的大小最接近待删除节点的值)
- 让父节点指向待删除节点的子树指向上一步找到的最小的节点
删除根节点(如删除值为7的节点)
- 删除根结点的方法和删除有两个子树的方法相似
- 找到一个接近根节点值的节点
- 删除该节点,将该节点的值赋值给根节点即可
实现代码
public class Demo1 {
public static void main(String[] args) {
int[] arr = {7, 3, 10, 12, 5, 1, 9, 2};
//创建二叉排序树
BinarySortTree binarySortTree = new BinarySortTree();
for (int i = 0; i < arr.length; i++) {
binarySortTree.addNode(new Node(arr[i]));
}
//前序遍历
System.out.println("前序遍历二叉排序树");
binarySortTree.preTraverse();
System.out.println();
//删除值为5、1、3、10、7的节点
binarySortTree.deleteNode(2);
binarySortTree.deleteNode(1);
binarySortTree.deleteNode(10);
binarySortTree.deleteNode(7);
System.out.println("前序遍历二叉排序树");
binarySortTree.preTraverse();
}
}
class BinarySortTree {
private Node root;
public void addNode(Node node) {
//如果根节点为空,就直接将该节点作为根节点
if (root == null) {
root = node;
return;
}
//否则就插入该节点到对应的位置
root.add(node);
}
public void preTraverse() {
if(root == null) {
System.out.println("二叉树为空");
} else {
root.preTraverse();
}
}
public Node getTargetNode(int targetValue) {
if (root == null) {
System.out.println("请先创建二叉树");
return null;
} else {
return root.getTargetNode(targetValue);
}
}
public Node getParentNode(int targetValue) {
if (root == null) {
System.out.println("请先创建二叉树");
return null;
} else {
return root.getParentNode(targetValue);
}
}
/**
* 删除节点
*
* @param targetValue 待删除节点的值
*/
public void deleteNode(int targetValue) {
if (root == null) {
System.out.println("请先创建二叉树");
return;
}
//找到待删除结点
Node targetNode = getTargetNode(targetValue);
if (targetNode == null) {
System.out.println("未找到该节点,删除失败");
return;
}
//如果只有一个根节点,就删除根节点
if(root.left == null && root.right == null) {
root = null;
System.out.println("删除成功");
return;
}
//得到其父节点
Node parentNode = getParentNode(targetValue);
//如果父节点为空(待删除节点为根节点)
if(parentNode == null) {
int minValue = getMinValue(targetNode.right);
deleteNode(minValue);
//根节点的值令为最接近的值
targetNode.value = minValue;
return;
}
//如果待删除节点为叶子节点
if (targetNode.left == null && targetNode.right == null) {
if (parentNode.left != null && parentNode.left == targetNode) {
//删除左子树
parentNode.left = null;
System.out.println("删除成功");
} else if (parentNode.right != null && parentNode.right == targetNode) {
//删除右子树
parentNode.right = null;
System.out.println("删除成功");
}
} else if (targetNode.left != null && targetNode.right != null) {
//待删除节点有左右子树
//得到并删除待删除节点右子树中值最小的节点
int minValue = getMinValue(targetNode.right);
deleteNode(minValue);
//将值最小的节点的值作为新的目标节点
targetNode.value = minValue;
} else {
//待删除节点只有左子树
if(targetNode.left != null) {
if(parentNode.left != null && parentNode.left == targetNode) {
parentNode.left = targetNode.left;
} else if (parentNode.right != null && parentNode.right == targetNode) {
parentNode.right = targetNode.left;
}
} else {
//待删除节点只有右子树
if(parentNode.left != null && parentNode.left == targetNode) {
parentNode.left = targetNode.right;
} else if (parentNode.right != null && parentNode.right == targetNode) {
parentNode.right = targetNode.right;
}
}
}
}
/**
* 找到以node为根节点的二叉树的最小节点的值
* @param node 作为根节点的节点
* @return 值最小的节点的值
*/
public int getMinValue(Node node) {
while(node.left != null) {
node = node.left;
}
//返回值最小的节点
return node.value;
}
}
class Node {
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
/**
* 添加节点到二叉排序树的对应位置
*
* @param node 待插入的节点
*/
public void add(Node node) {
if (node == null) {
return;
}
//如果该节点的值大待插入节点的值
if (value > node.value) {
//如果该节点的左子树为空,就直接插入
if (left == null) {
left = node;
} else {
left.add(node);
}
} else {
if (right == null) {
right = node;
} else {
right.add(node);
}
}
}
/**
* 前序遍历
*/
public void preTraverse() {
System.out.println(this);
if (left != null) {
left.preTraverse();
}
if (right != null) {
right.preTraverse();
}
}
/**
* 得到目标节点
*
* @param targetValue 目标节点的值
* @return 目标节点
*/
public Node getTargetNode(int targetValue) {
//如果当前节点就是目标节点,就返回
if (value == targetValue) {
return this;
}
//如果当前节点的值大于目标节点,就向左查找,反之向右查找
if (value > targetValue) {
if (left == null) {
return null;
} else {
return left.getTargetNode(targetValue);
}
} else {
if (right == null) {
return null;
} else {
return right.getTargetNode(targetValue);
}
}
}
/**
* 得到目标节点的父节点
*
* @param targetValue 目标节点的值
* @return 目标节点的父节点
*/
public Node getParentNode(int targetValue) {
//如果左右子树是目标节点,就返回该节点,否则继续向下查找
if (left != null && left.value == targetValue) {
return this;
} else if (right != null && right.value == targetValue) {
return this;
} else {
if (left != null && value > targetValue) {
return left.getParentNode(targetValue);
}
if (right != null && value <= targetValue) {
return right.getParentNode(targetValue);
} else {
//没有父节点(根节点)
return null;
}
}
}
}
运行结果
前序遍历二叉排序树
Node{value=7}
Node{value=3}
Node{value=1}
Node{value=2}
Node{value=5}
Node{value=10}
Node{value=9}
Node{value=12}
删除成功
删除成功
删除成功
删除成功
前序遍历二叉排序树
Node{value=9}
Node{value=3}
Node{value=5}
Node{value=12}
平衡二叉树
基本介绍
为什么需要平衡二叉树
- 如果由数组{1, 2, 3, 4}来构建一颗二叉排序树,得到的二叉树不仅没有体现其特点,反而还退化成了链表
简介
- 平衡二叉树也叫平衡二叉搜索树(Self-balancing binary search tree)又被称为AVL树,可以保证查询效率较高
- 具有以下特点:
- 它是一棵空树或它的左右两个子树的高度差的绝对值不超过 1,并且左右两个子树都是一棵平衡二叉树
- 平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等
- 下图所示的二叉树就是平衡二叉树
应用案例——左旋转
将由数列 {4,3,6,5,7,8}构建的二叉排序树,修改为一颗平衡二叉树
此处右子树的高度高于左子树,且差值大于1,所以需要进行左旋转,来降低右子树的高度
[
步骤
- 创建一个新节点,值为当前节点的值(4)
- 让新节点的左子树指向当前节点的左子树
- 让新节点的右子树指向当前节点的右子树的左子树
[
-
将当前节点的值改为其右子树的值
-
将当前节点的右子树变为其右子树的右子树
- 让当前节点的左子树指向新节点
[
整理后结果
应用案例——右旋转
当一颗二叉排序树的左子树高度大于右子树高度,且差值大于1时,需要进行右旋转,来降低左子树的高度
步骤
- 创建一个新节点,其值为当前节点的值
- 将新节点的右子树指向当前节点的右子树
- 将新节点的左子树指向当前节点的左子树的右子树
- 将当前节点的值改为其左子树的值
- 将当前节点的左子树指向其左子树的左子树
- 将当前节点的右子树指向新节点
应用案例——双旋转
某些时候,只进行左旋转或者右旋转,并不能将二叉排序树变为平衡二叉树。这时就需要进行双旋转,即同时进行左旋转和右旋转
- 进行左旋转时,如果当前节点右子树的左子树高于其右子树,需要先进行左旋转
- 进行右旋转时,如果当前节点左子树的右子树高于其左子树,需要先进性右旋转
[
实现代码
public class Demo1 {
public static void main(String[] args) {
int[] arr = {10, 7, 11, 5, 8, 9};
AVLTree tree = new AVLTree();
for (int value : arr) {
tree.addNode(new Node(value));
}
System.out.println("左右子树高度差值为 " + tree.getDifference());
System.out.println("前序遍历");
tree.preTraverse();
}
}
class AVLTree {
private Node root;
public void addNode(Node node) {
//如果根节点为空,就直接将该节点作为根节点
if (root == null) {
root = node;
return;
}
//否则就插入该节点到对应的位置
root.add(node);
}
public void preTraverse() {
if(root == null) {
System.out.println("二叉树为空");
} else {
root.preTraverse();
}
}
/**
* 找到以node为根节点的二叉树的最小节点的值
* @param node 作为根节点的节点
* @return 值最小的节点的值
*/
public int getMinValue(Node node) {
while(node.left != null) {
node = node.left;
}
//返回值最小的节点
return node.value;
}
public int getDifference() {
int leftHeight = root.getLeftHeight();
int rightHeight = root.getRightHeight();
//返回左右子树高度差值
return Math.abs(leftHeight - rightHeight);
}
}
class Node {
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
/**
* 添加节点到二叉排序树的对应位置
*
* @param node 待插入的节点
*/
public void add(Node node) {
if (node == null) {
return;
}
//如果该节点的值大待插入节点的值
if (value > node.value) {
//如果该节点的左子树为空,就直接插入
if (left == null) {
left = node;
} else {
left.add(node);
}
} else {
if (right == null) {
right = node;
} else {
right.add(node);
}
}
//如果右子树高度与左子树高度差值大于一,就进行左旋转
if(getRightHeight() - getLeftHeight() > 1) {
//如果当前节点右子树的左子树高度高于右子树,其右子树先进行右旋转
if(right.getLeftHeight() > right.getRightHeight()) {
right.rightRotate();
}
leftRotate();
}
//如果左子树高度与右子树的高度差值大于一,就进行右旋转
if(getLeftHeight() - getRightHeight() > 1) {
//如果当前节点左子树的右子树高度高于左子树,其左子树先进行左旋转
if(left.getRightHeight() > left.getLeftHeight()) {
left.leftRotate();
}
rightRotate();
}
}
/**
* 前序遍历
*/
public void preTraverse() {
System.out.println(this);
if (left != null) {
left.preTraverse();
}
if (right != null) {
right.preTraverse();
}
}
/**
* 获得该节点为根节点的树的高度
*
* @return 高度
*/
public int getHeight() {
return Math.max(left == null ? 0 : left.getHeight(), right == null ? 0 : right.getHeight()) + 1;
}
public int getLeftHeight() {
if(left == null) {
return 0;
} else {
return left.getHeight();
}
}
public int getRightHeight() {
if(right == null) {
return 0;
} else {
return right.getHeight();
}
}
/**
* 对二叉排序树进行左旋转(右子树高度较高)
*/
public void leftRotate() {
//创建新节点
Node newNode = new Node(value);
//新节点的左子树指向当前节点的左子树
newNode.left = left;
//新节点的右子树指向当前节点的右子树的左子树
newNode.right = right.left;
//当前节点的值变为其右子树的值
value = right.value;
//当前节点的右子树指向其右子树的右子树
right = right.right;
//当前节点的左子树指向新节点
left = newNode;
}
/**
* 对二叉树进行右旋转(左子树高度较高)
*/
public void rightRotate() {
//创建新节点,值为当前节点的值
Node newNode = new Node(value);
//新节点的右子树为当前节点的右子树
newNode.right = right;
//新节点的左子树为当前节点的左子树的右子树
newNode.left = left.right;
//当前节点的值为其左子树的值
value = left.value;
//当前节点的左子树为其左子树的左子树
left = left.left;
//当前节点的右子树为新节点
right = newNode;
}
}
运行结果
左右子树高度差值为 0
前序遍历
Node{value=8}
Node{value=7}
Node{value=5}
Node{value=10}
Node{value=9}
Node{value=11}
3、多叉树
基本介绍
在二叉树中,每个节点最多有一个数据项和两个子节点。如果允许每个节点可以有更多的数据项和更多的子节点,就是多叉树(multiway tree)
多叉树通过重新组织节点,减少树的高度,能对二叉树进行优化
2-3树
2-3树是最简单的B树结构,具有以下特点
- 2-3树的所有叶子节点都在同一层(只要是 B树都满足这个条件)
- 有两个子节点的节点叫二节点,二节点要么没有子节点,要么有两个子节点
- 有三个子节点的节点叫三节点,三节点要么没有子节点,要么有三个子节点
- 2-3树是由二节点和三节点构成的树(2和3)
2-3树插入规则
- 2-3树的所有叶子节点都在同一层.(只要是 B树都满足这个条件)
- 有两个子节点的节点叫二节点,二节点要么没有子节点,要么有两个子节点
- 有三个子节点的节点叫三节点,三节点要么没有子节点,要么有三个子节点
- 当按照规则插入一个数到某个节点时,不能满足上面三个要求,就需要拆,先向上拆,如果上层满,则拆本层,拆后仍然需要满足上面 3个条件
- 对于三节点的子树的值大小仍然遵守(BST 二叉排序树)的规则
- 左边的子树值小于父节点的值
- 中间的子树值在父节点的值之间
- 右边子树的值大于父节点的值
B树、B+和B*树
B树
)
- B树的阶:节点的最多子节点个数。比如 2-3树的阶是3,2-3-4树的阶是4
- B树的搜索,从根结点开始,对结点内的关键字(有序)序列进行二分查找,如果命中则结束,否则进入查询关键字所属范围的儿子结点;重复,直到所对应的儿子指针为空,或已经是叶子结点
- 关键字集合分布在整颗树中, 即叶子节点和非叶子节点都存放数据
- 搜索有可能在非叶子结点结束
- 其搜索性能等价于在关键字全集内做一次二分查找
B+树
- B+树是B树的变体,也是一种多路搜索树
- B+树的搜索与 B树也基本相同,区别是 B+树只有达到叶子结点才命中(B树可以在非叶子结点命中),其性能也等价于在关键字全集做一次二分查找
- 所有关键字都出现在叶子结点的链表中(即数据只能在叶子节点【也叫稠密索引】),且链表中的关键字(数据)恰好是有序的
- 不可能在非叶子结点命中
- 非叶子结点相当于是叶子结点的索引(稀疏索引),叶子结点相当于是存储(关键字)数据的数据层
- 更适合文件索引系统
- B树和 B+树各有自己的应用场景,不能说 B+树完全比 B树好,反之亦然
B*树
- B*树是 B+树的变体,在 B+树的非根和非叶子结点再增加指向兄弟的指针
- B*树定义了非叶子结点关键字个数至少为(2/3)M,即块的最低使用率为 2/3,而B+树的块的最低使用率为的1/2
- 从第 1个特点我们可以看出,B*树分配新结点的概率比B+树要低,空间使用率更高