堆排序
- 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。
- 堆是具有以下性质的完全二叉树：
①每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆
②每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆
注意 : 没有要求结点的左孩子的值和右孩子的值的大小关系。
大顶堆：
小顶堆：
基本思想：
①将待排序序列构造成一个大顶堆
②此时，整个序列的最大值就是堆顶的根节点。
③将其与末尾元素进行交换，此时末尾就为最大值。
④然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。
代码实现：
package com.jxust.tree;
import java.util.Arrays;
public class HeapSort {
public static void main(String[] args) {
int temp = 0;
//将数组进行升序排序
int arr[] = {4,6,8,5,9};
// adjustHeap(arr, 1, arr.length);
// System.out.println("第一次"+Arrays.toString(arr));
// adjustHeap(arr, 0, arr.length);
// System.out.println("第二次"+Arrays.toString(arr));
//将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆
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对应的非叶子结点的树调整成大顶堆
* @param arr 待调整的数组
* @param i 非叶子结点在数组中的索引
* @param length 表示对多少个元素继续调整，length是在逐渐减小
*/
public static void adjustHeap(int arr[],int i,int length) {
int temp = arr[i]; //先取出当前元素的值，保存在临时变量
//开始调整
/*
* k=i*2+1,k是i结点的左子结点
*/
for(int k=i*2+1;k<length;k=k*2+1) {
if(k+1<length && 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值放在调整后的位置
}
}
赫夫曼树（哈夫曼树）
- 给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度(wpl)达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。
- 赫夫曼树是带权路径长度最短的树，权值较大的结点离根较近。
- 路径和路径长度：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。
- 结点的权及带权路径长度：若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积
- 树的带权路径长度：树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WPL(weighted path length) ,权值越大的结点离根结点越近的二叉树才是最优二叉树。
- WPL最小的就是赫夫曼树
创建哈夫曼树
创建赫夫曼树的步骤：
①从小到大进行排序, 将每一个数据，每个数据都是一个节点 ， 每个节点可以看成是一颗最简单的二叉树
②取出根节点权值最小的两颗二叉树
③组成一颗新的二叉树, 该新的二叉树的根节点的权值是前面两颗二叉树根节点权值的和
④再将这颗新的二叉树，以根节点的权值大小 再次排序， 不断重复 1-2-3-4 的步骤，直到数列中，所有的数据都被处理，就得到一颗赫夫曼树
代码实现：
package huffmantree;
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加入到nodes中
nodes.add(parent);
}
//返回哈夫曼树的root结点
return nodes.get(0);
}
}
// 创建结点类
// 为了让Node对象持续排序Collections集合排序
// 让Node 实现Comparable接口
class Node implements Comparable<Node> {
int value; // 结点权值
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;
}
@Override
public String toString() {
return "Node [value=" + value + "]";
}
@Override
public int compareTo(Node o) {
// this.value - o.value表示从小到大排序
return this.value - o.value;
}
}
哈夫曼编码
赫夫曼码是可变字长编码(VLC)的一种。
例如：
构建一颗哈夫曼树：
注意：这个赫夫曼树根据排序方法不同，也可能不太一样，这样对应的赫夫曼编码也不完全一样，但是wpl 是一样的，都是最小的。
数据压缩：
①根据赫夫曼编码压缩数据的原理，需要创建 “i like like like java do you like a java” 对应的赫夫曼树.
②生成赫夫曼树对应的赫夫曼编码 , 如下表:空格=01 ，a=100， d=11000， u=11001 ，e=1110， v=11011， i=101 ，y=11010, j=0010， k=1111 ，l=000 ，o=0011
③使用赫夫曼编码来生成赫夫曼编码数据 ,即按照上面的赫夫曼编码，将"i like like like java do you like a java" 字符串生成对应的编码数据, 形式如下：1010100010111111110010001011111111001000101111111100100101001101110001110000011011101000111100101000101111111100110001001010011011100
数据解压：
①前面我们得到了赫夫曼编码和对应的编码byte[] , 即:[-88, -65, -56, -65, -56, -65, -55, 77, -57, 6, -24, -14, -117, -4, -60, -90, 28]
②现在要求使用赫夫曼编码， 进行解码，又重新得到原来的字符串"i like like like java do you like a java"
代码实现：
package huffmancode;
import java.io.FileInputStream;
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 content = "i like like like java do you like a java";
byte[] contentBytes = content.getBytes();
System.out.println(contentBytes.length);
byte[] huffmanCodesBytes = huffmanZip(contentBytes);
System.out.println("压缩后的结果是："+Arrays.toString(huffmanCodesBytes)+"长度 = "+huffmanCodesBytes.length);
byte[] sourceBytes = decode(huffmanCodes,huffmanCodesBytes);
System.out.println("原来的字符串 = "+new String(sourceBytes));
//分步过程
// 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));
//
}
//完成数据解压
/*
* 1、将huffmanCodeBytes重新转成哈夫曼编码对应的二进制的字符串
* 如：-88=>10101000
* 2、哈夫曼编码对应的二进制，对照哈夫曼编码，得到相应的字符串
*/
//完成对压缩数据的解码
/**
*
* @param huffmanCodes 哈夫曼编码表
* @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->a
Map<String, Byte> map = new HashMap<String,Byte>();
for(Map.Entry<Byte, String> entry: huffmanCodes.entrySet()) {
map.put(entry.getValue(), entry.getKey());
}
//创建要给集合，存放byte
List<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转成一个二进制字符串
* @param b 传入byte
* @param flag 标志是否需要不高为，如果是true，表示需要补高位
* @return 是该b对应的二进制字符串（注意是按补码返回）
*/
private static String byteToBitString(boolean flag, byte b) {
//使用变量保存 b
int 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);
//根据node创建哈夫曼树
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[]
* 即：10101000=>-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));
}
//统计返回byte[] huffmanCodeBytes 长度
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; //记录第几个byte
for(int i=0;i<stringBuilder.length();i+=8) { //每八位对应一个byte
String strByte;
if(i+8 > stringBuilder.length()) {
strByte = stringBuilder.substring(i);
}else {
strByte = stringBuilder.substring(i,i+8);
}
//将strByte转成byte，放入到humffmanCodeBytes
huffmanCodeBytes[index] = (byte)Integer.parseInt(strByte,2);
index++;
}
return huffmanCodeBytes;
}
//生成哈夫曼树对应的哈夫曼编码
//思路：
//1、将哈夫曼编码表存放在Map<Byte,String>形式
static Map<Byte,String> huffmanCodes = new HashMap<Byte,String>();
//2、在生成哈夫曼编码表示，需要去拼接路径，定义一个StringBuilder存储某个叶子节点的路径
static StringBuilder stringBuilder = new StringBuilder();
//为调用方便，我们重载getCodes
private 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加入到stringBuilder2
stringBuilder2.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形式
*/
private static List<Node> getNodes(byte[] bytes){
//1、创建一个ArrayList
ArrayList<Node> nodes = new ArrayList<Node>();
//存储每个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集合
//遍历map
for(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);
nodes.add(parent);
}
//最后的结点就是哈夫曼树的根节点
return nodes.get(0);
}
}
//创建Node，待数据和权值
class Node implements Comparable<Node>{
Byte data; //存放数据本身，如‘a’
int weight; //权值，表示字符出现的次数
Node left;
Node right;
public Node(Byte data, int weight) {
this.data = data;
this.weight = weight;
}
@Override
public int compareTo(Node o) {
//从小到大排序
return this.weight - o.weight;
}
@Override
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();
}
}
}
运行结果：
扫一扫
1663
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
