[算法] 堆

思路

• 不用传统排序算法，如何从小到大排序一个数组？
• 把原数组的元素放到最大堆中，不断取出根节点，从后往前赋值到原数组

堆的实现

• 完全二叉树：二叉树，除了最后一层外，其他层的节点数都是最大值，最后一层所有的节点都在左侧
• 堆：是一个完全二叉树，任何一个节点都不大于它的父节点的堆是最大堆
• 堆的存储
  • 利用数组，左节点的索引是父节点的2倍
• 堆的维护
  • Shift Up：在数组末尾加入新元素，将其调整到合适的位置（和父节点比较，交换）
  • Shift Down：取出根节点元素（优先级最大），将末尾元素放到根节点，调整元素位置（和子节点中较大的交换）
• 堆化（Heapify）
  • 给定一个数组，让数组的排列形成一个堆
  • 第一个非叶子节点的索引号 = 末尾元素的索引号/2
  • 所有叶子节点本身构成最大堆
  • 对非叶子节点进行Shift Down

  

Heap.h

#include <algorithm>
#include <cassert>

using namespace std;

template<typename Item>
class MaxHeap{
    private:
        Item *data;
        int count;
        int capacity;
        
        // 比较新加入的子节点和父节点大小并交换，直到最顶 
        // O(logn) 
        void shiftUp(int k){
            while( k > 1 && data[k/2] < data[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[j+1] > data[j]) j++;
                if( data[k] >= data[j]) break;
                swap(data[k] , data[j]);
                k = j;
            }
        }
    public:
        // 构造一个空堆，可容纳capacity个元素 
        // 时间复杂度O(nlogn)
        MaxHeap(int capacity){
            data = new Item[capacity+1];
            count = 0;
            this -> capacity = capacity;
        }
        
        // 通过一个给定数组创建最大堆（堆化） 
        // 时间复杂度O(n) 
        MaxHeap(Item arr[], int n){
            data = new Item[n+1];
            capacity = n;
            for( int i = 0 ; i < n ; i ++ )
                data[i+1] = arr[i];
            count = n;
            
            // 堆的第一个非叶子节点的索引为count/2
            // 从这个节点开始，逐个shiftDown到最顶 
            for( int i = count/2 ; i >= 1 ; i -- )
                shiftDown(i);    
        }
        ~MaxHeap(){
            delete[] data;
        }
        // 返回堆中元素个数 
        int size(){
            return count;
        }
        // 是否为空堆
        bool isEmpty(){
            return count == 0;
        }
        // 插入新元素，shiftUp
        void insert(Item item){
            assert( count +1 <= capacity );
            data[count+1] = item;
            shiftUp(count+1);
            count ++;
        } 
        // 从最大堆取出堆顶元素，shiftDown 
        Item extractMax(){ 
            assert( count > 0 );
            Item ret = data[1];
            swap( data[1] , data[count] );
            count --;
            shiftDown(1);
            return ret;
        } 
        // 获取最大堆的堆顶元素 
        Item getMax(){
            assert( count > 0 );
            return data[1];
        }     
};

main.cpp

#include <iostream>
#include <algorithm>
#include "Student.h"
#include "Heap.h"
#include "SortTestHelper.h"
#include "MergeSort.h"
#include "QuickSort.h"

using namespace std;


// 先将元素添加到堆中再取出，即完成排序
// 添加和取出的复杂度均为O(nlogn)，故整体复杂度为O(nlogn)
 
template<typename T>
void heapSort1(T arr[], int n){
    
    MaxHeap<T> maxheap = MaxHeap<T>(n);
    for( int i = 0 ; i < n ; i ++ )
        maxheap.insert(arr[i]);
        
    for( int i = n-1 ; i >= 0 ; i--)
        arr[i] = maxheap.extractMax();    
}

template<typename T>
void heapSort2(T arr[], int n){
    MaxHeap<T> maxheap = MaxHeap<T>(arr,n); 
    for( int i = n-1 ; i >= 0 ; i--)
        arr[i] = maxheap.extractMax();
}

// 优化的shiftDown过程，用赋值取代swap，从0开始索引 
template<typename T>
void __shiftDown2(T arr[], int n, int k){
    // k为起始位置 
    T e = arr[k];
    // 左孩子不越界 
    while( 2*k+1 < n ){
        int j = 2*k+1;
        // 右孩子比左孩子大 
        if( j + 1 < n && arr[j+1] > arr[j] )
            j += 1;
        if( e >= arr[j] ) break;
        // 和左、右孩子中较大的交换 
        arr[k] = arr[j];
        // k向下传递 
        k = j;
    }
    // 将堆头元素放到堆尾 
    arr[k] = e;
}

// 原地堆排序，直接在原数组上进行，不需额外空间 
template<typename T>
void heapSort(T arr[], int n){
    // 堆化 
    // 从0开始索引
    // 第一个非叶子节点索引 = (最后一个元素索引-1)/2
    for( int i = (n-1-1)/2 ; i >= 0 ; i-- )
        __shiftDown2(arr,n,i);
    // 不断把堆顶元素换到最后，完成排序 
    for( int i = n-1; i>0 ; i -- ){
        swap( arr[0] , arr[i] );
        __shiftDown2(arr, i, 0);
    }
} 

int main(){
    int n = 10000;
    //int *arr1 = SortTestHelper::generateNearlyOrderedArray(n,10);
    int *arr1 = SortTestHelper::generateRandomArray(n,0,10);
    int *arr2 = SortTestHelper::copyIntArray(arr1, n);
    //SortTestHelper::testSort("Insertion Sort",insertionSort,arr1,n);
    //SortTestHelper::testSort("Merge Sort",mergeSort,arr2,n);
    SortTestHelper::testSort("Heap Sort",heapSort,arr1,n);
    SortTestHelper::testSort("Quick Sort 3",quickSort3,arr2,n);
    
    delete[] arr1;
    delete[] arr2;
    
    return 0;
}

应用

• 优先队列：出队顺序和入队顺序无关，和优先级有关，优先级最高的出列，队列中的成员是动态增减的
  • 操作系统调度任务，先执行哪个
  • 不同上网用户对同一个服务器发出请求，服务器先回应哪个
  • 游戏角色攻击视野中的敌人，先攻击哪个（最强的？血最少的？...）

                      

• 在N个元素中选出前M个元素
  • 排序的话是NlogN，利用优先队列可达到NlogM（N越大，效率提升越明显）
• 实现优先队列
  • 普通数组：入队O(1)，出队O(n)
  • 顺序数组：入队O(n)，出队O(1)
  • 堆：入队O(lgn)，出队O(lgn)
  • 对于总共N个请求，使用数组，最差情况均为O(n^2)，使用堆为O(nlgn)

总结

• 堆的存储：在数组中，下标从1开始
• shiftUp干了什么：在堆尾部新插入元素后，调整堆以维护堆的定义
• shiftDown干了什么：从堆头取出一个元素后，将堆尾元素放到堆头，调整堆以维护堆的定义
• 直接建堆和堆化的区别：直接建堆是一个个插入，堆化是在现拥有数组的基础上调整数据
• 如何优化：额外用了O(n)的空间，可改为原地排序