堆

1.1 堆的定义

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

堆的特性

1.它是完全二叉树

2.通常用数组来实现（如果一个节点的位置为k，则它的父节点的位置为[k/2],而它的两个节点的位置则分别为2k和2k+1）

3.每个节点都大于等于它的两个子节点（两个节点的顺序没有要求）

1.2 堆的API

/**
 * @Author blackcat
 * @create 2021/6/22 20:06
 * @version: 1.0
 * @description:
 */
public class Heap<T extends Comparable<T>> {

    //存储数据的数组
    private T[] data;
    //记录堆中元素个数
    private int size;

    //创建容量为capacity的Heap
    public Heap(int capacity) {
        this.data = (T[]) new Comparable[capacity];
        this.size = 0;
    }

    //判断堆中索引i处的元素是否小于索引j处的元素
    private boolean less(int i, int j) {

        return data[i].compareTo(data[j]) < 0;
    }

    //交换堆中i索引和j索引处的值
    private void exch(int i, int j) {
        T temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }

    //删除堆中最大的元素,并返回这个最大元素
    public T delMax() {
        T max = data[1];
        exch(1, size);
        data[size] = null;
        size--;
        sink(1);
        return max;
    }

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

    }

    //使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
    private void swim(int k) {
        //如果已经到了根结点，就不需要循环了
        while (k > 1) {
            //比较当前节点和父节点的大小
            if (less(k / 2, k)) {
                //父节点小于当前节点，交换节点
                exch(k / 2, k);
            }
            k = k / 2;
        }
    }

    //使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置
    private void sink(int k) {
        //没有子节点 
        while (2 * k <= size) {
            //默认左子节点大于右子节点  最大下标为左子节点下标
            int max = 2 * k;
            //当右子节点存在而且大于左子节点
            if ((2 * k + 1) <= size && less(2 * k, 2 * k + 1)) {
                // 最大下标为右子节点下标
                max = 2 * k + 1;
            }
            //如果k 的值小于 左右子节点的最大值，则跳出
            if (!less(k, max)) {
                break;
            }
            //交换k,max下标的值
            exch(k, max);
            k = max;
        }
    }


    public static void main(String[] args) {
        Heap<String> heap = new Heap<String>(20);
        heap.insert("A");
        heap.insert("B");
        heap.insert("C");
        heap.insert("G");
        heap.insert("D");
        heap.insert("E");
        heap.insert("F");
      
        String del;
        while ((del = heap.delMax()) != null) {
            System.out.println(del);
        }
    }
}

1.3 堆排序

/**
 * @Author blackcat
 * @create 2021/6/22 21:46
 * @version: 1.0
 * @description:
 */
public class HeapSort {

    //对source数组中的数据从小到大排序
    public static void sort(Comparable[] source) {
        //1.创建一个比原数组大1的数组
        Comparable[] heap = new Comparable[source.length + 1];
        //2.构造堆
        createHeap(source, heap);

        //3.堆排序
        // 3.1定义一个变量，记录heap中未排序的所有元素中最大的索引
        int size = heap.length - 1;
        while (size != 1) {
            //3.2交换heap中索引1处的元素和N处的元素
            exch(heap, 1, size);
            size--;
            //3.3对索引1处的元素在0~size范围内做下沉操作
            sink(heap, 1, size);
        }
        //4.heap中的数据已经有序，拷贝到source中
        System.arraycopy(heap, 1, source, 0, source.length);
    }

    //根据原数组source，构造出堆heap
    private static void createHeap(Comparable[] source, Comparable[] heap) {
        //1.把source中的数据拷贝到heap中，从heap的1索引处开始填充
        System.arraycopy(source, 0, heap, 1, source.length);
        //2.从heap索引的一半处开始倒叙遍历，对得到的每一个元素做下沉操作
        for (int i = (heap.length - 1) / 2; i > 0; i--) {
            sink(heap, i, heap.length - 1);
        }
    }

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

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

    //在heap堆中，对target处的元素做下沉，范围是0~range。
    private static void sink(Comparable[] heap, int target, int range) {
        //没有子节点
        while (2 * target <= range) {
            int max = 2 * target;
            if ((2 * target + 1 <= range) && less(heap, 2 * target, 2 * target + 1)) {
                max = 2 * target + 1;
            }
            if (less(heap, target, max)) {
                exch(heap, target, max);
            }
            target = max;
        }
    }

    public static void main(String[] args) throws Exception {
        //待排序数组
        String[] arr = {"S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E"};
        //通过HeapSort对数组中的元素进行排序
        HeapSort.sort(arr);
        //打印排序后数组中的元素
        System.out.println(Arrays.toString(arr));
    }
}