[算法] 索引堆

索引堆

• 普通堆的问题
  • Heapify的过程中改变了原数组元素的位置，性能消耗较高
  • 原有元素改变位置后难以被索引找到（如原数组中保存着系统任务，Heapify后想提高原来id=6任务的优先级）
• 索引堆的引入
  • 数据和索引分开表示
  • 建堆过程：比较数据，交换索引，效率高
  • 便于堆中数据的操作，如将进程号为7的任务优先级由28改为38

template<typename Item>
class IndexMaxHeap{
    private:
        Item *data;    //数据
        int *indexes; //索引  
        int count;    
        int capacity;
        
        // 比较新加入的子节点和父节点大小并交换，直到最顶 
        // O(logn) 
        void shiftUp(int k){
            while( k > 1 && data[indexes[k/2]] < data[indexes[k]] ){
                swap(data[k/2],data[k]);
                k /= 2;
            }
        }
        
        // 比较两个子节点，和大的交换，直到最底 
        // 复杂度O(logn)
        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;
                swap(indexes[k] , indexes[j]);
                k = j;
            }
        }
    public:
        // 构造一个空堆，可容纳capacity个元素 
        // 时间复杂度O(nlogn)
        IndexMaxHeap(int capacity){
            data = new Item[capacity+1];
            indexes = new int[capacity +1];
            count = 0;
            this -> capacity = capacity;
        }
        
        ~MaxHeap(){
            delete[] data;
            delete[] indexes;
        }
        
        // 返回堆中元素个数 
        int size(){
            return count;
        }
        
        // 是否为空堆
        bool isEmpty(){
            return count == 0;
        }
        
        // 插入新元素，shiftUp
        // i为索引，传入的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+1);
        } 
        
        // 从最大堆取出堆顶元素，shiftDown 
        Item extractMax(){ 
            assert( count > 0 );
            Item ret = data[indexes[1]];
            swap( indexes[1] , indexes[count] );
            count --;
            shiftDown(1);
            return ret;
        } 
        
        // 获取最大堆的堆顶元素 
        Item getMax(){
            assert( count > 0 );
            return data[1];
        }     
        
        // 给定索引获得数据 
        Item getItem( int i ){
            assert( i + 1 >= 1 && i + 1 <= capacity );
            return data[i+1];
        }
        
        //返回最大元素索引 
        Item extractMaxIndex(){ 
            assert( count > 0 );
            int ret = indexes[1] - 1;
            swap( indexes[1] , indexes[count] );
            count --;
            shiftDown(1);
            return ret;
        } 
        
        // 将最大索引堆中索引为i的元素修改为newItem
        // 应用场景：修改优先队列中某个任务的优先级 
        // O(n+logn) 即 O(n) 
        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 ){
                     shiftUp(j);
                     shiftDown(j);
                     return;
                 }
        }
};

• 为什么先shiftUp()再shiftDown()：不知道是改堆头还是堆尾的元素