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

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

大顶堆特点：arr[i]>=arr[2i+1]&&arr[i]>=arr[2+2]

//i对应第几个节点，i从0开始编号

5.小顶堆举例说明

小顶堆：arr[i]<=arr[2i+1]&&arr[i]<=arr[2i+2]

//i对应第几个节点，i从0开始编号

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

2.基本思想

1)将待排序序列构建成一个堆

2)此时，整个序列的最大值就是堆顶的根节点。

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

4)然后将剩余-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。

3.代码实现

java复制代码package tree;import java.util.Arrays;/** * @author LeeZhi * @version 1.0 */public class HeapSort {    public static void main(String[] args) {        //要求将数组进行升序排序        int arr[] = {4, 6, 8, 5, 9};        heapSort(arr);    }    //编写一个堆排序的方法    public static void heapSort(int arr[]) {        int temp = 0;        System.out.println("堆排序!!");        //分布完成//        adjustHeap(arr,1, arr.length);//        System.out.println("第1次"+ 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));//9 6 8 5 4    }    //将一个数组(二叉树),调整成一个大顶堆    /**     * 功能: 完成将以 i 对应的非叶子节点的数调整成大顶堆     * 举例 举例int arr[]={4,6,8,5,9};=>i=1=>adjustHeap=>得到{4,9,8,5,6}     *     * @param arr    带调整的数组     * @param i      表示非叶子结点在数组中索引     * @param length 表示对多少个元素进行调整,length 是在逐渐减少     */    public static void adjustHeap(int arr[], int i, int length) {        int temp = arr[i];//先取出当前元素的值,保存在临时变量        //开始调整        //说明        //1.k=i*2+1k是i结点的左子结点        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {            if (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.基本介绍给定n个权值作为个叶子结点，构造一棵二叉树，若该树的带权路径长度(wpl)达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树Huffman Tree,还有的书翻译为霍夫曼树。赫夫曼树是带权路径长度最短的树，权值较大的结点离根较近。2.赫夫曼树几个重要概念和举例说明路径和路径长度：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1结点的权及带权路径长度：若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积树的带权路径长度：树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WPL(weighted path length),权值越大的结点离根结点越近的二叉树才是最优二叉树。WPL最小的就是赫夫曼树3.思路分析

构成赫夫曼树的步骤：

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

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

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

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

4.代码实现

java复制代码package huffmantree;import java.util.ArrayList;import java.util.Collections;import java.util.List;/** * @author LeeZhi * @version 1.0 */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 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 对象持续排序Collection集合排序//让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) {        //表示从小到大排序        return this.value-o.value;    }}