堆排序

1.基本介绍

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

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

大顶堆特点：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.代码实现

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.代码实现

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;
    }
}