树结构
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+树要低，空间使用率更高
33万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
