文章目录

一、堆排序
- 1.1 堆排序基本介绍
- 1.2 堆排序的基本思想
- 1.3 堆排序步骤图解
- 1.4 堆排序思路总结
- 1.5 堆排序代码实现
二、赫夫曼树
- 2.1 基本介绍
- 2.2 重要概念
- 1.3 赫夫曼树构建思路图解
- 1.4 赫夫曼树代码实现
三、赫夫曼编码
- 3.1 基本介绍
- 3.2 原理剖析
- 3.3 实践：数据压缩
- - 3.3.1 创建赫夫曼树
  - 3.3.2 生成赫夫曼编码和赫夫曼编码后的数据
- 3.4 实践：文件的压缩与解压
- - 3.4.1 压缩文件
  - 3.4.2 解压文件
  - 3.4.3 完整代码
- 3.5 赫夫曼编码压缩文件注意事项
四、二叉排序树
- 4.1 先看一个需求
- 4.2 解决方案分析
- 4.3 二叉排序树介绍
- 4.4 二叉排序树的创建和遍历
- 4.5 二叉排序树的删除
- 4.6 代码实现
五、平衡二叉树（AVL树）
- 5.1 看一个案例（说明二叉排序树可能的问题）
- 5.2 基本介绍
- 5.3 应用案例：单旋转（左旋转）
- 5.4 应用案例：单旋转（右旋转）
- 5.5 应用案例：双旋转
- 5.6 完整代码

一、堆排序

1.1 堆排序基本介绍

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

下面是大顶堆举例说明：

下面是小顶堆距离说明：

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

1.2 堆排序的基本思想

堆排序的基本思想是：

将待排序序列构造一个大顶堆
此时，整个序列的最大值就是堆顶的根节点
将其与末尾元素进行交换，此时末尾就为最大值
然后将剩余的 n-1 个元素重新构成一个堆，这样就会得到 n 个元素的次小值。如此反复进行，便能得到一个有序序列了

可以看到，在构建大顶堆的过程中，元素的个数逐渐减少，最后就得到一个有序序列了

1.3 堆排序步骤图解

要求：给你一个数组 {4, 6, 8, 5, 9} ，要求使用堆排序，将数组升序排序

步骤一：构造初始堆。将给定的无序序列构造为一个大顶堆（一般升序排序采用大顶堆，降序排序采用小顶堆）

假定给定的无序序列结构如下：

此时我们从最后一个非叶子节点开始（叶节点不用调整，第一个非叶子节点在数组中的索引是：arr.length/2-1=5/2-1=1，也就是下面的6节点），从左至右，从下至上进行调整

找到第二个非叶子节点4，由于 [4, 9, 8] 中 9 最大，所以 4 和 9 交换

这时，交换导致了子根 [4, 5, 6] 结构混乱，继续调整， [4, 5, 6] 中，6最大，交换 4 和 6

此时，我们就将一个无序序列构造成了一个大顶堆

步骤二：将堆顶元素与末尾元素进行交换，使末尾元素最大，然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素，如此反复进行交换、重建、交换。

将堆顶元素 9 和末尾元素 4 进行交换

重新调整结构，使其继续满足堆定义

再将堆顶元素 8 与末尾元素 5 进行交换，得到第二大元素 8

后续过程，继续进行调整、交换，如此反复进行，最终使得整个序列有序

1.4 堆排序思路总结

将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆
将堆顶元素与末尾元素交换，将最大元素“沉”到数组末端
重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序

1.5 堆排序代码实现

 public static int[] heapSort(int[] nums) {int start = (nums.length - 1) / 2;// 调整为大顶堆for (int i = start; i >= 0; i--) {maxHeap(nums, nums.length, i);}//for (int i = nums.length - 1; i >= 0; i--) {int temp = nums[0];nums[0] = nums[i];nums[i] = temp;maxHeap(nums, i, 0);}return nums;}// 转大顶堆的方法public static void maxHeap(int[] nums, int size, int index) {// 当前节点int self = index;// 左子节点int left = 2 * index + 1;// 和左子节点进行对比，选出最大的节点放到自身位置if (left < size && nums[self] < nums[left]) {int temp = nums[self];nums[self] = nums[left];nums[left] = temp;maxHeap(nums, size, left);}// 右子节点int right = 2 * index + 2;// 和右子节点进行对比，选出最大的节点放到自身位置if (right < size && nums[self] < nums[right]) {int temp = nums[self];nums[self] = nums[right];nums[right] = temp;maxHeap(nums, size, right);}}

二、赫夫曼树

2.1 基本介绍

给定 n 个权值作为 n 个叶子节点，构造一棵二叉树，若该树的带权路径长度（wpl）达到最小，称这样的二叉树为最优二叉树，也称哈夫曼树（Huffman Tree），还有的书翻译为霍夫曼树、赫夫曼树
赫夫曼树是带权路径长度最短的树，权值较大的节点离根节点较近

2.2 重要概念

路径和路径长度：在一颗树中，从一个节点往下可以达到的孩子或者孙子节点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根节点的层数为1，则从根节点到第 L 层节点的路径长度为 L-1
节点的权及带权路径长度：若将树中节点赋给一个有着某种含义的数值，则这个数值称为该节点的权。节点的带权路径长度为：从根节点到该节点之间的路径长度与该节点的权的乘积
树的带权路径长度：树的带权路径长度规定为所有叶子节点的带权路径长度之和，记为 WPL（Weighted Path Length）。权值越大的节点离根节点越近的二叉树才是最优二叉树
WPL 最小的二叉树就是赫夫曼树

下面是一些 WPL 计算的例子：

1.3 赫夫曼树构建思路图解

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

构成赫夫曼树的步骤：

将数列从小到大进行排序，将每一个数据，每个数据都是一个节点，每个节点可以看成是一颗最简单的二叉树
取出根节点权值最小的两颗二叉树
组成一颗新的二叉树，该新的二叉树的根节点的权值是前面两颗二叉树根节点的权值和
再将这颗新的二叉树。以根节点的权值大小，再次排序，不断重复这四个步骤（上面三个+当前一个），直到数列中所有的数据都被处理，就得到了一颗赫夫曼树

下面是示意图：

1.4 赫夫曼树代码实现

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接口static 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;}}}

输出：

nodes =[Node [value=1], Node [value=3], Node [value=6], Node [value=7], Node [value=8], Node [value=13], Node [value=29]]
nodes =[Node [value=4], Node [value=6], Node [value=7], Node [value=8], Node [value=13], Node [value=29]]
nodes =[Node [value=7], Node [value=8], Node [value=10], Node [value=13], Node [value=29]]
nodes =[Node [value=10], Node [value=13], Node [value=15], Node [value=29]]
nodes =[Node [value=15], Node [value=23], Node [value=29]]
nodes =[Node [value=29], Node [value=38]]
Node [value=67]
Node [value=29]
Node [value=38]
Node [value=15]
Node [value=7]
Node [value=8]
Node [value=23]
Node [value=10]
Node [value=4]
Node [value=1]
Node [value=3]
Node [value=6]
Node [value=13]

三、赫夫曼编码

3.1 基本介绍

赫夫曼编码也翻译为哈夫曼编码（Huffman Coding），又称霍夫曼编码，是一种编码方式，属于一种程序算法
赫夫曼编码是哈夫曼树在电讯通信中的经典的应用之一
赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%~90%之间
赫夫曼编码是可变字长编码（VLC）地一种，Huffman 于 1952 年提出一种编码方法，称之为最佳编码

3.2 原理剖析

通信领域中信息地处理方式1：定长编码

通信领域中信息地处理方式2：变长编码

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

步骤如下：

此编码满足前缀编码，即字符地编码都不能是其他字符编码的前缀。不会造成匹配的多义性，赫夫曼编码是无损处理方案

注意事项

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

3.3 实践：数据压缩

3.3.1 创建赫夫曼树

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

3.3.2 生成赫夫曼编码和赫夫曼编码后的数据

3.4 实践：文件的压缩与解压

3.4.1 压缩文件

3.4.2 解压文件

3.4.3 完整代码

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);/*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<Node> nodes = getNodes(contentBytes);System.out.println("nodes=" + nodes);//测试一把，创建的赫夫曼树System.out.println("赫夫曼树");Node huffmanTreeRoot = createHuffmanTree(nodes);System.out.println("前序遍历");huffmanTreeRoot.preOrder();//测试一把是否生成了对应的赫夫曼编码Map<Byte, String> 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 可以理解成就是索引,扫描 stringBuilderfor(int  i = 0; i < stringBuilder.length(); ) {int count = 1; // 小的计数器boolean flag = true;Byte b = null;while(flag) {//1010100010111...//递增的取出 key 1String 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<Byte,String> 形式//   生成的赫夫曼编码表{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 ,待数据和权值static 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();}}}}

3.5 赫夫曼编码压缩文件注意事项

如果文件本身就是经过压缩处理的，那么使用赫夫曼编码再压缩效率不会有明显变化，比如视频、PPT等等文件
赫夫曼编码是按照字节来处理的，因此可以处理所有的文件
如果一个文件中的内容，重复的数据不多，压缩效果也不会很明显

四、二叉排序树

4.1 先看一个需求

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

4.2 解决方案分析

使用数组

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

使用链表

不管链表是否有序，查找速度都慢，添加数据速度比数组快，不需要数据整体移动

使用二叉排序树

4.3 二叉排序树介绍

4.4 二叉排序树的创建和遍历

4.5 二叉排序树的删除

4.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();}//创建Node结点static 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();}}}//创建二叉排序树static 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("二叉排序树为空，不能遍历");}}}}

五、平衡二叉树（AVL树）

5.1 看一个案例（说明二叉排序树可能的问题）

5.2 基本介绍

5.3 应用案例：单旋转（左旋转）

5.4 应用案例：单旋转（右旋转）

5.5 应用案例：双旋转

解决思路分析：

当符合右旋转条件时，如果它的左子树的右子树的高度大于它的左子树高度，先对当前这个节点的左节点进行旋转，在对当前节点进行右旋转的操作即可

5.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}// 创建Node结点static 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();}}}// 创建AVLTreestatic class 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("二叉排序树为空，不能遍历");}}}}

【尚硅谷】Java数据结构与算法笔记11 - 树结构的实际应用相关推荐

用数组实现环形队列（尚硅谷Java数据结构与算法）
整个代码在文章最后面,gitee地址:java数据结构与算法: 自己学习与练习数据结构的仓库https://gitee.com/ALi_L/javaDataStructurs.git 环形队列的难点如 ...
Java 数据结构与算法（尚硅谷Java数据结构与算法）笔记目录
红色的表示重要,绿色的表示暂时还不懂而且很重要线性结构和非线性结构队列顺序队列循环队列链表链表(Linked List)介绍链表是有序的列表,但是它在内存中是存储如下小结: 1) 链表 ...
【尚硅谷】Java数据结构与算法笔记10 - 树结构的基础部分
文章目录一.二叉树 1.1 为什么需要树结构 1.1.1 数组存储方式的分析 1.1.2 链式存储方式的分析 1.1.3 树存储方式的分析 1.2 树示意图 1.3 二叉树的概念 1.4 二叉树 - ...
刚从阿里、头条面试回来，尚硅谷java数据结构与算法百度云
二.回顾整理阿里面试题基本就这样了,还有一些零星的问题想不起来了,答案也整理出来了. 自我介绍 JVM如何加载一个类的过程,双亲委派模型中有哪些方法? HashMap如何实现的? HashMap和C ...
尚硅谷Java数据结构与算法——054 冒泡排序
冒泡排序代码实现 package com.atguigu.sort;import java.util.Arrays;/*** @author WHT* @create 2021-06-15 11:1 ...
尚硅谷java数据结构与算法韩顺平数组实现队列问题
day2学习打卡:数组实现循环队列 package queue;import java.util.Scanner; //这里没有使用循环队列的思想所以造成了数组空间的浪费(数组空间不能复用) publ ...
尚硅谷Java数据结构和java算法，韩顺平数据结构和算法课后作业01
尚硅谷Java数据结构和java算法,韩顺平数据结构和算法课后作业第一题要求: 1)在前面的基础上,将稀疏数组保存到磁盘上,比如map.data 2) 恢复原来的数组时,读取map.data进行恢复 ...
尚硅谷01 数据结构与算法_数据结构与算法介绍+稀疏数组
数据结构与算法的关系几个实际编程中遇到的问题要想写出优秀的算法,首先应该能读懂别人写好的算法. 将生活中遇到的实际问题,使用程序来解决线性结构和非线性结构线性结构和非线性结构的关系: 数据结构 ...
尚硅谷Java数据结构与java算法全194章笔记整理
前言视频地址:https://www.bilibili.com/video/BV1E4411H73v?from=search&seid=13120683720695451628 评价:整个教 ...

【尚硅谷】Java数据结构与算法笔记11 - 树结构的实际应用