索引堆

堆（heap）是一种常见的数据结构，经常用来实现优先队列。其中最常见的是二叉堆（binary heap）。由于它特殊的性质（二叉满树）所以可以用数组高效的实现。

堆还能用来进行排序，堆排序（heap sort）具有快速（复杂度O(N * logN)），稳定的特点，尤其是非常稳定，因此适用于某些需要排序稳定性的场合。

然而，普通的二叉堆却存在以下两个缺陷：

1，在堆中的元素体积非常大的情况下，经常性的移动元素是低效的。（例如堆中的元素不在仅仅是简单的整数，而是大量的字符串亦或者是图片等体积较大的元素，则此时大量的移动会使得效率非常的低下）
2，如果在堆的使用过程中，堆中的元素的值要改变，则普通堆对此无能为力。简单的说，一个元素如果进入堆之后，它的值就不能改变了，否则会影响堆的性质。（因为堆是中元素是靠数组索引来取值的，然而在堆进行排序操作的时候，虽然数组索引不可能改变，但是数组中的值却在不停的变化，也就是说排序会破坏数组中的一一映射关系，导致无法直接通过数组索引来修改一个值）。

下面我们来介绍一下索引堆，索引堆完美的解决了以上存在的两个问题，并在以后的图学习中能够对图进行优化。

   对于原来的简单二叉堆，因为每一个节点的值都会因为shiftup和shiftdown操作而改变自身在堆中的位置，因此也就破坏了索引与数据原来的对应关系，以下的讨论都以这个例子为基础：如果索引代表一个进程的ID，而data值代表该进程的权值,这样的话每次就不能知道哪一个进程的权值最大了，因为已经破坏了进程ID和权值原来的映射关系，那么，有没有什么办法即能够实现堆的特性，又能够不改变他们之前的映射关系呢？当然有，那就是索引堆了，索引堆比普通的堆多了一个数据，那就是index数组，index[i]代表排在第i位的索引号，具体如下图所示：

也就是说，原来的ID与权值我们不改变他们，而是复制一遍他们的ID作为索引，然后在排序复制的索引，这样就不会破坏原来ID和权值的对应关系了。

然而，我们只能通过index[i]知道位于i位置上的进程的ID，却不能够通过知道一个进程的ID而获取到这个进程在堆中所处的位置（可依靠循环遍历堆中所有元素来寻找出位置，但是会牺牲时间复杂度），因此，我们必须还要添加一个数组用来专门维护上面的内容，因此我们又添加一个rev数组，专门用来记录进程ID所处在的位置，现在的堆实现如下图所示：

则rev[i]代表的意思为进程ID为i的进程所在堆中的位置，例如rev[1]=8的意思为进程ID为1的进程在堆中的位置为8，我们看看index[8]=1，这会发现index数组与rev数组代表的意思恰恰相反。

具体解释可看下图：

再者，如果还是不好理解，我们可以举一个显示生活中的例子，假设二叉堆代表的是一个领奖台，但是这个领奖台必须满足二叉堆的性质：1.为满二叉树 2.父节点一定大于子节点。我们反映到领奖台例子上则是，在上面的领奖台上站的学生分数一定要比他下面学生的分数高，且领奖台的设置必须和二叉堆类似。

对于存在的三个数组，我们可以按照下图这样理解：

data[i]代表学号为i的学生所得的分数，由上图可知，我们知道学号就可以知道相对应的分数，把data数组想象成如上面的一张表，data数组的任务就是记录每一个学号的学生所对应的分数，无特殊情况，每一个学生对应的分数都不会被改动。

rev[i]所代表的意思为学号为i的学生站在哪个领奖台上，由上图可知，我们知道学号就能通过上面这张表去查找的该学生在领奖台的位置，把rev数组也想象成上面的表，rev数组的任务就是维护每个学生现在所处的领奖台的位置，告诉我们是在拿一号领奖台上。

index[i]的意思为此时此刻站在i领奖台上的学生是哪一位呢？请提供他的学号给我，因此index数组的任务不仅仅是用来进行堆排序产生权值最大的那位，而且可以用来查找领奖台上学生的学号。

我们把二叉堆抽象为领奖台，如下图所示：

如上图的解释，每次执行操作，data[]数组只负责跟踪记录每位学生学号与相对应的分数，rev[]数组只负责跟踪记录每位学生在哪一号领奖台上。而所有的交换操作，全部转换成在交换index数组里的索引，即这里的领奖台上的学生的学号。

索引堆的内部结构如下：

 int* data;//数据存储数组
    int *index;//索引存储数组
    int Count;//记录堆中存放的数据的数量，每次都保证指向最后一个索引所在的位置
    int capacity;//记录数组最大能够承载元素的数量,也是索引最大承受数量
    int *rev;//rev为记录i索引所在数组的位置，与index数组恰好相反

倘若处在k位置领奖台上的学号(index[k])代表的学生其分数（data[index[k]]）要比其父节点领奖台上学生(index[k/2])的分数(data[index[k/2]])还要高，则需要对在k号领奖台上的学号进行shiftup操作，使其与父节点领奖台上的学号进行交换，以下是具体的代码（其中的swap（）操作因为效率优化更改成赋值操作，详细请看下一篇文章解释）：

void shiftup(int k)//k代表索引所处的位置
    {
        int e;//交换操作备用
        e=index[k];
        while (k > 1 && data[index[k / 2]] < data[index[k]]) {//如果k>1并且K的父节点的值要小于k节点的值
            //swap(index[k], index[k / 2]);//交换
            //优化交换操作，提高效率，替换代码如下：具体可参考插入排序的优化方法
            index[k]=index[k/2];
            rev[index[k]]=k;
            k /= 2;//k重新指向其原来父节点所在索引
        }
        index[k]=e;
        rev[index[k]]=k;
    }

相反，如果在k号领奖台上的学号（index[k]）代表的学生的分数(data[index[k]])比其左孩子领奖台上的学号(index[k*2])代表的学生的分数(data[index[k*2]])或者是右孩子领奖台( 如果存在右孩子的话)上的学号(index[k*2+1])代表的学生的分数（data[index[k*2+1]）还要低，则理应对k号领奖台上的学号进行shiftdown操作。

void shiftdown(int k){
        int e;//交换操作备用
        e=index[k];
        while(k*2<=Count){//K所处节点下沉条件成立，存在左孩子
            int j=k*2;//j指向孩子中的最大者,默认为其左孩子
            if(j+1<=Count&&data[index[j+1]]>data[index[j]]){//不仅存在右孩子，而且右孩子的值比左孩子还要大，则j指向右孩子
                j++;
            }
            if(data[index[j]]>data[index[k]]){//如果父节点的值小于大孩子节点的值则进行交换
              //  swap(index[j],index[k]);优化替换操作提高效率
                index[k]=index[j];
                rev[index[k]]=k;
            }
            else break;//父节点相比较大则不用交换直接退出下沉循环操作
            k=j;
        }
        index[k]=e;
        rev[e]=k;
    }

在具体的实现时，需要注意的点是：用户提供的索引是从0开始的，而我们实现的二叉堆是从1开始计数的，因此在存储数据修改数据等是要对用户输入的索引进行偏移操作，转换成在堆中的计数方式。

以下是索引堆的所有实现代码：

#include <cassert>
#include <iostream>
using namespace std;

class indexheap {
private:
    int* data;//数据存储数组
    int *index;//索引存储数组
    int Count;//记录堆中存放的数据的数量，每次都保证指向最后一个索引所在的位置
    int capacity;//记录数组最大能够承载元素的数量,也是索引最大承受数量
    int *rev;//rev为记录i索引所在数组的位置，与index数组恰好相反

    void shiftup(int k)//k代表索引所处的位置
    {
        int e;//交换操作备用
        e=index[k];
        while (k > 1 && data[index[k / 2]] < data[index[k]]) {//如果k>1并且K的父节点的值要小于k节点的值
            //swap(index[k], index[k / 2]);//交换
            //优化交换操作，提高效率，替换代码如下：具体可参考插入排序的优化方法
            index[k]=index[k/2];
            rev[index[k]]=k;
            k /= 2;//k重新指向其原来父节点所在索引
        }
        index[k]=e;
        rev[index[k]]=k;
    }

    void shiftdown(int k){
        int e;//交换操作备用
        e=index[k];
        while(k*2<=Count){//K所处节点下沉条件成立，存在左孩子
            int j=k*2;//j指向孩子中的最大者,默认为其左孩子
            if(j+1<=Count&&data[index[j+1]]>data[index[j]]){//不仅存在右孩子，而且右孩子的值比左孩子还要大，则j指向右孩子
                j++;
            }
            if(data[index[j]]>data[index[k]]){//如果父节点的值小于大孩子节点的值则进行交换
              //  swap(index[j],index[k]);优化替换操作提高效率
                index[k]=index[j];
                rev[index[k]]=k;
            }
            else break;//父节点相比较大则不用交换直接退出下沉循环操作
            k=j;
        }
        index[k]=e;
        rev[e]=k;
    }

public:
    indexheap(int n)//索引堆构造函数
    {
        data=new int[n+1];
        index=new int[n+1];
        rev=new int[n+1];
        Count=0;
        capacity=n;
        for(int i=0;i<n+1;i++){//初始化rev数组
            rev[i]=0;//若rev为0则代表不存在此元素，因为堆从1开始计数
        }
    }

    ~indexheap()
    {
        delete [] data;
        delete [] index;
        delete[] rev;
    }

    void insert(int i,int item){//i为索引，元素值为item,对用户而言从0开始
        i+=1;//修正用户从0开始计数与堆从1开始计数引起的偏差
        assert(i<=capacity);
        assert(Count+1<=capacity&&i>=1);
        data[i]=item;//插入数据
        index[Count+1]=i;//插入索引
        rev[i]=Count+1;
        Count++;//更新Count指向，使其指向最后一个数据的索引
        shiftup(Count);//对其新添加的元素更新索引位置
    }

    int getmax(){//获取最大值
        assert(Count>0);
        return data[index[1]];
    }

    int getitem(int i)//i相对于用户从0开始
    {
        assert(IsInHeap(i));
        i+=1;//偏移为内部索引
        return data[i];
    }

    void test()//测试函数，打印出Index和data
    {
        cout<<"index:"<<endl;
        for(int i=1;i<=Count;i++)
        {
            cout<<index[i]<<' ';
        }
        cout<<endl;
        cout<<"data:"<<endl;
        for(int i=1;i<=Count;i++)
        {
            cout<<data[i]<<' ';
        }
        cout<<endl;
        cout<<"rev:"<<endl;
        for(int i=1;i<=capacity;i++){
            cout<<rev[i]<<' ';
        }
        cout<<endl;
    }

    int size()//返回堆中存放的数据数量
    {
        return Count;
    }
     bool isempty()//堆是否为空堆
     {
         return Count==0;
     }

    void change(int i,int item)//修改数据,i为用户索引，item为需要新修改的数据值
    {
        assert(i+1>=1);
        assert(IsInHeap(i));
        i+=1;//偏移操作,使其符合从1开始计数标准
        data[i]=item;
        int j;
       j=rev[i];
        shiftup(j);
        shiftdown(j);
        cout<<"change "<<i<<" to "<<item<<" succeed"<<endl;
    }

    int extractmax(){//取出最大值并返回最大值
        assert(Count>0);//判断是否有数据可取
        int ret;
        ret=data[index[1]];
       swap(index[1],index[Count]) ;//index[1]由最后一位来取代，之后Count缩小一位
        rev[index[1]]=1;
        rev[index[Count]]=0;
        Count--;
        shiftdown(1);//对新上来的index[1]进行下沉操作保证堆的正确
        return ret;
    }

    bool IsInHeap(int i){//判断用户提供的索引在堆中是否存在
        assert(i+1>=1&&i+1<=capacity);
        i+=1;//偏移用户索引使其成为堆中索引
        return rev[i]!=0;
    }
};

测试用的main()函数如下：

#include <iostream>
#include "indexheap.h"
using namespace std;
int main() {
int arr[5]={5,7,3,2,6};
    indexheap heap(5);
    for(int i=0;i<5;i++)
    {
        heap.insert(i,arr[i]);
    }
heap.test();

    return 0;
}

输出的一个样例结果如下：

如需获取本节索引堆相关的全部源码，请点击此处。