文章目录

• 1.Java数据结构-树详解(两万字)
• • 1.1二叉树
  • • 1.1.1为什么需要树这种数据结构
    • 1.1.2树示意图
    • 1.1.3二叉树的概念
    • 1.1.4二叉树遍历的说明
    • 1.1.5二叉树遍历应用实例(前序,中序,后序)
    • 1.1.6二叉树-查找指定节点
    • 1.1.7二叉树-删除节点
    • 1.1.8以上所有代码实现：
  • 1.2顺序存储二叉树
  • • 1.2.1基本说明
    • 1.2.2特点
    • 1.2.3顺序存储二叉树遍历
    • 1.2.4应用实例(堆排序)
    • • 1.2.4.1堆排序基本介绍
      • 1.2.4.2堆排序基本思想
      • 1.2.4.3堆排序步骤图解说明
      • 1.2.4.4堆排序代码实现：
  • 1.3线索化二叉树
  • • 1.3.1基本介绍
    • 1.3.2应用案例
    • 1.3.3遍历线索化二叉树
  • 1.4赫夫曼树
  • • 1.4.1基本介绍
    • 1.4.2赫夫曼树几个重要概念和举例说明
    • 1.4.3赫夫曼树的代码实现
  • 1.5赫夫曼编码
  • • 1.5.1基本介绍
    • 1.5.1原理剖析
    • 1.5.2最佳实践--数据压缩和解压(编码解码)
    • 1.5.2最佳实践--文件压缩和解压(编码解码)
  • 1.6二叉排序树(BST)
  • • 1.6.1二叉排序树需求
    • 1.6.2解决方案分析
    • 1.6.3二叉排序树介绍
    • 1.6.4二叉排序树创建和遍历
    • 1.6.5二叉排序树的删除
    • 1.6.6代码实现
  • 1.7平衡二叉树(AVL树)
  • • 1.7.1二叉排序树的问题引入
    • 1.7.2平衡二叉树基本介绍
    • 1.7.3应用案例-单旋转(左旋转)
    • 1.7.4应用案例-单旋转(右旋转)
    • 1.7.5应用案例-双旋转
    • 1.7.6平衡二叉树代码实现
  • 1.8多路查找树
  • • 1.8.1二叉树的问题分析
    • 1.8.2多叉树
    • 1.8.3 B树的基本介绍
    • • 1.8.3.1 2-3树,2-3-4树的基本介绍
      • 1.8.3.2 2-3树,2-3-4树的基本介绍

1.Java数据结构-树详解(两万字)

1.1二叉树

1.1.1为什么需要树这种数据结构

1.数组存储方式的分析

优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低

2.链式存储方式的分析

优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可， 删除效率也很好)。

缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历)

3.树存储方式的分析

能提高数据存储，读取的效率, 比如利用 二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度。案例: [7, 3, 10, 1, 5, 9, 12]

1.1.2树示意图

1. 树的常用术语(结合示意图理解):
2. 节点
3. 根节点
4. 父节点
5. 子节点
6. 叶子节点 (没有子节点的节点)
7. 节点的权(节点值)
8. 路径(从root节点找到该节点的路线)
9. 层
10. 子树
11. 树的高度(最大层数)
12. 森林 :多颗子树构成森林

1.1.3二叉树的概念

1.树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
2.二叉树的子节点分为左节点和右节点。

示意图：

如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。

示意图：

如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。

示意图：

1.1.4二叉树遍历的说明

使用前序，中序和后序对下面的二叉树进行遍历.

前序遍历: 先输出父节点，再遍历左子树和右子树
中序遍历: 先遍历左子树，再输出父节点，再遍历右子树
后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点
小结: 看输出父节点的顺序，就确定是前序，中序还是后序

1.1.5二叉树遍历应用实例(前序,中序,后序)

思路分析示意图：

代码实现见下文

1.1.6二叉树-查找指定节点

要求：
1.请编写前序查找，中序查找和后序查找的方法。
2.并分别使用三种查找方式，查找 heroNO = 5 的节点
3.并分析各种查找方式，分别比较了多少次

思路分析图解：

代码实现见下文

1.1.7二叉树-删除节点

要求：
1.如果删除的节点是叶子节点，则删除该节点
2.如果删除的节点是非叶子节点，则删除该子树.

如果要删除的节点是非叶子节点，现在我们不希望将该非叶子节点为根节点的子树删除，需要指定规则, 后面在讲解 二叉排序树时，在给大家讲解具体的删除方法

3.测试，删除掉 5号叶子节点 和 3号子树.

1.1.8以上所有代码实现：

public class BinaryTreeDemo {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, "关胜");//说明，我们先手动创建该二叉树，后面我们学习递归的方式创建二叉树root.setLeft(node2);root.setRight(node3);node3.setRight(node4);node3.setLeft(node5);binaryTree.setRoot(root);//测试//System.out.println("前序遍历"); // 1,2,3,5,4//binaryTree.preOrder();//测试 //System.out.println("中序遍历");//binaryTree.infixOrder(); // 2,1,5,3,4////System.out.println("后序遍历");//binaryTree.postOrder(); // 2,5,4,3,1//前序遍历//前序遍历的次数 ：4 //System.out.println("前序遍历方式~~~");//HeroNode 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("中序遍历方式~~~");//HeroNode resNode = 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("后序遍历方式~~~");//HeroNode resNode = 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,4binaryTree.delNode(5);//binaryTree.delNode(3);System.out.println("删除后，前序遍历");binaryTree.preOrder(); // 1,2,3,4}}//定义BinaryTree 二叉树class BinaryTree {private HeroNode root;public void setRoot(HeroNode root) {this.root = root;}//删除结点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 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 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 this.root.postOrderSearch(no);}else {return null;}}}//先创建HeroNode 结点class HeroNode {private int no;private String name;private HeroNode left; //默认nullprivate HeroNode right; //默认nullpublic HeroNode(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 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;}@Overridepublic String toString() {return "HeroNode [no=" + no + ", name=" + name + "]";}//递归删除结点//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);}}//编写前序遍历的方法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);}//前序遍历查找/** *  * @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) {//判断当前结点的左子节点是否为空，如果不为空，则递归中序查找HeroNode 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 HeroNode postOrderSearch(int no) {//判断当前结点的左子节点是否为空，如果不为空，则递归后序查找HeroNode 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;}}

1.2顺序存储二叉树

1.2.1基本说明

从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组。

要求:
二叉树的结点，要求以数组的方式来存放，例如： arr : [1, 2, 3, 4, 5, 6, 7]
要求在遍历数组 arr时，仍然可以以前序遍历，中序遍历和后序遍历的方式完成结点的遍历

1.2.2特点

顺序存储二叉树的特点:

1.顺序二叉树通常只考虑完全二叉树
2.第n个元素的左子节点为 2 * n + 1
3.第n个元素的右子节点为 2 * n + 2
4.第n个元素的父节点为 (n-1) / 2
注：n 表示二叉树中的第几个元素(按0开始编号)

1.2.3顺序存储二叉树遍历

需求: 给你一个数组 {1,2,3,4,5,6,7}，要求以二叉树前序遍历的方式进行遍历。 前序遍历的结果应当为 1,2,4,5,3,6,7

public class ArrBinaryTreeDemo {public static void main(String[] args) {int[] arr = { 1, 2, 3, 4, 5, 6, 7 };//创建一个 ArrBinaryTreeArrBinaryTree arrBinaryTree = new ArrBinaryTree(arr);arrBinaryTree.preOrder(); // 1,2,4,5,3,6,7}}//编写一个ArrayBinaryTree, 实现顺序存储二叉树遍历class ArrBinaryTree {private int[] arr;//存储数据结点的数组public ArrBinaryTree(int[] arr) {this.arr = arr;}//重载preOrderpublic void preOrder() {this.preOrder(0);}//编写一个方法，完成顺序存储二叉树的前序遍历/** *  * @param index 数组的下标  */public void preOrder(int index) {//如果数组为空，或者 arr.length = 0if(arr == null || arr.length == 0) {System.out.println("数组为空，不能按照二叉树的前序遍历");}//输出当前这个元素System.out.println(arr[index]); //向左递归遍历if((index * 2 + 1) < arr.length) {preOrder(2 * index + 1 );}//向右递归遍历if((index * 2 + 2) < arr.length) {preOrder(2 * index + 2);}}}

1.2.4应用实例(堆排序)

十大排序算法中的堆排序，就会使用到顺序存储二叉树。

1.2.4.1堆排序基本介绍

1.堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。
2.堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆, 注意 : 没有要求结点的左孩子的值和右孩子的值的大小关系。
3.每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆

大顶堆举例说明：

我们对堆中的结点按层进行编号，映射到数组中就是下面这个样子:

大顶堆特点：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2] // i 对应第几个节点，i从0开始编号

小顶堆举例说明：

小顶堆特点：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2] // i 对应第几个节点，i从0开始编号

一般升序采用大顶堆，降序采用小顶堆

1.2.4.2堆排序基本思想

1.将待排序序列构造成一个大顶堆
2.此时，整个序列的最大值就是堆顶的根节点。
3.将其与末尾元素进行交换，此时末尾就为最大值。
4.然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，可以看到在构建大顶堆的过程中，元素的个数逐渐减少，最后就得到一个有序序列了

1.2.4.3堆排序步骤图解说明

1.2.4.4堆排序代码实现：

import java.text.SimpleDateFormat;import java.util.Arrays;import java.util.Date;public class HeapSort {public static void main(String[] args) {//要求将数组进行升序排序//int arr[] = {4, 6, 8, 5, 9};// 创建要给80000个的随机的数组int[] arr = new int[8000000];for (int i = 0; i < 8000000; i++) {arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数}System.out.println("排序前");Date data1 = new Date();SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String date1Str = simpleDateFormat.format(data1);System.out.println("排序前的时间是=" + date1Str);heapSort(arr);Date data2 = new Date();String date2Str = simpleDateFormat.format(data2);System.out.println("排序前的时间是=" + date2Str);//System.out.println("排序后=" + Arrays.toString(arr));}//编写一个堆排序的方法public static void heapSort(int arr[]) {int temp = 0;System.out.println("堆排序!!");////分步完成//adjustHeap(arr, 1, arr.length);//System.out.println("第一次" + Arrays.toString(arr)); // 4, 9, 8, 5, 6////adjustHeap(arr, 0, arr.length);//System.out.println("第2次" + Arrays.toString(arr)); // 9,6,8,5,4//完成我们最终代码//将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆for(int i = arr.length / 2 -1; i >=0; i--) {adjustHeap(arr, i, arr.length);}/* * 2).将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;　　3).重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。 */for(int j = arr.length-1;j >0; j--) {//交换temp = arr[j];arr[j] = arr[0];arr[0] = temp;adjustHeap(arr, 0, j); }//System.out.println("数组=" + Arrays.toString(arr)); }//将一个数组(二叉树), 调整成一个大顶堆/** * 功能： 完成 将 以 i 对应的非叶子结点的树调整成大顶堆 * 举例  int arr[] = {4, 6, 8, 5, 9}; => i = 1 => adjustHeap => 得到 {4, 9, 8, 5, 6} * 如果我们再次调用  adjustHeap 传入的是 i = 0 => 得到 {4, 9, 8, 5, 6} => {9,6,8,5, 4} * @param arr 待调整的数组 * @param i 表示非叶子结点在数组中索引 * @param lenght 表示对多少个元素继续调整， length 是在逐渐的减少 */public  static void adjustHeap(int arr[], int i, int lenght) {int temp = arr[i];//先取出当前元素的值，保存在临时变量//开始调整//说明//1. k = i * 2 + 1 k 是 i结点的左子结点for(int k = i * 2 + 1; k < lenght; k = k * 2 + 1) {if(k+1 < lenght && arr[k] < arr[k+1]) { //说明左子结点的值小于右子结点的值k++; // k 指向右子结点}if(arr[k] > temp) { //如果子结点大于父结点arr[i] = arr[k]; //把较大的值赋给当前结点i = k; //!!! i 指向 k,继续循环比较} else {break;//!}}//当for 循环结束后，我们已经将以i 为父结点的树的最大值，放在了 最顶(局部)arr[i] = temp;//将temp值放到调整后的位置}}

1.3线索化二叉树

先看一个问题：
将数列 {1, 3, 6, 8, 10, 14 } 构建成一颗二叉树.

问题分析:
当我们对上面的二叉树进行中序遍历时，数列为 {8, 3, 10, 1, 6, 14 }
但是 6, 8, 10, 14 这几个节点的 左右指针，并没有完全的利用上.
如果我们希望充分的利用 各个节点的左右指针， 让各个节点可以指向自己的前后节点,怎么办?
解决方案-线索二叉树

1.3.1基本介绍

1.n个结点的二叉链表中含有n+1 【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）

2.这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种

3.一个结点的前一个结点，称为前驱结点；一个结点的后一个结点，称为后继结点

1.3.2应用案例

将上面的二叉树，进行中序线索二叉树。中序遍历的数列为 {8, 3, 10, 1, 14, 6}

思路分析: 中序遍历的结果：{8, 3, 10, 1, 14, 6}

说明: 当线索化二叉树后，Node节点的 属性 left 和 right ，有如下情况:
left 指向的是左子树，也可能是指向的前驱节点. 比如 ① 节点 left 指向的左子树, 而 ⑩ 节点的 left 指向的就是前驱节点.
right指向的是右子树，也可能是指向后继节点，比如 ① 节点right 指向的是右子树，而⑩ 节点的right 指向的是后继节点.

1.3.3遍历线索化二叉树

说明：对前面的中序线索化的二叉树， 进行遍历
分析：因为线索化后，各个结点指向有变化，因此原来的遍历方式不能使用，这时需要使用新的方式遍历线索化二叉树，各个节点可以通过线型方式遍历，因此无需使用递归方式，这样也提高了遍历的效率。 遍历的次序应当和中序遍历保持一致。

代码实现：

import java.util.concurrent.SynchronousQueue;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.setLeft(node2);root.setRight(node3);node2.setLeft(node4);node2.setRight(node5);node3.setLeft(node6);//测试中序线索化ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();threadedBinaryTree.setRoot(root);threadedBinaryTree.threadedNodes();//测试: 以10号节点测试HeroNode leftNode = node5.getLeft();HeroNode rightNode = node5.getRight();System.out.println("10号结点的前驱结点是 ="  + leftNode); //3System.out.println("10号结点的后继结点是="  + rightNode); //1//当线索化二叉树后，能在使用原来的遍历方法//threadedBinaryTree.infixOrder();System.out.println("使用线索化的方式遍历 线索化二叉树");threadedBinaryTree.threadedList(); // 8, 3, 10, 1, 14, 6}}//定义ThreadedBinaryTree 实现了线索化功能的二叉树class ThreadedBinaryTree {private HeroNode root;//为了实现线索化，需要创建要给指向当前结点的前驱结点的指针//在递归进行线索化时，pre 总是保留前一个结点private HeroNode pre = null;public void setRoot(HeroNode root) {this.root = root;}//重载一把threadedNodes方法public void threadedNodes() {this.threadedNodes(root);}//遍历线索化二叉树的方法public void threadedList() {//定义一个变量，存储当前遍历的结点，从root开始HeroNode node = root;while(node != null) {//循环的找到leftType == 1的结点，第一个找到就是8结点//后面随着遍历而变化,因为当leftType==1时，说明该结点是按照线索化//处理后的有效结点while(node.getLeftType() == 0) {node = node.getLeft();}//打印当前这个结点System.out.println(node);//如果当前结点的右指针指向的是后继结点,就一直输出while(node.getRightType() == 1) {//获取到当前结点的后继结点node = node.getRight();System.out.println(node);}//替换这个遍历的结点node = node.getRight();}}//编写对二叉树进行中序线索化的方法/** *  * @param node 就是当前需要线索化的结点 */public void threadedNodes(HeroNode node) {//如果node==null, 不能线索化if(node == null) {return;}//(一)先线索化左子树threadedNodes(node.getLeft());//(二)线索化当前结点[有难度]//处理当前结点的前驱结点//以8结点来理解//8结点的.left = null , 8结点的.leftType = 1if(node.getLeft() == null) {//让当前结点的左指针指向前驱结点 node.setLeft(pre); //修改当前结点的左指针的类型,指向前驱结点node.setLeftType(1);}//处理后继结点if (pre != null && pre.getRight() == null) {//让前驱结点的右指针指向当前结点pre.setRight(node);//修改前驱结点的右指针类型pre.setRightType(1);}//!!! 每处理一个结点后，让当前结点是下一个结点的前驱结点pre = node;//(三)在线索化右子树threadedNodes(node.getRight());}//删除结点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 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 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 this.root.postOrderSearch(no);}else {return null;}}}//先创建HeroNode 结点class HeroNode {private int no;private String name;private HeroNode left; //默认nullprivate HeroNode right; //默认null//说明//1. 如果leftType == 0 表示指向的是左子树, 如果 1 则表示指向前驱结点//2. 如果rightType == 0 表示指向是右子树, 如果 1表示指向后继结点private int leftType;private int rightType;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;}public HeroNode(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 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;}@Overridepublic String toString() {return "HeroNode [no=" + no + ", name=" + name + "]";}//递归删除结点//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);}}//编写前序遍历的方法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);}//前序遍历查找/** *  * @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) {//判断当前结点的左子节点是否为空，如果不为空，则递归中序查找HeroNode 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 HeroNode postOrderSearch(int no) {//判断当前结点的左子节点是否为空，如果不为空，则递归后序查找HeroNode 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;}}

1.4赫夫曼树

1.4.1基本介绍

1)给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度(wpl)达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree), 还有的书翻译为霍夫曼树。

2)赫夫曼树是带权路径长度最短的树，权值较大的结点离根较近。

1.4.2赫夫曼树几个重要概念和举例说明

1)路径和路径长度：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1

2)结点的权及带权路径长度：若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积

3)树的带权路径长度：树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WPL(weighted path length) ,权值越大的结点离根结点越近的二叉树才是最优二叉树。

4)WPL最小的就是赫夫曼树

1.4.3赫夫曼树创建思路

给你一个数列 {13, 7, 8, 3, 29, 6, 1}，要求转成一颗赫夫曼树.

思路分析：

{13, 7, 8, 3, 29, 6, 1}

构成赫夫曼树的步骤：

1)从小到大进行排序, 将每一个数据，每个数据都是一个节点 ， 每个节点可以看成是一颗最简单的二叉树

2)取出根节点权值最小的两颗二叉树

3)组成一颗新的二叉树, 该新的二叉树的根节点的权值是前面两颗二叉树根节点权值的和

4)再将这颗新的二叉树，以根节点的权值大小 再次排序， 不断重复 1-2-3-4 的步骤，直到数列中，所有的数据都被处理，就得到一颗赫夫曼树

(5)图解：

1.4.3赫夫曼树的代码实现

import java.util.ArrayList;import java.util.Collections;import java.util.List;public class HuffmanTree {public static void main(String[] args) {int arr[] = { 13, 7, 8, 3, 29, 6, 1 };Node root = createHuffmanTree(arr);//测试一把preOrder(root); //}//编写一个前序遍历的方法public static void preOrder(Node root) {if(root != null) {root.preOrder();}else{System.out.println("是空树，不能遍历~~");}}// 创建赫夫曼树的方法/** *  * @param arr 需要创建成哈夫曼树的数组 * @return 创建好后的赫夫曼树的root结点 */public static Node createHuffmanTree(int[] arr) {// 第一步为了操作方便// 1. 遍历 arr 数组// 2. 将arr的每个元素构成成一个Node// 3. 将Node 放入到ArrayList中List<Node> nodes = new ArrayList<Node>();for (int value : arr) {nodes.add(new Node(value));}//我们处理的过程是一个循环的过程while(nodes.size() > 1) {//排序 从小到大 Collections.sort(nodes);System.out.println("nodes =" + nodes);//取出根节点权值最小的两颗二叉树 //(1) 取出权值最小的结点（二叉树）Node leftNode = nodes.get(0);//(2) 取出权值第二小的结点（二叉树）Node rightNode = nodes.get(1);//(3)构建一颗新的二叉树Node parent = new Node(leftNode.value + rightNode.value);parent.left = leftNode;parent.right = rightNode;//(4)从ArrayList删除处理过的二叉树nodes.remove(leftNode);nodes.remove(rightNode);//(5)将parent加入到nodesnodes.add(parent);}//返回哈夫曼树的root结点return nodes.get(0);}}// 创建结点类// 为了让Node 对象持续排序Collections集合排序// 让Node 实现Comparable接口class Node implements Comparable<Node> {int value; // 结点权值char c; //字符Node left; // 指向左子结点Node right; // 指向右子结点//写一个前序遍历public void preOrder() {System.out.println(this);if(this.left != null) {this.left.preOrder();}if(this.right != null) {this.right.preOrder();}}public Node(int value) {this.value = value;}@Overridepublic String toString() {return "Node [value=" + value + "]";}@Overridepublic int compareTo(Node o) {// TODO Auto-generated method stub// 表示从小到大排序return this.value - o.value;}}

1.5赫夫曼编码

1.5.1基本介绍

1)赫夫曼编码也翻译为 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式, 属于一种程序算法

2)赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一

3)赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%～90%之间

4)赫夫曼码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，称之为最佳编码

1.5.1原理剖析

通信领域中信息的处理方式1-定长编码

1. i like like like java do you like a java // 共40个字符(包括空格)

2. 105 32 108 105 107 101 32 108 105 107 101 32 108 105 107 101 32 106 97 118 97 32 100 111 32 121 111 117 32 108 105 107 101 32 97 32 106 97 118 97 //对应Ascii码

3. 01101001 00100000 01101100 01101001 01101011 01100101 00100000 01101100 01101001 01101011 01100101 00100000 01101100 01101001 01101011 01100101 00100000 01101010 01100001 01110110 01100001 00100000 01100100 01101111 00100000 01111001 01101111 01110101 00100000 01101100 01101001 01101011 01100101 00100000 01100001 00100000 01101010 01100001 01110110 01100001 //对应的二进制

4. 按照二进制来传递信息，总的长度是 359 (包括空格)

在线转码 工具 ：https://www.mokuge.com/tool/asciito16/

通信领域中信息的处理方式2-变长编码

1. i like like like java do you like a java // 共40个字符(包括空格)

2. d:1 y:1 u:1 j:2 v:2 o:2 l:4 k:4 e:4 i:5 a:5 :9 // 各个字符对应的个数

3. 0= , 1=a, 10=i, 11=e, 100=k, 101=l, 110=o, 111=v, 1000=j, 1001=u, 1010=y, 1011=d

   说明：按照各个字符出现的次数进行编码，原则是出现次数越多的，则编码越小，比如 空格出现了9 次， 编码为0 ,其它依次类推.

4. 按照上面给各个字符规定的编码，则我们在传输 “i like like like java do you like a java” 数据时，编码就是
   10010110100…

注：字符的编码都不能是其他字符编码的前缀，符合此要求的编码叫做前缀编码， 即不能匹配到重复的编码

通信领域中信息的处理方式3-赫夫曼编码

1. i like like like java do you like a java // 共40个字符(包括空格)

2. d:1 y:1 u:1 j:2 v:2 o:2 l:4 k:4 e:4 i:5 a:5 :9 // 各个字符对应的个数

3. 按照上面字符出现的次数构建一颗赫夫曼树, 次数作为权值.

步骤：

构成赫夫曼树的步骤：

1. 从小到大进行排序, 将每一个数据，每个数据都是一个节点 ， 每个节点可以看成是一颗最简单的二叉树

2. 取出根节点权值最小的两颗二叉树

3. 组成一颗新的二叉树, 该新的二叉树的根节点的权值是前面两颗二叉树根节点权值的和

4. 再将这颗新的二叉树，以根节点的权值大小 再次排序， 不断重复 1-2-3-4 的步骤，直到数列中，所有的数据都被处理，就得到一颗赫夫曼树

根据赫夫曼树，给各个字符，规定编码 ， 向左的路径为0，向右的路径为1 ， 编码如下:

o: 1000 u: 10010 d: 100110 y: 100111 i: 101

a : 110 k: 1110 e: 1111 j: 0000 v: 0001

l: 001 : 01

按照上面的赫夫曼编码，我们的"i like like like java do you like a java" 字符串对应的编码为 (注意这里我们使用的无损压缩)

1010100110111101111010011011110111101001101111011110100001100001110011001111000011001111000100100100110111101111011100100001100001110

长度为 ： 133

说明:

1)原来长度是 359 , 压缩了 (359-133) / 359 = 62.9%

2)此编码满足前缀编码, 即字符的编码都不能是其他字符编码的前缀。不会造成匹配的多义性

注意, 这个赫夫曼树根据排序方法不同，也可能不太一样，这样对应的赫夫曼编码也不完全一样，但是wpl 是一样的，都是最小的, 比如: 如果我们让每次生成的新的二叉树总是排在权值相同的二叉树的最后一个，则生成的二叉树为:

1.5.2最佳实践–数据压缩和解压(编码解码)

将给出的一段文本，比如 “i like like like java do you like a java” ， 根据前面的讲的赫夫曼编码原理，对其进行数据压缩处理 ，形式如 "1010100110111101111010011011110111101001101111011110100001100001110011001111000011001111000100100100110111101111011100100001100001110’’

压缩步骤1：根据赫夫曼编码压缩数据的原理，需要创建 “i like like like java do you like a java” 对应的赫夫曼树.

压缩步骤2：生成赫夫曼树对应的赫夫曼编码 , 如下表:
=01 a=100 d=11000 u=11001 e=1110 v=11011 i=101 y=11010 j=0010 k=1111 l=000 o=0011

压缩步骤3：使用赫夫曼编码来生成赫夫曼编码数据 ,即按照上面的赫夫曼编码，将"i like like like java do you like a java" 字符串生成对应的编码数据, 形式如下:
1010100010111111110010001011111111001000101111111100100101001101110001110000011011101000111100101000101111111100110001001010011011100

使用赫夫曼编码来解码数据，具体要求是：

1)前面我们得到了赫夫曼编码和对应的编码
byte[] , 即:[-88, -65, -56, -65, -56, -65, -55, 77 , -57, 6, -24, -14, -117, -4, -60, -90, 28]

2)现在要求使用赫夫曼编码， 进行解码，又重新得到原来的字符串"i like like like java do you like a java"

1.5.2最佳实践–文件压缩和解压(编码解码)

我们学习了通过赫夫曼编码对一个字符串进行编码和解码, 下面我们来完成对文件的压缩和解压

压缩具体要求：给你一个图片文件，要求对其进行无损压缩, 看看压缩效果如何。

思路：读取文件-> 得到赫夫曼编码表 -> 完成压缩

解压具体要求：将前面压缩的文件，重新恢复成原来的文件。

思路：读取压缩文件(数据和赫夫曼编码表)-> 完成解压(文件恢复)

代码实现：

import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.InputStream;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.io.OutputStream;import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;import java.util.HashMap;import java.util.List;import java.util.Map;public class HuffmanCode {public static void main(String[] args) {//测试压缩文件//String srcFile = "d://Uninstall.xml";//String dstFile = "d://Uninstall.zip";////zipFile(srcFile, dstFile);//System.out.println("压缩文件ok~~");//测试解压文件String zipFile = "d://Uninstall.zip";String dstFile = "d://Uninstall2.xml";unZipFile(zipFile, dstFile);System.out.println("解压成功!");/*String content = "i like like like java do you like a java";byte[] contentBytes = content.getBytes();System.out.println(contentBytes.length); //40byte[] huffmanCodesBytes= huffmanZip(contentBytes);System.out.println("压缩后的结果是:" + Arrays.toString(huffmanCodesBytes) + " 长度= " + huffmanCodesBytes.length);//测试一把byteToBitString方法//System.out.println(byteToBitString((byte)1));byte[] sourceBytes = decode(huffmanCodes, huffmanCodesBytes);System.out.println("原来的字符串=" + new String(sourceBytes)); // "i like like like java do you like a java"*///如何将 数据进行解压(解码)  //分步过程/*List nodes = getNodes(contentBytes);System.out.println("nodes=" + nodes);//测试一把，创建的赫夫曼树System.out.println("赫夫曼树");Node huffmanTreeRoot = createHuffmanTree(nodes);System.out.println("前序遍历");huffmanTreeRoot.preOrder();//测试一把是否生成了对应的赫夫曼编码Map huffmanCodes = getCodes(huffmanTreeRoot);System.out.println("~生成的赫夫曼编码表= " + huffmanCodes);//测试byte[] huffmanCodeBytes = zip(contentBytes, huffmanCodes);System.out.println("huffmanCodeBytes=" + Arrays.toString(huffmanCodeBytes));//17//发送huffmanCodeBytes 数组 */}//编写一个方法，完成对压缩文件的解压/** *  * @param zipFile 准备解压的文件 * @param dstFile 将文件解压到哪个路径 */public static void unZipFile(String zipFile, String dstFile) {//定义文件输入流InputStream is = null;//定义一个对象输入流ObjectInputStream ois = null;//定义文件的输出流OutputStream os = null;try {//创建文件输入流is = new FileInputStream(zipFile);//创建一个和  is关联的对象输入流ois = new ObjectInputStream(is);//读取byte数组  huffmanBytesbyte[] huffmanBytes = (byte[])ois.readObject();//读取赫夫曼编码表Map<Byte,String> huffmanCodes = (Map<Byte,String>)ois.readObject();//解码byte[] bytes = decode(huffmanCodes, huffmanBytes);//将bytes 数组写入到目标文件os = new FileOutputStream(dstFile);//写数据到 dstFile 文件os.write(bytes);} catch (Exception e) {// TODO: handle exceptionSystem.out.println(e.getMessage());} finally {try {os.close();ois.close();is.close();} catch (Exception e2) {// TODO: handle exceptionSystem.out.println(e2.getMessage());}}}//编写方法，将一个文件进行压缩/** *  * @param srcFile 你传入的希望压缩的文件的全路径 * @param dstFile 我们压缩后将压缩文件放到哪个目录 */public static void zipFile(String srcFile, String dstFile) {//创建输出流OutputStream os = null;ObjectOutputStream oos = null;//创建文件的输入流FileInputStream is = null;try {//创建文件的输入流is = new FileInputStream(srcFile);//创建一个和源文件大小一样的byte[]byte[] b = new byte[is.available()];//读取文件is.read(b);//直接对源文件压缩byte[] huffmanBytes = huffmanZip(b);//创建文件的输出流, 存放压缩文件os = new FileOutputStream(dstFile);//创建一个和文件输出流关联的ObjectOutputStreamoos = new ObjectOutputStream(os);//把 赫夫曼编码后的字节数组写入压缩文件oos.writeObject(huffmanBytes); //我们是把//这里我们以对象流的方式写入 赫夫曼编码，是为了以后我们恢复源文件时使用//注意一定要把赫夫曼编码 写入压缩文件oos.writeObject(huffmanCodes);}catch (Exception e) {// TODO: handle exceptionSystem.out.println(e.getMessage());}finally {try {is.close();oos.close();os.close();}catch (Exception e) {// TODO: handle exceptionSystem.out.println(e.getMessage());}}}//完成数据的解压//思路//1. 将huffmanCodeBytes [-88, -65, -56, -65, -56, -65, -55, 77, -57, 6, -24, -14, -117, -4, -60, -90, 28]//   重写先转成 赫夫曼编码对应的二进制的字符串 "1010100010111..."//2.  赫夫曼编码对应的二进制的字符串 "1010100010111..." =》 对照 赫夫曼编码  =》 "i like like like java do you like a java"//编写一个方法，完成对压缩数据的解码/** *  * @param huffmanCodes 赫夫曼编码表 map * @param huffmanBytes 赫夫曼编码得到的字节数组 * @return 就是原来的字符串对应的数组 */private static byte[] decode(Map<Byte,String> huffmanCodes, byte[] huffmanBytes) {//1. 先得到 huffmanBytes 对应的 二进制的字符串 ， 形式 1010100010111...StringBuilder stringBuilder = new StringBuilder();//将byte数组转成二进制的字符串for(int i = 0; i < huffmanBytes.length; i++) {byte b = huffmanBytes[i];//判断是不是最后一个字节boolean flag = (i == huffmanBytes.length - 1);stringBuilder.append(byteToBitString(!flag, b));}//把字符串安装指定的赫夫曼编码进行解码//把赫夫曼编码表进行调换，因为反向查询 a->100 100->aMap<String, Byte>  map = new HashMap<String,Byte>();for(Map.Entry<Byte, String> entry: huffmanCodes.entrySet()) {map.put(entry.getValue(), entry.getKey());}//创建要给集合，存放byteList<Byte> list = new ArrayList<>();//i 可以理解成就是索引,扫描 stringBuilder for(int  i = 0; i < stringBuilder.length(); ) {int count = 1; // 小的计数器boolean flag = true;Byte b = null;while(flag) {//1010100010111...//递增的取出 key 1 String key = stringBuilder.substring(i, i+count);//i 不动，让count移动，指定匹配到一个字符b = map.get(key);if(b == null) {//说明没有匹配到count++;}else {//匹配到flag = false;}}list.add(b);i += count;//i 直接移动到 count}//当for循环结束后，我们list中就存放了所有的字符  "i like like like java do you like a java"//把list 中的数据放入到byte[] 并返回byte b[] = new byte[list.size()];for(int i = 0;i < b.length; i++) {b[i] = list.get(i);}return b;} /** * 将一个byte 转成一个二进制的字符串, 如果看不懂，可以参考我讲的Java基础 二进制的原码，反码，补码 * @param b 传入的 byte * @param flag 标志是否需要补高位如果是true ，表示需要补高位，如果是false表示不补, 如果是最后一个字节，无需补高位 * @return 是该b 对应的二进制的字符串，（注意是按补码返回） */private static String byteToBitString(boolean flag, byte b) {//使用变量保存 bint temp = b; //将 b 转成 int//如果是正数我们还存在补高位if(flag) {temp |= 256; //按位与 256  1 0000 0000  | 0000 0001 => 1 0000 0001}String str = Integer.toBinaryString(temp); //返回的是temp对应的二进制的补码if(flag) {return str.substring(str.length() - 8);} else {return str;}}//使用一个方法，将前面的方法封装起来，便于我们的调用./** *  * @param bytes 原始的字符串对应的字节数组 * @return 是经过 赫夫曼编码处理后的字节数组(压缩后的数组) */private static byte[] huffmanZip(byte[] bytes) {List<Node> nodes = getNodes(bytes);//根据 nodes 创建的赫夫曼树Node huffmanTreeRoot = createHuffmanTree(nodes);//对应的赫夫曼编码(根据 赫夫曼树)Map<Byte, String> huffmanCodes = getCodes(huffmanTreeRoot);//根据生成的赫夫曼编码，压缩得到压缩后的赫夫曼编码字节数组byte[] huffmanCodeBytes = zip(bytes, huffmanCodes);return huffmanCodeBytes;}//编写一个方法，将字符串对应的byte[] 数组，通过生成的赫夫曼编码表，返回一个赫夫曼编码 压缩后的byte[]/** *  * @param bytes 这时原始的字符串对应的 byte[] * @param huffmanCodes 生成的赫夫曼编码map * @return 返回赫夫曼编码处理后的 byte[]  * 举例： String content = "i like like like java do you like a java"; =》 byte[] contentBytes = content.getBytes(); * 返回的是 字符串 "1010100010111111110010001011111111001000101111111100100101001101110001110000011011101000111100101000101111111100110001001010011011100" * => 对应的 byte[] huffmanCodeBytes  ，即 8位对应一个 byte,放入到 huffmanCodeBytes * huffmanCodeBytes[0] =  10101000(补码) => byte  [推导  10101000=> 10101000 - 1 => 10100111(反码)=> 11011000= -88 ] * huffmanCodeBytes[1] = -88 */private static byte[] zip(byte[] bytes, Map<Byte, String> huffmanCodes) {//1.利用 huffmanCodes 将  bytes 转成  赫夫曼编码对应的字符串StringBuilder stringBuilder = new StringBuilder();//遍历bytes 数组 for(byte b: bytes) {stringBuilder.append(huffmanCodes.get(b));}//System.out.println("测试 stringBuilder~~~=" + stringBuilder.toString());//将 "1010100010111111110..." 转成 byte[]//统计返回  byte[] huffmanCodeBytes 长度//一句话 int len = (stringBuilder.length() + 7) / 8;int len;if(stringBuilder.length() % 8 == 0) {len = stringBuilder.length() / 8;} else {len = stringBuilder.length() / 8 + 1;}//创建 存储压缩后的 byte数组byte[] huffmanCodeBytes = new byte[len];int index = 0;//记录是第几个bytefor (int i = 0; i < stringBuilder.length(); i += 8) { //因为是每8位对应一个byte,所以步长 +8String strByte;if(i+8 > stringBuilder.length()) {//不够8位strByte = stringBuilder.substring(i);}else{strByte = stringBuilder.substring(i, i + 8);}//将strByte 转成一个byte,放入到 huffmanCodeByteshuffmanCodeBytes[index] = (byte)Integer.parseInt(strByte, 2);index++;}return huffmanCodeBytes;}//生成赫夫曼树对应的赫夫曼编码//思路://1. 将赫夫曼编码表存放在 Map 形式//   生成的赫夫曼编码表{32=01, 97=100, 100=11000, 117=11001, 101=1110, 118=11011, 105=101, 121=11010, 106=0010, 107=1111, 108=000, 111=0011}static Map<Byte, String> huffmanCodes = new HashMap<Byte,String>();//2. 在生成赫夫曼编码表示，需要去拼接路径, 定义一个StringBuilder 存储某个叶子结点的路径static StringBuilder stringBuilder = new StringBuilder();//为了调用方便，我们重载 getCodesprivate static Map<Byte, String> getCodes(Node root) {if(root == null) {return null;}//处理root的左子树getCodes(root.left, "0", stringBuilder);//处理root的右子树getCodes(root.right, "1", stringBuilder);return huffmanCodes;}/** * 功能：将传入的node结点的所有叶子结点的赫夫曼编码得到，并放入到huffmanCodes集合 * @param node  传入结点 * @param code  路径： 左子结点是 0, 右子结点 1 * @param stringBuilder 用于拼接路径 */private static void getCodes(Node node, String code, StringBuilder stringBuilder) {StringBuilder stringBuilder2 = new StringBuilder(stringBuilder);//将code 加入到 stringBuilder2stringBuilder2.append(code);if(node != null) { //如果node == null不处理//判断当前node 是叶子结点还是非叶子结点if(node.data == null) { //非叶子结点//递归处理//向左递归getCodes(node.left, "0", stringBuilder2);//向右递归getCodes(node.right, "1", stringBuilder2);} else { //说明是一个叶子结点//就表示找到某个叶子结点的最后huffmanCodes.put(node.data, stringBuilder2.toString());}}}//前序遍历的方法private static void preOrder(Node root) {if(root != null) {root.preOrder();}else {System.out.println("赫夫曼树为空");}}/** *  * @param bytes 接收字节数组 * @return 返回的就是 List 形式   [Node[date=97 ,weight = 5], Node[]date=32,weight = 9]......], */private static List<Node> getNodes(byte[] bytes) {//1创建一个ArrayListArrayList<Node> nodes = new ArrayList<Node>();//遍历 bytes , 统计 每一个byte出现的次数->map[key,value]Map<Byte, Integer> counts = new HashMap<>();for (byte b : bytes) {Integer count = counts.get(b);if (count == null) { // Map还没有这个字符数据,第一次counts.put(b, 1);} else {counts.put(b, count + 1);}}//把每一个键值对转成一个Node 对象，并加入到nodes集合//遍历mapfor(Map.Entry<Byte, Integer> entry: counts.entrySet()) {nodes.add(new Node(entry.getKey(), entry.getValue()));}return nodes;}//可以通过List 创建对应的赫夫曼树private static Node createHuffmanTree(List<Node> nodes) {while(nodes.size() > 1) {//排序, 从小到大Collections.sort(nodes);//取出第一颗最小的二叉树Node leftNode = nodes.get(0);//取出第二颗最小的二叉树Node rightNode = nodes.get(1);//创建一颗新的二叉树,它的根节点 没有data, 只有权值Node parent = new Node(null, leftNode.weight + rightNode.weight);parent.left = leftNode;parent.right = rightNode;//将已经处理的两颗二叉树从nodes删除nodes.remove(leftNode);nodes.remove(rightNode);//将新的二叉树，加入到nodesnodes.add(parent);}//nodes 最后的结点，就是赫夫曼树的根结点return nodes.get(0);}}//创建Node ,待数据和权值class Node implements Comparable<Node>  {Byte data; // 存放数据(字符)本身，比如'a' => 97 ' ' => 32int weight; //权值, 表示字符出现的次数Node left;//Node right;public Node(Byte data, int weight) {this.data = data;this.weight = weight;}@Overridepublic int compareTo(Node o) {// 从小到大排序return this.weight - o.weight;}public String toString() {return "Node [data = " + data + " weight=" + weight + "]";}//前序遍历public void preOrder() {System.out.println(this);if(this.left != null) {this.left.preOrder();}if(this.right != null) {this.right.preOrder();}}}

1.6二叉排序树(BST)

1.6.1二叉排序树需求

给你一个数列 (7, 3, 10, 12, 5, 1, 9)，要求能够高效的完成对数据的查询和添加。

1.6.2解决方案分析

1.使用数组

1)数组未排序， 优点：直接在数组尾添加，速度快。 缺点：查找速度慢.

2)数组排序，优点：可以使用二分查找，查找速度快，缺点：为了保证数组有序，在添加新数据时，找到插入位置后，后面的数据需整体移动，速度慢。

2.使用链式存储-链表
不管链表是否有序，查找速度都慢，添加数据速度比数组快，不需要数据整体移动。

3.使用二叉排序树

1.6.3二叉排序树介绍

二叉排序树：BST: (Binary Sort(Search) Tree), 对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。

特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点

比如针对前面的数据 (7, 3, 10, 12, 5, 1, 9) ，对应的二叉排序树为：

1.6.4二叉排序树创建和遍历

一个数组创建成对应的二叉排序树，并使用中序遍历二叉排序树，比如: 数组为 Array(7, 3, 10, 12, 5, 1, 9) ， 创建成对应的二叉排序树为 :

1.6.5二叉排序树的删除

二叉排序树的删除情况比较复杂，有下面三种情况需要考虑

1)删除叶子节点 (比如：2, 5, 9, 12)

2)删除只有一颗子树的节点 (比如：1)

3)删除有两颗子树的节点. (比如：7, 3，10 )

示意图：

思路分析：

第一种情况:

删除叶子节点 (比如：2, 5, 9, 12)

思路：

(1) 需求先去找到要删除的结点 targetNode

(2) 找到targetNode 的 父结点 parent

(3) 确定 targetNode 是 parent的左子结点 还是右子结点

(4) 根据前面的情况来对应删除

左子结点 parent.left = null

右子结点 parent.right = null;

第二种情况: 删除只有一颗子树的节点 比如 1

思路：

(1) 需求先去找到要删除的结点 targetNode

(2) 找到targetNode 的 父结点 parent

(3) 确定targetNode 的子结点是左子结点还是右子结点

(4) targetNode 是 parent 的左子结点还是右子结点

(5) 如果targetNode 有左子结点

5. 1 如果 targetNode 是 parent 的左子结点

parent.left = targetNode.left;

5.2 如果 targetNode 是 parent 的右子结点

parent.right = targetNode.left;

(6) 如果targetNode 有右子结点

6.1 如果 targetNode 是 parent 的左子结点

parent.left = targetNode.right;

6.2 如果 targetNode 是 parent 的右子结点

parent.right = targetNode.right

情况三 ： 删除有两颗子树的节点. (比如：7, 3，10 )

思路：

(1) 需求先去找到要删除的结点 targetNode

(2) 找到targetNode 的 父结点 parent

(3) 从targetNode 的右子树找到最小的结点

(4) 用一个临时变量，将 最小结点的值保存 temp = 11

(5) 删除该最小结点

(6) targetNode.value = temp

1.6.6代码实现

public class BinarySortTreeDemo {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.add(new Node(arr[i]));}//中序遍历二叉排序树System.out.println("中序遍历二叉排序树~");binarySortTree.infixOrder(); // 1, 3, 5, 7, 9, 10, 12//测试一下删除叶子结点    binarySortTree.delNode(12); binarySortTree.delNode(5);    binarySortTree.delNode(10);    binarySortTree.delNode(2);    binarySortTree.delNode(3);binarySortTree.delNode(9);    binarySortTree.delNode(1);    binarySortTree.delNode(7);    System.out.println("root=" + binarySortTree.getRoot());System.out.println("删除结点后");binarySortTree.infixOrder();}}//创建二叉排序树class BinarySortTree {private Node root;public Node getRoot() {return root;}//查找要删除的结点public Node search(int value) {if(root == null) {return null;} else {return root.search(value);}}//查找父结点public Node searchParent(int value) {if(root == null) {return null;} else {return root.searchParent(value);}}//编写方法: //1. 返回的 以node 为根结点的二叉排序树的最小结点的值//2. 删除node 为根结点的二叉排序树的最小结点/** *  * @param node 传入的结点(当做二叉排序树的根结点) * @return 返回的 以node 为根结点的二叉排序树的最小结点的值 */public int delRightTreeMin(Node node) {Node target = node;//循环的查找左子节点，就会找到最小值while(target.left != null) {target = target.left;}//这时 target就指向了最小结点//删除最小结点delNode(target.value);return target.value;}//删除结点public void delNode(int value) {if(root == null) {return;}else {//1.需求先去找到要删除的结点  targetNodeNode targetNode = search(value);//如果没有找到要删除的结点if(targetNode == null) {return;}//如果我们发现当前这颗二叉排序树只有一个结点if(root.left == null && root.right == null) {root = null;return;}//去找到targetNode的父结点Node parent = searchParent(value);//如果要删除的结点是叶子结点if(targetNode.left == null && targetNode.right == null) {//判断targetNode 是父结点的左子结点，还是右子结点if(parent.left != null && parent.left.value == value) { //是左子结点parent.left = null;} else if (parent.right != null && parent.right.value == value) {//是由子结点parent.right = null;}} else if (targetNode.left != null && targetNode.right != null) { //删除有两颗子树的节点int minVal = delRightTreeMin(targetNode.right);targetNode.value = minVal;} else { // 删除只有一颗子树的结点//如果要删除的结点有左子结点 if(targetNode.left != null) {if(parent != null) {//如果 targetNode 是 parent 的左子结点if(parent.left.value == value) {parent.left = targetNode.left;} else { //  targetNode 是 parent 的右子结点parent.right = targetNode.left;} } else {root = targetNode.left;}} else { //如果要删除的结点有右子结点 if(parent != null) {//如果 targetNode 是 parent 的左子结点if(parent.left.value == value) {parent.left = targetNode.right;} else { //如果 targetNode 是 parent 的右子结点parent.right = targetNode.right;}} else {root = targetNode.right;}}}}}//添加结点的方法public void add(Node node) {if(root == null) {root = node;//如果root为空则直接让root指向node} else {root.add(node);}}//中序遍历public void infixOrder() {if(root != null) {root.infixOrder();} else {System.out.println("二叉排序树为空，不能遍历");}}}//创建Node结点class Node {int value;Node left;Node right;public Node(int value) {this.value = value;}//查找要删除的结点/** *  * @param value 希望删除的结点的值 * @return 如果找到返回该结点，否则返回null */public Node search(int value) {if(value == this.value) { //找到就是该结点return this;} else if(value < this.value) {//如果查找的值小于当前结点，向左子树递归查找//如果左子结点为空if(this.left  == null) {return null;}return this.left.search(value);} else { //如果查找的值不小于当前结点，向右子树递归查找if(this.right == null) {return null;}return this.right.search(value);}}//查找要删除结点的父结点/** *  * @param value 要找到的结点的值 * @return 返回的是要删除的结点的父结点，如果没有就返回null */public Node searchParent(int value) {//如果当前结点就是要删除的结点的父结点，就返回if((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {return this;} else {//如果查找的值小于当前结点的值, 并且当前结点的左子结点不为空if(value < this.value && this.left != null) {return this.left.searchParent(value); //向左子树递归查找} else if (value >= this.value && this.right != null) {return this.right.searchParent(value); //向右子树递归查找} else {return null; // 没有找到父结点}}}@Overridepublic String toString() {return "Node [value=" + value + "]";}//添加结点的方法//递归的形式添加结点，注意需要满足二叉排序树的要求public void add(Node node) {if(node == null) {return;}//判断传入的结点的值，和当前子树的根结点的值关系if(node.value < this.value) {//如果当前结点左子结点为nullif(this.left == null) {this.left = node;} else {//递归的向左子树添加this.left.add(node);}} else { //添加的结点的值大于 当前结点的值if(this.right == null) {this.right = node;} else {//递归的向右子树添加this.right.add(node);}}}//中序遍历public void infixOrder() {if(this.left != null) {this.left.infixOrder();}System.out.println(this);if(this.right != null) {this.right.infixOrder();}}}

1.7平衡二叉树(AVL树)

1.7.1二叉排序树的问题引入

看一个案例(说明二叉排序树可能的问题)

给你一个数列{1,2,3,4,5,6}，要求创建一颗二叉排序树(BST), 并分析问题所在

上面BST 存在的问题分析:

1)左子树全部为空，从形式上看，更像一个单链表.

2)插入速度没有影响

3)查询速度明显降低(因为需要依次比较), 不能发挥BST
的优势，因为每次还需要比较左子树，其查询速度比
单链表还慢

4)解决方案-平衡二叉树(AVL)

1.7.2平衡二叉树基本介绍

1)平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树， 可以保证查询效率较高。

2)具有以下特点：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。

1.7.3应用案例-单旋转(左旋转)

1)要求: 给你一个数列，创建出对应的平衡二叉树.数列 {4,3,6,5,7,8}

2)思路分析(示意图)

1.7.4应用案例-单旋转(右旋转)

1)要求: 给你一个数列，创建出对应的平衡二叉树.数列 {10,12, 8, 9, 7, 6}

2)思路分析(示意图)

1.7.5应用案例-双旋转

前面的两个数列，进行单旋转(即一次旋转)就可以将非平衡二叉树转成平衡二叉树,但是在某些情况下，单旋转不能完成平衡二叉树的转换。比如数列

int[] arr = { 10, 11, 7, 6, 8, 9 }; 运行原来的代码可以看到，并没有转成 AVL树

int[] arr = {2,1,6,5,7,3}; // 运行原来的代码可以看到，并没有转成 AVL树

问题分析与解决(示意图)：

1.7.6平衡二叉树代码实现

public class AVLTreeDemo {public static void main(String[] args) {//int[] arr = {4,3,6,5,7,8};//int[] arr = { 10, 12, 8, 9, 7, 6 };int[] arr = { 10, 11, 7, 6, 8, 9 };  //创建一个 AVLTree对象AVLTree avlTree = new AVLTree();//添加结点for(int i=0; i < arr.length; i++) {avlTree.add(new Node(arr[i]));}//遍历System.out.println("中序遍历");avlTree.infixOrder();System.out.println("在平衡处理~~");System.out.println("树的高度=" + avlTree.getRoot().height()); //3System.out.println("树的左子树高度=" + avlTree.getRoot().leftHeight()); // 2System.out.println("树的右子树高度=" + avlTree.getRoot().rightHeight()); // 2System.out.println("当前的根结点=" + avlTree.getRoot());//8}}// 创建AVLTreeclass AVLTree {private Node root;public Node getRoot() {return root;}// 查找要删除的结点public Node search(int value) {if (root == null) {return null;} else {return root.search(value);}}// 查找父结点public Node searchParent(int value) {if (root == null) {return null;} else {return root.searchParent(value);}}// 编写方法:// 1. 返回的 以node 为根结点的二叉排序树的最小结点的值// 2. 删除node 为根结点的二叉排序树的最小结点/** *  * @param node *     传入的结点(当做二叉排序树的根结点) * @return 返回的 以node 为根结点的二叉排序树的最小结点的值 */public int delRightTreeMin(Node node) {Node target = node;// 循环的查找左子节点，就会找到最小值while (target.left != null) {target = target.left;}// 这时 target就指向了最小结点// 删除最小结点delNode(target.value);return target.value;}// 删除结点public void delNode(int value) {if (root == null) {return;} else {// 1.需求先去找到要删除的结点 targetNodeNode targetNode = search(value);// 如果没有找到要删除的结点if (targetNode == null) {return;}// 如果我们发现当前这颗二叉排序树只有一个结点if (root.left == null && root.right == null) {root = null;return;}// 去找到targetNode的父结点Node parent = searchParent(value);// 如果要删除的结点是叶子结点if (targetNode.left == null && targetNode.right == null) {// 判断targetNode 是父结点的左子结点，还是右子结点if (parent.left != null && parent.left.value == value) { // 是左子结点parent.left = null;} else if (parent.right != null && parent.right.value == value) {// 是由子结点parent.right = null;}} else if (targetNode.left != null && targetNode.right != null) { // 删除有两颗子树的节点int minVal = delRightTreeMin(targetNode.right);targetNode.value = minVal;} else { // 删除只有一颗子树的结点// 如果要删除的结点有左子结点if (targetNode.left != null) {if (parent != null) {// 如果 targetNode 是 parent 的左子结点if (parent.left.value == value) {parent.left = targetNode.left;} else { // targetNode 是 parent 的右子结点parent.right = targetNode.left;}} else {root = targetNode.left;}} else { // 如果要删除的结点有右子结点if (parent != null) {// 如果 targetNode 是 parent 的左子结点if (parent.left.value == value) {parent.left = targetNode.right;} else { // 如果 targetNode 是 parent 的右子结点parent.right = targetNode.right;}} else {root = targetNode.right;}}}}}// 添加结点的方法public void add(Node node) {if (root == null) {root = node;// 如果root为空则直接让root指向node} else {root.add(node);}}// 中序遍历public void infixOrder() {if (root != null) {root.infixOrder();} else {System.out.println("二叉排序树为空，不能遍历");}}}// 创建Node结点class Node {int value;Node left;Node right;public Node(int value) {this.value = value;}// 返回左子树的高度public int leftHeight() {if (left == null) {return 0;}return left.height();}// 返回右子树的高度public int rightHeight() {if (right == null) {return 0;}return right.height();}// 返回 以该结点为根结点的树的高度public int height() {return Math.max(left == null ? 0 : left.height(), right == null ? 0 : right.height()) + 1;}//左旋转方法private void leftRotate() {//创建新的结点，以当前根结点的值Node newNode = new Node(value);//把新的结点的左子树设置成当前结点的左子树newNode.left = left;//把新的结点的右子树设置成带你过去结点的右子树的左子树newNode.right = right.left;//把当前结点的值替换成右子结点的值value = right.value;//把当前结点的右子树设置成当前结点右子树的右子树right = right.right;//把当前结点的左子树(左子结点)设置成新的结点left = newNode;}//右旋转private void rightRotate() {Node newNode = new Node(value);newNode.right = right;newNode.left = left.right;value = left.value;left = left.left;right = newNode;}// 查找要删除的结点/** *  * @param value *     希望删除的结点的值 * @return 如果找到返回该结点，否则返回null */public Node search(int value) {if (value == this.value) { // 找到就是该结点return this;} else if (value < this.value) {// 如果查找的值小于当前结点，向左子树递归查找// 如果左子结点为空if (this.left == null) {return null;}return this.left.search(value);} else { // 如果查找的值不小于当前结点，向右子树递归查找if (this.right == null) {return null;}return this.right.search(value);}}// 查找要删除结点的父结点/** *  * @param value *     要找到的结点的值 * @return 返回的是要删除的结点的父结点，如果没有就返回null */public Node searchParent(int value) {// 如果当前结点就是要删除的结点的父结点，就返回if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {return this;} else {// 如果查找的值小于当前结点的值, 并且当前结点的左子结点不为空if (value < this.value && this.left != null) {return this.left.searchParent(value); // 向左子树递归查找} else if (value >= this.value && this.right != null) {return this.right.searchParent(value); // 向右子树递归查找} else {return null; // 没有找到父结点}}}@Overridepublic String toString() {return "Node [value=" + value + "]";}// 添加结点的方法// 递归的形式添加结点，注意需要满足二叉排序树的要求public void add(Node node) {if (node == null) {return;}// 判断传入的结点的值，和当前子树的根结点的值关系if (node.value < this.value) {// 如果当前结点左子结点为nullif (this.left == null) {this.left = node;} else {// 递归的向左子树添加this.left.add(node);}} else { // 添加的结点的值大于 当前结点的值if (this.right == null) {this.right = node;} else {// 递归的向右子树添加this.right.add(node);}}//当添加完一个结点后，如果: (右子树的高度-左子树的高度) > 1 , 左旋转if(rightHeight() - leftHeight() > 1) {//如果它的右子树的左子树的高度大于它的右子树的右子树的高度if(right != null && right.leftHeight() > right.rightHeight()) {//先对右子结点进行右旋转right.rightRotate();//然后在对当前结点进行左旋转leftRotate(); //左旋转..} else {//直接进行左旋转即可leftRotate();}return ; //必须要!!!}//当添加完一个结点后，如果 (左子树的高度 - 右子树的高度) > 1, 右旋转if(leftHeight() - rightHeight() > 1) {//如果它的左子树的右子树高度大于它的左子树的高度if(left != null && left.rightHeight() > left.leftHeight()) {//先对当前结点的左结点(左子树)->左旋转left.leftRotate();//再对当前结点进行右旋转rightRotate();} else {//直接进行右旋转即可rightRotate();}}}// 中序遍历public void infixOrder() {if (this.left != null) {this.left.infixOrder();}System.out.println(this);if (this.right != null) {this.right.infixOrder();}}}

1.8多路查找树

1.8.1二叉树的问题分析

二叉树的操作效率较高，但是也存在问题, 请看下面的二叉树：

1)二叉树需要加载到内存的，如果二叉树的节点少，没有什么问题，但是如果二叉树的节点很多(比如1亿) 就存在如下问题:

2)问题1：在构建二叉树时，需要多次进行io操作(海量数据存在数据库或文件中)，节点海量，构建二叉树时，速度有影响

3)问题2：节点海量，也会造成二叉树的高度很大，会降低操作速度

1.8.2多叉树

1)在二叉树中，每个节点有数据项，最多有两个子节点。如果允许每个节点可以有更多的数据项和更多的子节点，就是多叉树（multiway tree）

2)后面我们讲解的2-3树，2-3-4树就是多叉树，多叉树通过重新组织节点，减少树的高度，能对二叉树进行优化。

3)举例说明(下面2-3树就是一颗多叉树）

1.8.3 B树的基本介绍

B树通过重新组织节点，降低树的高度，并且减少i/o读写次数来提升效率。

1)如图B树通过重新组织节点， 降低了树的高度

2)文件系统及数据库系统的设计者利用了磁盘预读原理，将一个节点的大小设为等于一个页(页得大小通常为4k)，这样每个节点只需要一次I/O就可以完全载入

3)将树的度M设置为1024，在600亿个元素中最多只需要4次I/O操作就可以读取到想要的元素, B树(B+)广泛应用于文件存储系统以及数据库系统中

1.8.3.1 2-3树,2-3-4树的基本介绍

2-3树基本介绍

2-3树是最简单的B树结构, 具有如下特点:

1)2-3树的所有叶子节点都在同一层(只要是B树都满足这个条件)

2)有两个子节点的节点叫二节点，二节点要么没有子节点，要么有两个子节点

3)有三个子节点的节点叫三节点，三节点要么没有子节点，要么有三个子节点

4)2-3树是由二节点和三节点构成的树。

2-3树应用案例

将数列{16, 24, 12, 32, 14, 26, 34, 10, 8, 28, 38, 20} 构建成2-3树，并保证数据插入的
大小顺序。(演示一下构建2-3树的过程.)

插入规则：

1)2-3树的所有叶子节点都在同一层.(只要是B树都满足这个条件)

2)有两个子节点的节点叫二节点，二节点要么没有子节点，要么有两个子节点.

3)有三个子节点的节点叫三节点，三节点要么没有子节点，要么有三个子节点

4)当按照规则插入一个数到某个节点时，不能满足上面三个要求，就需要拆，先向上拆，如果上层满，则拆本层，拆后仍然需要满足上面3个条件。

5)对于三节点的子树的值大小仍然遵守(BST 二叉排序树)的规则

234树概念和23树类似，也是一种B树。 如图:

1.8.3.2 2-3树,2-3-4树的基本介绍

B树的介绍

B-tree树即B树，B即Balanced，平衡的意思。有人把B-tree翻译成B-树，容易让人
产生误解。会以为B-树是一种树，而B树又是另一种树。实际上，B-tree就是指的B树。

前面已经介绍了2-3树和2-3-4树，他们就是B树(英语：B-tree 也写成B-树)，这里我们再做一个说明，我们在学习Mysql时，经常听到说某种类型的索引是基于B树或者B+树的，如图:

B树的说明

1)B树的阶：节点的最多子节点个数。比如2-3树的阶是3，2-3-4树的阶是4

2)B-树的搜索，从根结点开始，对结点内的关键字（有序）序列进行二分查找，如果命中则结束，否则进入查询关键字所属范围的儿子结点；重复，直到所对应的儿子指针为空，或已经是叶子结点

3)关键字集合分布在整颗树中, 即叶子节点和非叶子节点都存放数据.

4)搜索有可能在非叶子结点结束

5)其搜索性能等价于在关键字全集内做一次二分查找

B+树的介绍

B+树是B树的变体，也是一种多路搜索树。

B+树的说明:

1)B+树的搜索与B树也基本相同，区别是B+树只有达到叶子结点才命中（B树可以在非叶子结点命中），其性能也等价于在关键字全集做一次二分查找

2)所有关键字都出现在叶子结点的链表中（即数据只能在叶子节点【也叫稠密索引】），且链表中的关键字(数据)恰好是有序的。

3)不可能在非叶子结点命中

4)非叶子结点相当于是叶子结点的索引（稀疏索引），叶子结点相当于是存储（关键字）数据的数据层

5)更适合文件索引系统

6)B树和B+树各有自己的应用场景，不能说B+树完全比B树好，反之亦然.

B*树的介绍

B*树是B+树的变体，在B+树的非根和非叶子结点再增加指向兄弟的指针。

B*树的说明:

1)B*树定义了非叶子结点关键字个数至少为(2/3)*M，即块的最低使用率为2/3，而B+树的块的最低使用率为B+树的1/2。

2)从第1个特点我们可以看出，B*树分配新结点的概率比B+树要低，空间使用率更高