索引堆的实现与优化

最新推荐文章于 2021-05-23 00:12:39 发布
最新推荐文章于 2021-05-23 00:12:39 发布
阅读量1k 收藏
点赞数
文章标签： java 算法 数据结构 python 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38032942/article/details/111158392
版权

在之前文章中记述了堆的实现(插入方式建堆、heapify方式建堆以及堆排序)《 堆的实现及其应用 》。今天来看看索引堆是个什么东西，对于我们所关心的这个数组而言，数组中的元素位置发生了改变。正是因为这些元素的位置发生了改变，我们才能将其构建为最大堆。 如果元素十分复杂的话，比如像每个位置上存的是一篇上万字的文章。那么交换它们之间的位置将产生大量的时间消耗。并且由于数组元素的位置在构建成堆之后发生了改变，那么我们就很难索引到它，很难去改变它。可以在每一个元素上再加上一个属性来表示原来的位置可以解决，但是这样的话，必须将这个数组遍历一下才能解决。针对以上问题，我们就需要引入索引堆(Index Heap)的概念。

索引堆基本实现

对于索引堆来说，我们将数据和索引这两部分分开存储。真正表征堆的这个数组是由索引这个数组构建成的。

mark

而在构建堆(以最大索引堆为例)的时候，比较的是data中的值(即原来数组中对应索引所存的值)，构建成堆的却是index域。而构建完之后，data域并没有发生改变，位置改变的是index域。

mark

那么现在这个最大堆该怎么解读呢？例如，堆顶元素为Index=10代表的就是索引为10的data域的值，即62。这时我们来看，构建堆的过程就是简单地索引之间的交换，索引就是简单的int型。效率很高。

现在如果我们想对这个数组进行一些改变，比如我们想将索引为7的元素值改为100，那我们需要做的就是将索引7所对应data域的28改为100。时间复杂度为O(1)。当然改完之后，我们还需要进行一些操作来维持最大堆的性质。不过调整的过程改变的依旧是index域的内容。

package imooc.heap;

public class MaxIndexHeap {
    protected int[] data;
    protected int[] indexes;

    //堆里有多少元素
    protected int count;

    //堆的容量
    protected int capacity;

    //因为0号位置不使用，所以capacity + 1
    public MaxIndexHeap(int capacity) {
        data = new int[capacity + 1];
        indexes = new int[capacity + 1];
        count = 0;
        this.capacity = capacity;
    }

    public MaxIndexHeap(int[] arr){
        data = new int[arr.length + 1];
        capacity = arr.length + 1;
        for (int i = 0; i < arr.length; i++) {
            data[i + 1] = arr[i];
        }
        count = arr.length;
        //从第一个不是叶子节点的位置开始
        for (int i = count / 2; i >= 1; i--) {
            shiftDown(i);
        }
    }

    //获取现存元素个数
    public int size(){
        return count;
    }

    //判断是否为空
    public boolean isEmpty(){
        return count == 0;
    }

    //插入数据(传入的i对于用户而言，是从0开始索引的)
    public void insert(int i, int item){
        assert i + 1 >= 1;
        i++; //i += 1
        //判断容量知否超出
        if(count + 1 >= capacity){
            //开始扩容
            resize();
        }
        //先存储到末尾
        data[i] = item;
        indexes[count + 1] = i;
        count++;
        //开始向上调堆
        shiftUp(count);
    }

    //取出数据的索引
    public int extractIndexMax(){
        if(count == 0) throw new RuntimeException("Heap is null");
        int ret = indexes[1] - 1;
        swapIndexes(1, count);
        count--;
        //开始向下调堆
        shiftDown(1);
        return ret;
    }

    //根据索引获得元素
    public int getItemByIndex(int index){
        return data[index];
    }

    //根据索引修改某个元素
    public void changeItem(int index, int newValue){
        index++;
        data[index] = newValue;
        //找到indexes[j] = index; j表示data[index]在堆中的位置
        //找到shiftUp(j)，再shiftDown(j)
        for (int j = 1; j <= count; j++) {
            if(indexes[j] == index){
                shiftUp(j);
                shiftDown(j);
                return;
            }
        }
    }

    //向下调堆
    private void shiftDown(int k) {
        while (2 * k <= count){
            int j = 2 * k;
            if(j + 1 <= count && data[indexes[j+1]] > data[indexes[j]]){
                j++;
            }
            if(data[indexes[k]] >= data[indexes[j]]){
                break;
            }
            swapIndexes(k, j);
            k = j;
        }
    }

    //向上调堆
    private void shiftUp(int k) {
        while(k > 1 && data[indexes[k / 2]] < data[indexes[k]]){
            swapIndexes(k/2, k);
            k /= 2;
        }
    }

    //交换对应两个位置的值(这是其实是交换索引的位置)
    private void swapIndexes(int i, int j){
        int tmp = indexes[i];
        indexes[i] = indexes[j];
        indexes[j] = tmp;
    }

    //扩充容量
    private void resize() {
        int[] newData = new int[capacity * 2];
        System.arraycopy(data, 0, newData, 0, count);
        data = newData;
        capacity *= 2;

        int[] newIndexes = new int[capacity * 2];
        System.arraycopy(indexes, 0, newIndexes, 0, count);
        indexes = newIndexes;
    }
}

索引堆的优化：反向查找

如何优化呢？ 反向查找：再建立一个数组，这个数组的下标和原始数据数组的下标的意思是一样的，就是索引的意思。而数组中存储的元素则是索引在索引堆数组中的位置。

mark

对反向查找表的维护就是，将索引堆中的值取出来(值就是索引值)，这个值就是方向查找表的下标，那这个下标应该对应的元素就是索引堆中的位置。

mark 
public class MaxIndexHeapOptimize {
    protected int[] data;
    protected int[] indexes;
    protected int[] reverse;

    //堆里有多少元素
    protected int count;

    //堆的容量
    protected int capacity;

    //因为0号位置不使用，所以capacity + 1
    public MaxIndexHeapOptimize(int capacity) {
        data = new int[capacity + 1];
        indexes = new int[capacity + 1];
        reverse = new int[capacity + 1];
        count = 0;
        for (int i = 0; i <= capacity ; i++) {
            reverse[i] = 0;
        }
        this.capacity = capacity;
    }

    public MaxIndexHeapOptimize(int[] arr){
        data = new int[arr.length + 1];
        capacity = arr.length + 1;
        for (int i = 0; i < arr.length; i++) {
            data[i + 1] = arr[i];
        }
        count = arr.length;
        //从第一个不是叶子节点的位置开始
        for (int i = count / 2; i >= 1; i--) {
            shiftDown(i);
        }
    }

    //获取现存元素个数
    public int size(){
        return count;
    }


    //判断是否为空
    public boolean isEmpty(){
        return count == 0;
    }

    //插入数据(传入的i对于用户而言，是从0开始索引的)
    public void insert(int i, int item){
        assert i + 1 >= 1;
        i++; //i += 1
        //判断容量知否超出
        if(count + 1 >= capacity){
            //开始扩容
            resize();
        }
        //先存储到末尾
        data[i] = item;
        indexes[count + 1] = i;
        reverse[i] = count + 1;
        count++;
        //开始向上调堆
        shiftUp(count);
    }

    //取出数据的索引
    public int extractIndexMax(){
        if(count == 0) throw new RuntimeException("Heap is null");
        int ret = indexes[1] - 1;
        swapIndexes(1, count);
        reverse[indexes[1]] = 1;
        reverse[indexes[count]] = 0;
        count--;
        //开始向下调堆
        shiftDown(1);
        return ret;
    }

    //取出数据的索引
    public int extractMax(){
        if(count == 0) throw new RuntimeException("Heap is null");
        int ret = data[indexes[1]];
        swapIndexes(1, count);
        reverse[indexes[1]] = 1;
        reverse[indexes[count]] = 0;
        count--;
        //开始向下调堆
        shiftDown(1);
        return ret;
    }

    //根据索引获得元素
    public int getItemByIndex(int index){
        if(contain(index)){
            throw new RuntimeException("This index is not in heap!");
        }
        return data[index];
    }

    //根据索引修改某个元素
    public void changeItemOld(int index, int newValue){
        index++;
        data[index] = newValue;
        //找到indexes[j] = index; j表示data[index]在堆中的位置
        //找到shiftUp(j)，再shiftDown(j)
        for (int j = 1; j <= count; j++) {
            if(indexes[j] == index){
                shiftUp(j);
                shiftDown(j);
                return;
            }
        }
    }

    //根据索引修改某个元素
    public void changeItem(int index, int newValue){
        if(contain(index)){
            throw new RuntimeException("This index is not in heap!");
        }
        index++;
        data[index] = newValue;
        //找到indexes[j] = index; j表示data[index]在堆中的位置
        int j = reverse[index]; //O(1)的时间复杂度
        shiftUp(j);
        shiftDown(j);
    }

    private boolean contain(int index) {
        if(!(index + 1 >= 0 && index + 1 <= capacity)){
            throw new RuntimeException("This index is illegal");
        }
        return reverse[index + 1] == 0;
    }

    //向下调堆
    private void shiftDown(int k) {
        while (2 * k <= count){
            int j = 2 * k;
            if(j + 1 <= count && data[indexes[j+1]] > data[indexes[j]]){
                j++;
            }
            if(data[indexes[k]] >= data[indexes[j]]){
                break;
            }
            swapIndexes(k, j);
            reverse[indexes[k]] = k;
            reverse[indexes[j]] = j;
            k = j;
        }
    }

    //向上调堆
    private void shiftUp(int k) {
        while(k > 1 && data[indexes[k / 2]] < data[indexes[k]]){
            swapIndexes(k/2, k);
            reverse[indexes[k/2]] = k/2;
            reverse[indexes[k]] = k;
            k /= 2;
        }
    }

    //交换对应两个位置的值(这是其实是交换索引的位置)
    private void swapIndexes(int i, int j){
        int tmp = indexes[i];
        indexes[i] = indexes[j];
        indexes[j] = tmp;
    }

    //扩充容量
    private void resize() {
        int[] newData = new int[capacity * 2];
        System.arraycopy(data, 0, newData, 0, count);
        data = newData;
        capacity *= 2;

        int[] newIndexes = new int[capacity * 2];
        System.arraycopy(indexes, 0, newIndexes, 0, count);
        indexes = newIndexes;
    }
}

其他和堆相关的问题

1、使用堆来实现优先队列

动态选择优先级最高的任务执行

2、实现多路归并排序

将整个数组分成n个子数组，子数组排完序之后，将每个子数组中最小的元素取出，放到一个最小堆里面，每次从最小堆里取出最小值放到归并结束的数组中，被取走的元素属于哪个子数组，就从哪个子数组中再取出一个补充到最小堆里面，如此循环，直到所有子数组归并到一个数组中。

赏

谢谢你请我喝咖啡

支付宝
微信
「已注销」
关注
索引堆
NinoSun的博客
11-25 374
什么是索引堆 索引堆是对堆这个数据结构的优化。 索引堆使用了一个新的int类型的数组，用于存放索引信息。 我们将会对索引数组进行堆排序，而不对数据直接进行堆排序。 相较于堆，优点如下： 1、优化了交换元素的消耗 如果堆中只放数字还好，但是如果存放的是大型字符串，经常交换会消耗很多资源。 2、加入的数据位置固定，方便寻找 比如我想在堆中给第七个进程提升优先级，那么我就需要直接去修改它。普通的堆因为要...
谈一谈mysql innoDB索引与优化
qq_44793993的博客
08-01 860
文章目录理解索引索引的几种实现实现对比B树和B+树对比mysql innoDB的索引索引的物理存储结构聚簇索引和辅助索引回表索引覆盖最左前缀索引失效索引的选择change buffer索引与约束自增索引设计原则 理解索引 索引的几种实现 实现对比 B树和B+树对比 mysql innoDB的索引 索引的物理存储结构 聚簇索引和辅助索引 回表 索引覆盖 最左前缀 索引失效 索引的选择 change buffer 索引与约束 自增 索引设计原则 ...
索引堆及其优化
段渣渣推轮子的飙车场
07-31 343
索引堆基本理解 最小生成树算法, 还是最短路径算法, 我们都需要使用索引堆进行优化。 索引堆解决普通堆的一些局限性 堆中存储的元素结构复杂，交换元素的代价很大 堆建成后改变了原本他在数组中的位置，我们如果想要修改某个元素的值，将会很困难，如果添加一个元素表示他原来的位置的话，我们需要遍历一遍堆才能找到进行修改，这样的性能也是低效的 对于索引堆来说，我们将数据和索引这两部分分开存储。真正表...
索引堆(Index Heap)及其优化 —— C++
点滴博客
07-25 926
引入索引堆的原因：堆构建前后数组元素位置发生改变，其具有一定的局限性： 1.元素是非常复杂的结构，交换消耗本身是巨大的，比如每一个元素都是一篇十万字以上的文章，对于这些大型的字符串，让它们来回交换，会产生大量的性能上的消耗 2.由于整个元素在数组中的位置发生改变，使得当我们的堆建成之后，很难所引导到它，以至于我们很难去改变它，比如说我们这些元素表示的是一个一个的系统任务，初始的时候，数值的索引是系...
算法与数据结构-索引堆优化(C++)
weixin_43587255的博客
04-26 363
描述 如果我们想要在索引堆中修改索引为i的元素，我们就需要找到索引i(也可以理解为索引为i的元素)在堆中的位置，并对其进行维护以保持堆特性。就是我们需要对索引进行遍历直到indexes[j] == i表示索引i在堆中的位置为j，并对位置为j的索引进行维护，这样一来就需要耗费O(n)的时间复杂度。 为了提高这一操作的效率，我们可以引入一个reverse[i]表示索引i在堆中的位置，就可以非常方便地定...
挖掘算法中的数据结构（五）：排序算法总结 和 索引堆及优化（堆结构）
lemonGuo的大脑皮层、小脑、海马体、杏仁核.....
08-23 1741
前四篇博文介绍的O(n^2)或O(n*logn)排序算法及堆排序结束，意味着有关排序算法已讲解完毕，此篇博文将对这些排序算法进行比较总结，并且学习另一个经典的堆结构，处于二叉堆优化之上的索引堆，最后拓展了解由堆衍生的一些问题。 此篇涉及的知识点有： 排序算法总结 索引堆及其优化 堆结构衍生的问题 挖掘算法中的数据结构（一）：选择、插入、冒泡、希尔排序 及 O(n^2)排序算法思考 挖
python实现堆和索引堆的代码示例
09-20
本文将探讨如何在Python中实现堆和索引堆。 首先，堆可以用完全二叉树的概念来理解。在数组中，完全二叉树的节点可以用数组下标来表示。对于索引为i的节点，其左子节点的索引是2i+1，右子节点的索引是2i+2，而父...
详解堆的javascript实现方法
10-21
总的来说，JavaScript中的堆实现主要依赖于数组的便捷性，通过数组索引可以直接获取节点的父节点和子节点。理解和掌握堆的原理以及JavaScript中的实现方式，对于优化算法性能，尤其是处理大数据集时，是非常有价值的...
第A章习题(索引与散列).doc
06-27
总结来说，索引和散列都是为了优化数据的存取效率。索引通过预建的数据结构加速查找，而散列则利用哈希函数将数据映射到固定位置，实现快速的查找和插入。在实际应用中，我们需要根据数据的特性和需求选择合适的方法...
C语言实现基于最大堆和最小堆的堆排序算法示例
09-02
在初始化堆时，从数组的最后一个非叶子节点开始，即从索引 `(len - 1) / 2` 开始，因为这是完全二叉树中最后一个非叶子节点的位置。通过`initHeap`函数，我们可以遍历这些节点并调用`adjustMaxHeap`函数，确保每个...
索引堆排序
weixin_30820151的博客
06-06 196
------------------siwuxie095 索引堆排序 程序： SortTestHelper.h： #ifndef SORTTESTHELPER_H #define SORTTESTHELPER_H #include <iostre...
索引堆简单介绍
带你装逼带你飞的专栏
05-05 1794
1 索引堆基本概念 堆的基本概念不用多种介绍了，但是对于堆来说，有时堆结点存储的数据结构交换时间及空间比较大，或者结点存储的是比较复杂的数据结构。这个时候，我们可以采用索引堆这种数据结构来解决 索引堆：在堆的基础上用一个索引数组来存储数据元素的位置，即索引堆里面包含两个数组，如下： 建堆之前： 建堆之后 在这个图中，有两个数组，data[]存储真实的数据元素，index[]存...
算法与数据结构-索引堆(堆排序)(C++)
weixin_43587255的博客
04-25 490
描述 堆的概念就不多说了。有的时候堆存放的数据比较复杂，直接对堆中的元素进行操作将造成过大的时空开销，或者我们需要保持堆中数据的原有顺序不变。我们就可以用索引堆这种数据结构来解决，下面以最大索引堆为例介绍索引堆。 思路 初始化时，为每个元素顺序分配索引。arr[0…n-1]对应堆中data[1…n]，索引为indexes[1…n]。 插入操作。设定count指向最后一个元素的位置，data[++...
堆优化prim算法C语言,007 基于最小索引堆优化的 Prim 算法求最小生成树
weixin_39834678的博客
05-23 202
两种 Prim 算法的区别基于最小索引堆优化的 Prim 算法在堆中最多存储 v-1 条边，即每个节点最多存一条邻边到堆中；而 LazyPrim 算法会将一个节点的多条邻边存进堆中；由于堆中存储边的数量从 e 变为 v，从而关于堆的操作的时间复杂度从 O(logE) 降为 O(logV)；v 是比 e 小的；存储在文件中的图8 164 5 .354 7 .375 7 .280 7 .161 5 ....
MySQL排序原理与索引优化
1. **排序优化与索引使用** - 可以利用索引避免排序的情况： - 当ORDER BY的字段与索引完全匹配时，如`SELECT * FROM t1 ORDER BY key_part1, key_part2;` - 筛选条件与索引匹配且ORDER BY与索引顺序一致时，如`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值