D11-堆排序和赫夫曼编码[Java数据结构和算法]

1.堆排序

　　1.1 基本介绍

　　（1）堆排序是利用堆这种数据结构设计的排序算法，是一种选择排序，他的最好最坏平均时间复杂度为O(nlogn)，是不稳定排序；

　　（2）堆是具有以下性质的完全二叉树，每个节点的值都大于或等于其左右孩子节点的值，称为大顶堆；每个节点的值都小于或等于其左右孩子节点的值，称为小顶堆；

　　（3）一般升序采用大顶堆，降序采用小顶堆；

　　1.2 堆排序的基本思想：

　　（1）将待排序的序列构造成一个大顶堆，利用数组；

　　（2）此时，整个序列的最大值就是堆顶的根节点；

　　（3）将其与末尾元素进行交换，此时末尾就为最大值；

　　（4）然后将剩余n-1个元素重新构造成一个堆，就会得到n个元素的次小值。反复执行后就能得到一个有序序列。

　　1.3 源代码

package cn.atguigu.Tree;

import java.util.Arrays;

public class HeapSort {

    public static void main(String[] args) {
        //要求把数组升序排列
        int arr[]= {4,6,8,5,9};
        heapSort(arr);
            
    }
    
    //编写一个堆排序的方法
    public static void heapSort(int arr[]) {
        System.out.println("堆排序");
        int temp=0;
        //将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆
        for(int i=arr.length/2-1;i>=0;i--) {
            adjustHeap(arr, i, arr.length);
        }
        
        /*
         * 1.将堆顶元素与末尾元素交换，将最大元素沉到数组末尾；
         * 2.重新调整结构，使其满足堆定义，然后继续交换堆顶元素和当前末尾元素，反复执行调整+交换步骤，直到整个有序序列
         */
        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对应的非叶子节点的树调整成大顶堆
     * [4,6,8,5,9]=>i=1=>adjustHeap()=>[4,9,8,5,6]
     * 如果再次调用adjustHeap 传入的是i=0=>[9,6,8,5,4]
     * @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值放到调整后的位置
    }
}

2.赫夫曼树

　　2.1 基本介绍

　　（1）给定n个权值作为n个叶子节点，构造一一颗二叉树，若该输的带权路径长度（wpl）达到最小，称这样的二叉树为最优二叉树，，也成为了赫夫曼树(Huffman Tree)；

　　（2）赫夫曼树是带权路径长度最短的树，权值较大的节点离根较近；

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

　　（4）节点的权及带权路径长度：若书中节点赋给一个有着某种含义的数值，则这个数值称为该节点的权。带权路径长度为从根节点到该节点之间的路径长度与该节点的权的乘积；

　　（5）树的带权路径长度：所有叶子节点的带权路径长度之和，即为WPL（Weighted path length），权值越大的节点离根节点越近。

　　2.2 创建赫夫曼树的思路

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

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

　　（3）组成一颗新的二叉树，该新的二叉树的根节点的权值是前面两颗二叉树根节点权值之和；

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

　　2.3 源代码

package cn.atguigu.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 node=createHuffmanTree(arr);//返回根节点
        
        preOrder(node);
    }
    
    //创建赫夫曼树的方法
    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);
            
            //取出根节点权值最小的两颗二叉树
            //1取出权值最小的节点
            Node leftNode=nodes.get(0);
            //2取出权值次小的节点
            Node rightNode=nodes.get(1);
            
            //构建一颗新的二叉树
            Node parent=new Node(leftNode.value+rightNode.value);
            parent.left=leftNode;
            parent.right=rightNode;
            
            //从ArrayList中删除处理过的二叉树
            nodes.remove(leftNode);
            nodes.remove(rightNode);
            
            //加入新处理后的二叉树
            nodes.add(parent);
        }
        return nodes.get(0);
    }
    
    public static void preOrder(Node root) {
        if(root!=null) {
            root.preOrder();
        }else {
            System.out.println("是空树，不能遍历");
        }
    }
}

//创建节点类
//为了让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 + "]";
    }
    
    public int compareTo(Node o) {
        //表示从小到大排序
        return this.value-o.value;
    }
}

 　

3.赫夫曼编码

　　3.1 赫夫曼编码介绍

　　（1）是一种编码方式，属于一种程序算法；

　　（2）赫夫曼编码是赫夫曼树在电讯通信中经典的应用；

　　（3）赫夫曼编码广泛地应用于数据文件压缩，其压缩率在20%-90%之间；

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

　　3.2 赫夫曼编码原理剖析（不会造成匹配的多义性，是无损压缩）

　　（1）将传输的字符串分解，得到各个字符对应的个数；

　　（2）按照上面字符出现的次数构建一颗赫夫曼树，次数作为权值；

　　（3）构造赫夫曼树；

　　（4）根据赫夫曼树，给各个字符规定编码：向左的路径为0，向右的路径为1；

　　（5）按照赫夫曼编码，得到字符串对应的编码；

　　注：赫夫曼树根据排序方法不同，也可能不太一样，这样对应的赫夫曼编码也不完全一样，但是wpl是一样的，都是最小的；

 　　3.3 赫夫曼编码进行压缩思路

　　（1）Node{data,weight,left,right}；

　　（2）得到字符串对应的byte[]数组；

　　（3）编写一个方法，将准备构建赫夫曼树的Node节点放到List中，形式为[Node[data=97,weight=5],Node[data=32,weight=9].......]，体现各个字符对应的个数；

　　（4）通过List创建对应的赫夫曼树；

　　（5）通过赫夫曼树得到每个字符对应的赫夫曼编码；

　　（6）得到字符串对应的赫夫曼编码，将其转换为字节数组，得到压缩；

　　3.4 赫夫曼编码解码思路

　　（1）将压缩数组重新转换成赫夫曼编码对应的二进制字符串；

　　（2）赫夫曼编码对应的二进制字符串对应赫夫曼编码转换成字符串；

 　　3.4 赫夫曼编码的实践-实现文件的压缩和解压

package cn.atguigu.huffmancode;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.sql.Array;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.xml.sax.InputSource;

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();
        byte[] huffmanCodeBytes=huffmanZip(contentBytes);
        System.out.println("压缩后的结果是："+Arrays.toString(huffmanCodeBytes));
        
        byte[] sourceBytes=decode(huffmanCodes, huffmanCodeBytes);
        System.out.println("原来的字符串"+new String(sourceBytes));
    
        //测试压缩文件
        String srcFile="C://Users//ZMQ//Pictures//1.bmp";
        String dstFile="C://Users//ZMQ//Pictures//1.zip";
        zipFile(srcFile, dstFile);
        System.out.println("压缩文件ok");
        
        //测试解压文件
        String zipFile="C://Users//ZMQ//Pictures//1.zip";
        dstFile="C://Users//ZMQ//Pictures//2.bmp";
        unZipFile(zipFile, dstFile);
        System.out.println("解压文件ok");
        }
    //编写方法，完成对压缩文件的解压
    /**
     * 
     * @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);
            //创建对象输入流
            ois=new ObjectInputStream(is);
            //读取压缩文件对应的压缩字节数组
            byte[] huffmanBytes=(byte[]) ois.readObject();
            //读取压缩文件对应的赫夫曼编码
            Map<Byte,String> huffmanCodes=(Map<Byte,String>)ois.readObject();
            //解码
            byte[] bytes=decode(huffmanCodes, huffmanBytes);
            //创建文件输出流
            os=new FileOutputStream(dstFile);
            os.write(bytes);
        }catch (Exception e) {
            System.out.println(e.getMessage());
        }finally {
            try {
                os.close();
                ois.close();
                is.close();
            }catch (Exception e) {
                System.out.println(e.getMessage());
            }
            
        }
    }
    
    //编写方法，将一个文件进行压缩
    /**
     * 
     * @param srcFile 传入希望压缩的文件的全路径
     * @param dstFile 压缩后将压缩文件存放在哪个目录
     */
    public static void zipFile(String srcFile,String dstFile) {
        //创建文件输出流
        OutputStream out=null;
        //创建文件输入流
        FileInputStream is=null;
        ObjectOutputStream oos=null;
        try {
            is=new FileInputStream(srcFile);
            //创建文件大小的字节数组
            byte[] bytes=new byte[is.available()];
            //读取文件
            is.read(bytes);
            //得到对应huffman编码,直接对源文件进行压缩
            byte[] hufffmanCodesBytes=huffmanZip(bytes);
            //创建文件输出流，准备压缩文件
            out=new FileOutputStream(dstFile);
            //创建一个和文件输出流相关的ObjectOutputStream
            oos=new ObjectOutputStream(out);
            //将压缩后的字节数组存放到压缩文件中
            oos.writeObject(hufffmanCodesBytes);
            //以对象流的方式写入赫夫曼编码，以便恢复源文件时使用
            oos.writeObject(huffmanCodes);
        }catch (Exception e) {
            System.out.println(e.getMessage());
        }finally {
            try {
                is.close();    
                oos.close();
                out.close();
            }catch (Exception e) {
                System.out.println(e.getMessage());
            }
        }
    }
    
    //完成数据的解压
    //思路
    //1.将huffmanCodeBytes重新转换成赫夫曼编码对应的二进制字符串
    //2.赫夫曼编码对应的二进制字符串对应赫夫曼编码转换成字符串
    
    //编写一个方法，完成对压缩数据的解码
    /**
     * 
     * @param huffmanCodes 赫夫曼编码表 map
     * @param huffmanBytes 赫夫曼编码得到的字节数组
     * @return 就是原来字符串对应的数组
     */
    private static byte[] decode(Map<Byte,String> huffmanCodes,byte[] huffmanBytes) {
        //1.先得到huffmanBytes对应的二进制字符串，形式1010100111000...
        StringBuilder stringBuilder=new StringBuilder();
        //将byte数组转成二进制的字符串
        for(int i=0;i<huffmanBytes.length;i++) {
            //判断是不是最有一个字节
            boolean flag=(i==huffmanBytes.length-1);
            stringBuilder.append(byteToBitString(!flag, huffmanBytes[i]));
        }
        
        //把字符串按照指定的赫夫曼编码进行解码
        //把赫夫曼编码表进行调换，因为需要反向查询
        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<Byte>();
        //1.可以理解成索引，不断扫描
        for(int i=0;i<stringBuilder.length();) {
            int count=1;//小的计算器
            boolean flag=true;
            Byte b=null;
            while(flag) {
                //取出一个'1' '0'
                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直接移动到i+count的位置
        }
        //当for循环结束后，list中存放所有的字符
        //把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 bytes
     * @param flag 表示是否需要补高位，如果是true，表示需要补高位
     * @return 是该b 对应的二进制的字符串（注意是按照补码的形式返回）
     */
    private static String byteToBitString(boolean flag,byte b) {
        //使用变量保存b
        int temp=b;//将b转换成int
        if(flag) {
            //如果是整数，还需要补高位
            temp|=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> node=getNodes(bytes);
        //将这些节点构成哈夫曼树,返回哈夫曼树的根节点
        Node HuffmanRoot=createHuffmanTree(node);
        //根据哈夫曼树形成哈夫曼编码数组,返回存放字符和字符对应哈夫曼编码的哈希表
        Map<Byte,String> huffmanMap=getCodes(HuffmanRoot);
        //进行压缩,得到压缩后的数组
        byte[] huffmanCodeBytes=zip(bytes, huffmanMap);
        return huffmanCodeBytes;
    }
    
    //编写方法，将字符串对应的byte[]数组，通过生成的赫夫曼编码表，返回一个赫夫曼编码 压缩后的byte[]
    /**
     * 
     * @param bytes 原始字符串对应的byte[]
     * @param huffmanCodes 生成的赫夫曼编码
     * @return 返回赫夫曼编码处理后的byte[]
     */
    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[]
        //统计返回byte[] huffmanCodeBytes长度
        int len=(stringBuilder.length()+7)/8;
        //创建 存储压缩后的byte数组
        //创建HuffmanCodeBytes
        byte[] huffmanCodeBytes=new byte[len];
        int index=0;//记录第几个byte
        for(int i=0;i<stringBuilder.length();i=i+8) {//因为每8位对应一个byte，所以步长+8
            String strByte;
            if(i+8>stringBuilder.length()) {
                strByte=stringBuilder.substring(i);
            }else {
                strByte=stringBuilder.substring(i,i+8);
            }
            
            //将strByte转换成byte，放到huffmanCodeBytes[]
            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就不处理
            if(node.data==null) {//如果node节点是非叶子节点
                //递归处理
                //向左递归
                getCodes(node.left, "0", stringBuilder2);
                //向右递归
                getCodes(node.right, "1", stringBuilder2);
            }else {//如果node节点是叶子节点
                //说明找到某个子节点的最后
                huffmanCodes.put(node.data, stringBuilder2.toString());
            }    
        }
    }
    
    //前序遍历方法
    public static void preOrder(Node root) {
        if(root!=null) {
            root.preOrder();
        }else {
            System.out.println("赫夫曼树为空，不能遍历");
        }
    }
    /**
     * 功能：得到每个字符对应的个数，存放在List集合中
     * @param bytes 接受字节数组
     * @return list
     */
    private static List<Node> getNodes(byte[] bytes){
        //创建ArrayList 存放节点
        ArrayList<Node> list=new ArrayList<Node>();
        
        //通过map获取得到对应的值和权值
        HashMap<Byte, Integer> counts=new HashMap<Byte, Integer>();
        for(byte b:bytes) {
            Integer count=counts.get(b);
            if(count==null) {
                counts.put(b, 1);
            }else {
                counts.put(b,count+1);
            }
        }
        //将map转换为node节点
        for(Map.Entry<Byte, Integer> entry:counts.entrySet()) {
            list.add(new Node(entry.getKey(), entry.getValue()));
        }
        return list;
    }
    
    //通过list创建对应的赫夫曼树
    private static Node createHuffmanTree(List<Node> list) {
        while(list.size()>1) {
            //排序,从小到大
            Collections.sort(list);
            //对第0个和第1个相加
            Node leftNode=list.get(0);
            Node rightNode=list.get(1);
            //创建父节点,它的根节点没有data
            Node parent=new Node(null, leftNode.weight+rightNode.weight);
            //挂起
            parent.left=leftNode;
            parent.right=rightNode;
            //删除第0，1个节点
            list.remove(leftNode);
            list.remove(rightNode);
            //添加父节点
            list.add(parent);
        }
        return list.get(0);//最后的节点就是荷夫曼树的根节点
    }
}
 //创建Node，带数据和权值
class Node implements Comparable<Node>{
    Byte data;//数据
    int weight;//权值，表示字符串出现的次数
    Node left;//指向左子节点
    Node right;//指向右子节点
    public Node(Byte data, int weight) {
        this.data = data;
        this.weight = weight;
    }
    @Override
    public String toString() {
        return "Node [data=" + data + ", weight=" + weight + "]";
    }
    @Override
    public int compareTo(Node o) {
        //从小到大排序
        return this.weight-o.weight;
    }
    public void preOrder() {
        System.out.println(this);
        if(this.left!=null) {
            this.left.preOrder();
        }
        if(this.right!=null) {
            this.right.preOrder();
        }
    }
}

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

　　（1）如果文件本身就是经过处理的，使用赫夫曼编码再压缩效率不会有明显的变化，比如视频，ppt等文件；

　　（2）赫夫曼编码是按照字节处理的，因此可以处理所有的文件（二进制文件，文本文件）；

　　（3）如果一个文件中内容重复的数据量不多，压缩效果也不明显。