数据结构与算法（五）—— 堆

目录

1、认识堆

堆的特性：

2、堆的实现

1、insert方法的实现

2、delMax删除最大元素方法的实现

3、堆排序

---

1、认识堆

堆是计算机科学中一类特殊的数据结构的统称，堆通常可以被看做是一棵完全二叉树的数组对象。

堆的特性：

1、它是完全二叉树，除了树的最后一层结点不需要是满的，其它的每一层从左到右都是满的，如果最后一层结点不是满的，那么要求左满右不满。

2. 它通常用数组来实现。
具体方法就是将二叉树的结点按照层级顺序放入数组中，根结点在位置1，它的子结点在位置2和3，而子结点的子结点则分别在位置4,5,6和7，以此类推。 

 

结论：

如果一个结点的位置为k，则它的父结点的位置为[k/2],而它的两个子结点的位置则分别为2k和2k+1。

这样，在不使用指针的情况下，我们也可以通过计算数组的索引在树中上下移动：从a[k]向上一层，就令k等于k/2,向下一层就 令k等于2k或2k+1。

3.每个结点都大于等于它的两个子结点。这里要注意堆中仅仅规定了每个结点大于等于它的两个子结点，但这两个子结点的顺序并没有做规定，跟我们之前学习的二叉查找树是有区别的。

2、堆的实现

1、insert方法的实现

插入数据时要符合堆的原则

从索引1处开始插入数据，插入的数据不能大于它的父节点

如果往堆中新插入元素，我们只需要不断的比较新结点 a[k]和它的父结点a[k/2]的大小，然后根据结果完成数据元素的交换，就可以完成堆的有序调整

2、delMax删除最大元素方法的实现

当删除掉最大元素后，只需要将最后一个元素放到索引 1处，并不断的拿着当前结点a[k]与它的子结点a[2k]和a[2k+1]中的较大者交换位置，即可完成堆的有序调整

package tree;


//堆
public class Heap<T extends Comparable<T>> {
    //存储元素
    private T[] items;
    //元素个数
    private int N;

    public Heap(int capacity){
        this.items = (T[]) new Comparable[capacity+1];
        this.N = 0;
    }

    //判断堆中索引i处的元素是否小于索引j处的元素
    public boolean less(int i, int j){
        return items[i].compareTo(items[j])<0;
    }

    //交换堆中索引i和j的值
    public void exch(int i, int j){
        T t = items[i];
        items[i] = items[j];
        items[j] = t;
    }

    //往堆中插入一个元素
    public void insert(T t){
        items[++N] = t;
        swim(N);
    }

    //使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
    public void swim(int k){

        while(k>1){
            int p = k/2;
            if(less(p,k)){
                exch(p,k);
            }
            k = p;
        }
    }

    //删除堆中最大的元素，并返回这个最大的元素
    public T delMax(){
        exch(1,N);
        T t = items[N];
        items[N--] = null;
        sink(1);

        return t;
    }

    //使用下沉算法，使。。。
    public void sink(int k){
        while(2*k<=N){
            int max;
            if(2*k+1<=N){
                if(less(2*k,2*k+1)){
                    max = 2*k+1;
                }else{
                    max = 2*k;
                }
            }else{
                max = 2*k;
            }

            if(less(k,max)){
                exch(k,max);
                k = max;
            }else{
                break;
            }
        }
    }
}

测试：

package test;

import tree.Heap;

public class HeapTest {
    public static void main(String[] args) throws Exception {
        Heap<String> heap = new Heap<>(10);
        heap.insert("A");
        heap.insert("B");
        heap.insert("C");
        heap.insert("D");
        heap.insert("E");
        heap.insert("F");
        heap.insert("G");

        String del;
        while((del=heap.delMax())!=null){
            System.out.print(del+",");
        }
    }
}

3、堆排序

给定一个数组：

String[] arr = {"S","O","R","T","E","X","A","M","P","L","E"}

请对数组中的字符按从小到大排序。

堆的构造，最直观的想法就是另外再创建一个和新数组数组，然后从左往右遍历原数组，每得到一个元素后，添加到新数组中，并通过上浮，对堆进行调整，最后新的数组就是一个堆。

对构造好的堆，我们只需要做类似于堆的删除操作，就可以完成排序。

1.将堆顶元素和堆中最后一个元素交换位置；

2.通过对堆顶元素下沉调整堆，把最大的元素放到堆顶(此时最后一个元素不参与堆的调整，因为最大的数据已经到了数组的最右边)

3.重复1~2步骤，直到堆中剩最后一个元素。

package tree;

//堆排序
public class HeapSort {
    //判断索引i处的值是否小于j
    public static boolean less(Comparable[] heap, int i, int j){
        return heap[i].compareTo(heap[j])<0;
    }

    //交换索引i与j处的值
    public static void exch(Comparable[] heap, int i, int j){
        Comparable temp = heap[i];
        heap[i] = heap[j];
        heap[j] = temp;
    }

    //根据原始数组source,构造出堆heap
    public static void createHeap(Comparable[] source, Comparable[] heap){
        System.arraycopy(source,0,heap,1,source.length);
        for(int i = heap.length/2; i>0; i--){
            sink(heap, i,heap.length-1);
        }
    }

    //对source数组中的数据从大到小进行排列
    public static void sort(Comparable[] source){
        Comparable[] heap = new Comparable[source.length+1];
        createHeap(source,heap);

        int N = heap.length - 1;
        while(N != 1){
            exch(heap,1,N);
            N--;
            sink(heap,1,N);
        }

        System.arraycopy(heap,1,source,0,source.length);
    }

    //在heap堆中，对target处的元素做下沉
    public static void sink(Comparable[] heap, int target, int range){
        while(2*target <= range){
            int max;
            if(2*target+1<=range){
                if(less(heap,target*2,2*target+1)){
                    max = 2*target+1;
                }else{
                    max = 2*target;
                }
            }else{
                max = 2*target;
            }

            if(less(heap,target,max)){
                exch(heap,target,max);
            }else{
                break;
            }
            target = max;
        }
    }
}

package test;

import tree.HeapSort;

import java.util.Arrays;

public class HeapSortTest {
    public static void main(String[] args) {
        String[] arr = {"S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E"};
        HeapSort.sort(arr);

        System.out.println(Arrays.toString(arr));
    }
}