索引堆

最新推荐文章于 2021-07-30 15:34:05 发布
最新推荐文章于 2021-07-30 15:34:05 发布
阅读量64 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43579079/article/details/101774810
版权

将数组的索引重新按优先级建立新的索引；数组的索引代表从小到大的顺序，而新索引里面对应着堆的不同位置对应的数组的位置。
如果想更改数组中的某个元素，要维护index数组（堆）；在里面找到该元素所在的位置，然后再二叉树里进行元素的改变，然后使用shiftup,shiftdown维护最大堆的性质。

012345678910
index10978563142
data

假设想改变数组中4位置的data，先要通过index查到到此元素在二叉堆中存在于9的位置，然后再相应的位置改变data，之后再利用shift还原最大堆。这里在index里面用的是遍历查找的方式，此处可以进行优化。
mian.cpp

#include <iostream>
#include <cassert>
#include "SortTestHelper.h"

#define Priority int

using namespace std;

template<typename Item>
class IndexMaxHeap{

private:
    Item *data;
    int *indexes;
	// 得到data里的数需要先经过index进行索引
    int count;
    int capacity;
	// 描述索引数组的位置
    void shiftUp( int k ){

        while( k > 1 && data[indexes[k/2]] < data[indexes[k]] ){
            swap( indexes[k/2] , indexes[k] );
            k /= 2;
        }
    }

    void shiftDown( int k ){

        while( 2*k <= count ){
            int j = 2*k;
            if( j + 1 <= count && data[indexes[j+1]] > data[indexes[j]] )
                j += 1;

            if( data[indexes[k]] >= data[indexes[j]] )
                break;

            swap( indexes[k] , indexes[j] );
            k = j;
        }
    }

public:
    IndexMaxHeap(int capacity){ // 建立空间

        data = new Item[capacity+1];
        indexes = new int[capacity+1];

        count = 0;
        this->capacity = capacity;
    }
	// 释放空间
    ~IndexMaxHeap(){
        delete[] data;
        delete[] indexes;
    }

    int size(){
        return count;
    }

    bool isEmpty(){
        return count == 0;
    }

    // 传入的i对用户而言,数组是从0索引的
    void insert(int i, Item item){
        assert( count + 1 <= capacity ); // 无越界问题
        assert( i + 1 >= 1 && i + 1 <= capacity );

        i += 1;
        data[i] = item;
        indexes[count+1] = i; // 添加新的索引
        count++;

        shiftUp(count);
    }

    Item extractMax(){
        assert( count > 0 );

        Item ret = data[indexes[1]];
        swap( indexes[1] , indexes[count] );
        count--;
        shiftDown(1);
        return ret;
    }
	// 返回的是索引index值
    int extractMaxIndex(){
        assert( count > 0 );

        int ret = indexes[1] - 1; // 外部是从0开始
        swap( indexes[1] , indexes[count] );
        count--;
        shiftDown(1);
        return ret;
    }

    Item getMax(){
        assert( count > 0 );
        return data[indexes[1]];
    }

    int getMaxIndex(){
        assert( count > 0 );
        return indexes[1]-1;
    }

    Item getItem( int i ){
        return data[i+1];
    }
	// 利用索引堆修改数据
    void change( int i , Item newItem ){

        i += 1;
        data[i] = newItem;

        // 找到indexes[j] = i, j表示data[i]在堆中的位置
        // 之后shiftUp(j), 再shiftDown(j)

        for( int j = 1 ; j <= count ; j ++ ) // 遍历所有值
            if( indexes[j] == i ){  // 找到一个j的位置，代表在堆中的位置
                shiftUp(j);
                shiftDown(j);
                return;
            }
    }

    // test reverse index
    bool testReverseIndex(){

        int *copyIndexes = new int[count+1];

        for( int i = 0 ; i <= count ; i ++ ){
            copyIndexes[i] = indexes[i];
        }

        copyIndexes[0] = 0;
        std::sort(copyIndexes, copyIndexes + count + 1);

        bool res = true;
        for( int i = 1 ; i <= count ; i ++ )
            if( copyIndexes[i-1] + 1 != copyIndexes[i] )
                res = res || false;

        delete[] copyIndexes;

        if( !res ){
            cout<<"Error 1"<<endl;
            return res;
        }

        return true;
    }
};

template<typename T>
void heapSortUsingIndexMaxHeap(T arr[], int n){

    IndexMaxHeap<T> indexMaxHeap = IndexMaxHeap<T>(n);
    for( int i = 0 ; i < n ; i ++ )
        indexMaxHeap.insert( i , arr[i] );
    assert( indexMaxHeap.testReverseIndex() );

    for( int i = n-1 ; i >= 0 ; i -- )
        arr[i] = indexMaxHeap.extractMax();
}

int main() {

    int n = 1000000;

    Priority* arr = new Priority[n];
    srand(time(NULL));
    for( int i = 0 ; i < n ; i ++ )
        arr[i] = rand()%n;
    SortTestHelper::testSort("Heap Sort Using Index-Max-Heap", heapSortUsingIndexMaxHeap, arr, n);
    delete[] arr;

    return 0;
}

SortTestHelper.h

//
// Created by liuyubobobo on 8/16/16.
//

#ifndef INC_08_INDEX_HEAP_SORTTESTHELPER_H
#define INC_08_INDEX_HEAP_SORTTESTHELPER_H

#include <iostream>
#include <algorithm>
#include <string>
#include <ctime>
#include <cassert>
#include <string>

using namespace std;


namespace SortTestHelper {

    int *generateRandomArray(int n, int range_l, int range_r) {

        int *arr = new int[n];

        srand(time(NULL));
        for (int i = 0; i < n; i++)
            arr[i] = rand() % (range_r - range_l + 1) + range_l;
        return arr;
    }

    int *generateNearlyOrderedArray(int n, int swapTimes){

        int *arr = new int[n];
        for(int i = 0 ; i < n ; i ++ )
            arr[i] = i;

        srand(time(NULL));
        for( int i = 0 ; i < swapTimes ; i ++ ){
            int posx = rand()%n;
            int posy = rand()%n;
            swap( arr[posx] , arr[posy] );
        }

        return arr;
    }

    int *copyIntArray(int a[], int n){

        int *arr = new int[n];
        copy(a, a+n, arr);
        return arr;
    }

    template<typename T>
    void printArray(T arr[], int n) {

        for (int i = 0; i < n; i++)
            cout << arr[i] << " ";
        cout << endl;

        return;
    }

    template<typename T>
    bool isSorted(T arr[], int n) {

        for (int i = 0; i < n - 1; i++)
            if (arr[i] > arr[i + 1])
                return false;

        return true;
    }

    bool areSameIntArrs(int* arr, int* arr2, int n){

        std::sort(arr,arr+n);
        std::sort(arr2,arr2+n);
        for( int i = 0 ; i < n ; i ++ )
            if( arr[i] != arr2[i] )
                return false;
        return true;
    }

    template<typename T>
    void testSort(const string &sortName, void (*sort)(T[], int), T arr[], int n) {

        T* arr2 = copyIntArray(arr, n);

        clock_t startTime = clock();
        sort(arr, n);
        clock_t endTime = clock();
        cout << sortName << " : " << double(endTime - startTime) / CLOCKS_PER_SEC << " s"<<endl;

        assert(isSorted(arr, n));
        assert(areSameIntArrs(arr,arr2,n));
        delete[] arr2;
        return;
    }

};

#endif //INC_08_INDEX_HEAP_SORTTESTHELPER_H

反向查找表：
新建一个数组rev，里面存放的是数组索引在index里面存在的位置。

012345678910
index10978563142
data
rev81079563421

优化：要改变数组4位置的data，通过rev可以之间知道其在index的第九个位置，然后直接到二叉堆中第九个位置改变data，而无需再遍历index寻找合适的位置。
rev[i] 表示i在index中的位置
index[i] = j
rev[j] = i
index [rev[i]] = i
rev[index[]] = i
main.cpp

#include <iostream>
#include <cassert>
#include "SortTestHelper.h"

#define Priority int

using namespace std;

template<typename Item>
class IndexMaxHeap{

private:
    Item *data;
    int *indexes;
    int *reverse; //新的成员变量

    int count;
    int capacity;

    void shiftUp( int k ){

        while( k > 1 && data[indexes[k/2]] < data[indexes[k]] ){
            swap( indexes[k/2] , indexes[k] );
            reverse[indexes[k/2]] = k/2; // 把这两个位置的rev写入
            reverse[indexes[k]] = k;
            k /= 2;
        }
    }

    void shiftDown( int k ){

        while( 2*k <= count ){
            int j = 2*k;
            if( j + 1 <= count && data[indexes[j+1]] > data[indexes[j]] )
                j += 1;

            if( data[indexes[k]] >= data[indexes[j]] )
                break;

            swap( indexes[k] , indexes[j] );
            reverse[indexes[k]] = k;
            reverse[indexes[j]] = j;
            k = j;
        }
    }

public:
    IndexMaxHeap(int capacity){

        data = new Item[capacity+1];
        indexes = new int[capacity+1];
        reverse = new int[capacity+1]; // 分配空间
        for( int i = 0 ; i <= capacity ; i ++ )
            reverse[i] = 0; // 初始化为0，表示不存在

        count = 0;
        this->capacity = capacity;
    }

    ~IndexMaxHeap(){
        delete[] data;
        delete[] indexes;
        delete[] reverse; // 释放空间
    }

    int size(){
        return count;
    }

    bool isEmpty(){
        return count == 0;
    }

    // 传入的i对用户而言,是从0索引的
    void insert(int i, Item item){
        assert( count + 1 <= capacity );
        assert( i + 1 >= 1 && i + 1 <= capacity );

        i += 1;
        data[i] = item;
        indexes[count+1] = i;
        reverse[i] = count+1; //由性质而来
        count++;

        shiftUp(count);
    }

    Item extractMax(){
        assert( count > 0 );

        Item ret = data[indexes[1]];
        swap( indexes[1] , indexes[count] );
        reverse[indexes[count]] = 0;
        reverse[indexes[1]] = 1;
        count--;
        shiftDown(1);
        return ret;
    }

    int extractMaxIndex(){
        assert( count > 0 );

        int ret = indexes[1] - 1;
        swap( indexes[1] , indexes[count] );
        reverse[indexes[count]] = 0;
        reverse[indexes[1]] = 1;
        count--;
        shiftDown(1);
        return ret;
    }

    Item getMax(){
        assert( count > 0 );
        return data[indexes[1]];
    }

    int getMaxIndex(){
        assert( count > 0 );
        return indexes[1]-1;
    }

    bool contain( int i ){ // 布尔值
        assert( i + 1 >= 1 && i + 1 <= capacity );
        return reverse[i+1] != 0; // 从0开始的要加1
    }

    Item getItem( int i ){
        assert( contain(i) );
        return data[i+1];
    }

    void change( int i , Item newItem ){

        assert( contain(i) ); //确定包含索引i
        i += 1;
        data[i] = newItem;

        // 找到indexes[j] = i, j表示data[i]在堆中的位置
        // 之后shiftUp(j), 再shiftDown(j)

//        for( int j = 1 ; j <= count ; j ++ )
//            if( indexes[j] == i ){
//                shiftUp(j);
//                shiftDown(j);
//                return;
//            }

        int j = reverse[i];
        shiftUp( j );
        shiftDown( j );
    }

    // test reverse index
    bool testReverseIndex(){

        int *copyIndexes = new int[count+1];
        int *copyReverseIndexes = new int[count+1];

        for( int i = 0 ; i <= count ; i ++ ){
            copyIndexes[i] = indexes[i];
            copyReverseIndexes[i] = reverse[i];
        }

        copyIndexes[0] = copyReverseIndexes[0] = 0;
        std::sort(copyIndexes, copyIndexes + count + 1);
        std::sort(copyReverseIndexes, copyReverseIndexes + count + 1);

        bool res = true;
        for( int i = 1 ; i <= count ; i ++ )
            if( copyIndexes[i-1] + 1 != copyIndexes[i] || copyReverseIndexes[i-1] + 1 != copyReverseIndexes[i] )
                res = res || false;

        delete[] copyIndexes;
        delete[] copyReverseIndexes;

        if( !res ){
            cout<<"Error 1"<<endl;
            return res;
        }

        for( int i = 1 ; i <= count ; i ++ )
            if( reverse[ indexes[i] ] != i ){
                cout<<"Error 2"<<endl;
                return false;
            }

        return true;
    }
};

template<typename T>
void heapSortUsingIndexMaxHeap(T arr[], int n){

    IndexMaxHeap<T> indexMaxHeap = IndexMaxHeap<T>(n);
    for( int i = 0 ; i < n ; i ++ )
        indexMaxHeap.insert( i , arr[i] );
    assert( indexMaxHeap.testReverseIndex() );

    for( int i = n-1 ; i >= 0 ; i -- )
        arr[i] = indexMaxHeap.extractMax();
}

int main() {

    int n = 1000000;

    Priority* arr = new Priority[n];
    srand(time(NULL));
    for( int i = 0 ; i < n ; i ++ )
        arr[i] = rand()%n;
    SortTestHelper::testSort("Heap Sort Using Index-Max-Heap", heapSortUsingIndexMaxHeap, arr, n);
    delete[] arr;

    return 0;
}

SortTestHelper.h

//
// Created by liuyubobobo on 8/16/16.
//

#ifndef INC_08_INDEX_HEAP_SORTTESTHELPER_H
#define INC_08_INDEX_HEAP_SORTTESTHELPER_H

#include <iostream>
#include <algorithm>
#include <string>
#include <ctime>
#include <cassert>
#include <string>

using namespace std;


namespace SortTestHelper {

    int *generateRandomArray(int n, int range_l, int range_r) {

        int *arr = new int[n];

        srand(time(NULL));
        for (int i = 0; i < n; i++)
            arr[i] = rand() % (range_r - range_l + 1) + range_l;
        return arr;
    }

    int *generateNearlyOrderedArray(int n, int swapTimes){

        int *arr = new int[n];
        for(int i = 0 ; i < n ; i ++ )
            arr[i] = i;

        srand(time(NULL));
        for( int i = 0 ; i < swapTimes ; i ++ ){
            int posx = rand()%n;
            int posy = rand()%n;
            swap( arr[posx] , arr[posy] );
        }

        return arr;
    }

    int *copyIntArray(int a[], int n){

        int *arr = new int[n];
        copy(a, a+n, arr);
        return arr;
    }

    template<typename T>
    void printArray(T arr[], int n) {

        for (int i = 0; i < n; i++)
            cout << arr[i] << " ";
        cout << endl;

        return;
    }

    template<typename T>
    bool isSorted(T arr[], int n) {

        for (int i = 0; i < n - 1; i++)
            if (arr[i] > arr[i + 1])
                return false;

        return true;
    }

    bool areSameIntArrs(int* arr, int* arr2, int n){

        std::sort(arr,arr+n);
        std::sort(arr2,arr2+n);
        for( int i = 0 ; i < n ; i ++ )
            if( arr[i] != arr2[i] )
                return false;
        return true;
    }

    template<typename T>
    void testSort(const string &sortName, void (*sort)(T[], int), T arr[], int n) {

        T* arr2 = copyIntArray(arr, n);

        clock_t startTime = clock();
        sort(arr, n);
        clock_t endTime = clock();
        cout << sortName << " : " << double(endTime - startTime) / CLOCKS_PER_SEC << " s"<<endl;

        assert(isSorted(arr, n));
        assert(areSameIntArrs(arr,arr2,n));
        delete[] arr2;
        return;
    }

};

#endif //INC_08_INDEX_HEAP_SORTTESTHELPER_H
weixin_43579079
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
索引
04-01 1856
1、索引的定义 索引是一个单独的、物理的数据库结构，它是某个表中一列或若干列值的集合和相应的指向表中物理标识这些值的数据页的逻辑指针清单。 简单地说，索引是对数据库表中一列或多列的值进行排序的一种结构。 2、索引的优缺点 优点： 1.大大加快数据的检索速度，这也是创建索引的最主要的原因； 2.可以创建唯一性索引，保证数据库表中每一行数据的唯一性； 3.可以
Java 集合扩展 ｜ 索引堆实现
BurukeYou
03-20 452
1、前言 好像Java自带的集合体中并没有原生索引堆实现， 甚至原生的普通堆都没有，而优先级队列PriorityQueue虽然可以当作堆来使用，虽然底层是用了堆的思想实现， 但是它本质还是属于队列体系。 2、什么是堆 特点1: 本质是一棵完全二叉树 特点2: 每个节点的值比它左右孩子节点的值都小 或者 都大。 比孩子节点值都大的叫 最大堆， 反之叫最小堆。 如下图两颗完全二叉树就是属于堆 3、堆可以做什么(应用场景) 堆可以以O(1)时间复杂度快速的获得集合里的最大 或者 最小值。 应用场景
堆排序
wolffmark的博客
05-07 212
堆排序思想： 利用大顶堆(小顶堆)堆顶记录的是最大关键字(最小关键字)这一特性，使得每次从无序中选择最大记录(最小记录)变得简单。     其基本思想为(大顶堆)：     1)将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无须区；     2)将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn
python实现堆和索引堆的代码示例
12-25
由于是完全二叉树，所以可以使用数组来表示堆，索引从0开始[0:length-1]。结点i的左右子节点分别为2i+1,2i+2。长度为length的树的最后一个非叶子节点为length//2-1。当前节点i的父节点为(i-1)//2。其中//表示向下...
MySQL索引之聚集索引介绍
09-10
相反，MyISAM引擎使用堆组织表，没有聚集索引的概念。数据行的物理存储位置与索引分离，索引仅仅指向数据行的地址，而非数据本身。这种模式在某些场景下可以提供较高的写性能，但对查询性能和数据一致性可能有所牺牲...
MySQL索引之主键索引
09-10
在MyISAM引擎中，主键索引和唯一索引之间的区别并不显著，因为MyISAM是堆组织表，数据行的位置与索引无关。但在InnoDB中，这个区别很重要。主键索引是聚集索引，而其他唯一索引和非唯一索引是非聚集的，它们不包含...
css3动态堆叠索引卡
06-12
在本项目中，我们主要探讨的是如何利用CSS3来实现一个动态堆叠的索引卡片效果。这个效果通常用于展示信息，比如文章摘要、产品介绍或者个人简历等，通过翻转和堆叠的方式吸引用户的注意力，提升用户体验。下面将详细...
Heap-006-Index-Heap
Sunshine
04-17 100
main.cpp #include <iostream> #include <cassert> #include "SortTestHelper.h" #define Priority int using namespace std; template<typename Item> class IndexMaxHeap{ private: Ite...
索引堆 Index Heap的详解和代码实现
bluebiy的专栏
07-30 462
目录 一、为什么需要索引堆 二，索引堆的具体实现 三、索引堆的优化 四、和堆相关的其他问题 一、为什么需要索引堆 本篇我们将介绍一个相比于普通堆更加高级一些的数据结构 索引堆（Index Heap）。 我们先来看一下之前所解介绍的堆有什么问题，为什么要引入索引堆这种新的数据结构？ 大家可以来看如下的例子。给定一个数组，现在要对整个数组进行heapify（堆化、堆构建）操作，使其变成一个堆。 heapify操作完成以后，整个数组变成如下样子，这时候它是一个最大堆。
索引堆简单介绍
带你装逼带你飞的专栏
05-05 1770
1 索引堆基本概念 堆的基本概念不用多种介绍了，但是对于堆来说，有时堆结点存储的数据结构交换时间及空间比较大，或者结点存储的是比较复杂的数据结构。这个时候，我们可以采用索引堆这种数据结构来解决 索引堆：在堆的基础上用一个索引数组来存储数据元素的位置，即索引堆里面包含两个数组，如下： 建堆之前： 建堆之后 在这个图中，有两个数组，data[]存储真实的数据元素，index[]存...
《剑指 Offer》（第 2 版） 题解（Python 语言实现）第 01-10 题
李威威的博客
09-15 1666
最大索引堆change 操作：首先我们来解释一下 change 操作，在实际应用中，我们除了有 insert 和 extract 这两个操作以外，我们数组中的元素很可能是动态变化的，在变化的过程中，如何保持最大堆的性质，这就是我们要讨论的问题。最大索引堆的特性1、最大索引堆的内部维护了一个索引数组，这个索引数组构成了一个最大堆；2、使用最大索引堆的时候，可以很好地支持 change 这个操作，即我们
索引堆的实现
liqian_blog的博客
04-27 402
   之前讲的基础堆的实现，是将数组元素进行交换最后建成最大堆，这种交换数组元素来建堆的方式有2个局限性：（1）若数组元素是非常复杂的结构（比如巨大的字符串），那么每次交换这些字符串消耗性能都是巨大的；（2）若数组成为最大堆以后，我们需要对某个下标下原来的元素进行操作，那么操作将会是很复杂的（比如假设每个下标代表一个进程，每个进程为一个系统任务，下标处对应的元素为该任务的优先级，那么在建成最大堆后...
算法与数据结构-索引堆(堆排序)(C++)
weixin_43587255的博客
04-25 449
描述 堆的概念就不多说了。有的时候堆存放的数据比较复杂，直接对堆中的元素进行操作将造成过大的时空开销，或者我们需要保持堆中数据的原有顺序不变。我们就可以用索引堆这种数据结构来解决，下面以最大索引堆为例介绍索引堆。 思路 初始化时，为每个元素顺序分配索引。arr[0…n-1]对应堆中data[1…n]，索引为indexes[1…n]。 插入操作。设定count指向最后一个元素的位置，data[++...
数据结构笔记（4）：索引堆
gh6267的博客
09-07 162
索引堆：对于索引堆来说，我们将索引和数据分开存储，而真正表征堆的数组是由索引构成的。如图1所示，二叉树的每个结点上写的不是数字而是索引号。当我们将这个数组变成对以后，这个数组变成图2的样子，我们可以看出数组的data域没有发生改变，发生改变的只是index域，二叉树中的每个元素仍是索引，而每个索引对应的元素才是堆中原本的元素。所以当我们维护这个堆的时候，比较时用的仍然时data域的数据，而交换就要交换index域的数据。 ...
堆、堆排序与索引堆
跑码场
05-16 640
完整代码参见github 堆的概念 定义 堆就是一棵二叉树，每个节点包含一个键，不过还需要满足以下两个条件： （1）必须是完全二叉树，也就是说，树的每一层都必须是满的，除了最后一层最右边的元素可能有所缺失 （2）堆特性（又称为父母优势，这里我们以最大堆为例），每一个节点都要大于或等于它的子节点（对于叶子节点我们认为是满足这个条件的） 举例说明，上图中只有第一棵树是堆，第二棵树违背了...
数据库索引深度解析与性能优化实践
资料深入讲解了索引与统计信息的关系、索引存储原理、索引碎片分析以及如何读懂查询计划，并通过具体的案例分析了堆表和不同类型的索引存储方式。" 在SQL性能优化中，索引起着至关重要的作用。首先，我们需要理解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值