堆，堆排序

最新推荐文章于 2024-06-02 20:27:04 发布

原创最新推荐文章于 2024-06-02 20:27:04 发布 · 145 阅读

0 ·

CC 4.0 BY-SA版权

数据结构专栏收录该内容

4 篇文章

订阅专栏

本文深入探讨了堆数据结构的实现原理，包括完全二叉树的定义、堆的插入与删除操作，以及如何通过堆实现优先队列。同时，介绍了堆排序算法，并提供了构建堆的优化方法和原地排序的实现。

很久没写博客了还是抽时间写一写~

堆用来做优先队列插入与删除平均时间复杂度都为O(n)，以链表实现插入是O(1)，删除是O(n)，数组实现反之

JUC包就有优先队列的实现（后面深入并发后再补充）

判断：叶子节点为左节点时是完全二叉树，叶子节点为右节点时，不连续紧密排列，非完全二叉树

堆的定义：

堆是一颗完全二叉树。堆的基本要求是堆中所有结点的值必须大于（或小于）其孩子结点的值。

完全二叉树：

若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层有叶子结点，并且叶子结点都是从左到右依次排布。

堆是数据结构（以大根堆为例）

public class Heap {
    // 容量
    private int capbility;
    // 元素大小
    private int count;
    // 元素数组
    private int[] data;

    Heap(int capbility) {
        this.data = new int[capbility+1];
        this.capbility = capbility;
        this.count = 0;
    }

}

注意这里是capbility+1; 因为我们堆结点是从索引1开始，从1到capbility+1，data[0]是空

介绍两个性质

获取父结点 i/2

获取子结点 2*i 和 2*i+1

（如果是capbility则只是计算不同，获取父结点 (i-1)/2,子结点 2*i +1和 2*i+2 ）

然后是插入操作

插入到是插入到最后的结点位置，容量++，为了保持堆的性质，开始上升shiftUp操作，不断与父结点比较，如果大于父结点则交换，到一个节点的时候或者满足堆的性质

 public void insert(int item) {
        // FIXME 可改为扩容操作
        assert(count + 1 <= capbility);
        count++;
        data[count] = item;
        shiftUp(count);
    }

    private void shiftUp(int k) {
        while (k > 1 && data[k] > data[k/2])
        {
            // 与父结点交换
            SortHelper.swap(data,k,k/2);
            // 继续比较
            k = k/2;
        }
    }

删除操作

把data[1](ps：data[0]为空）删除，容量--，为了保持堆的性质，把data[count]换到data[1]，开始shiftDown操作，不断与子节点比较，与子节点中大的那个交换位置，到无子节点或者已经满足大于堆的性质

   public int delete(){
        assert( count > 0 );
        int item = data[1];
        data[1] = data[count];
        count --;
        shiftDown(1);
        return item;
    }

    private void shiftDown(int k) {
        // 如果有左节点
        while (2*k <= count){
            int j = 2*k;
            // data[j] 是 data[2*k]和data[2*k+1]中的最大值
            if (j+1 <= count && data[j] < data[j+1]) {
                j = j+1;
            }
            // 与子节点最大的进行比较 如果大于子节点 就直接跳出
            if( data[k] >= data[j] ) break;
            // 交换位置和索引继续比较
            SortHelper.swap(data,k,j);
            k = j;
        }
    }

测试结果

堆排序

由上面得出结论我们按照顺序每次把删除的元素就保存就是堆排序是不是很简单~

   public static void main(String[] args) {
        int n = 10;
        Heap heap = new Heap(n);
        for (int i = 0; i < 10; i++) {
            heap.insert((i+1)*2);
        }
        System.out.println("构建的堆："+Arrays.toString(heap.getData()));
        int[] arr = new int[n];
        for (int i = 0; i < n ; i++) {
            arr[i] = heap.delete();
        }
        System.out.println("排序后的数组："+Arrays.toString(arr));
    }

构建堆优化

其实构建堆不用每次都加一个元素就shiftUp操作

叶子节点一开始就一个无需进行任何操作，所以我们从第一个非叶子节点进行，也就是22（索引5）和之前的元素进行shiftDown操作，

获取第一个非叶子节点：获取最后一个叶子节点（data[count]）的父结点(data[count/2])

public void heapify(int[] arr, int n) {
        for( int i = 0 ; i < n ; i ++ )
            data[i+1] = arr[i];
        count = n;
        for (int i = n/2; i >= 1; i--) {
            shiftDown(i);
        }
    }

注意我们这里是>= 1，因为我们从索引1开始计算

原地排序（不需要借助辅助空间）

把最大的data[0]一直往数组最后放，放完该排序的数组大小-1，再重复进行这个操作

  public static void localSort(int[] arr,int n) {
        heapify(arr, n);
        for (int i = 0; i < n ; i++) {
            SortHelper.swap(arr,0,n-(i+1));
            __shiftDown(arr, n-(i+1), 0);
        }
    }

代码优化