堆操作及应用

1. 堆是一个完全二叉树，堆主要设计到的操作有插入，删除，堆化。

2. 堆的主要应用有堆排序：从小到大排序，使用大顶堆；从大到小排序，使用小顶堆。

3. 下面以大顶堆为例，给出实现代码：

#include <iostream>
#include <cassert>

using namespace std;

//大顶堆的实现
class Myheap
{
public:
    Myheap(int hSize=DefaultSize)
    {
        if (hSize>DefaultSize)
        {
            heapSize=hSize;
        }
        else
        {
            heapSize=DefaultSize;
        }
        data=new int[heapSize];
        currentSize=0;
    }
    int leftChild(int pos)
    {
        return 2*pos+1;
    }
    int rightChild(int pos)
    {
        return 2*pos+2;
    }
    int parent(int i)
    {
        return (i-1)>>1;
    }

    //递归的处理方式
    //void Max_Heapify(int pos)
    //{
    //    assert(pos<currentSize && pos>=0);
    //    int l=leftChild(pos);
    //    int r=rightChild(pos);
    //    int maxNumber=pos;
    //    if (l<currentSize)
    //    {
    //        maxNumber=data[l]>data[maxNumber] ? l:maxNumber;
    //    }
    //    if (r<currentSize)
    //    {
    //        maxNumber=data[r]>data[maxNumber] ? r:maxNumber;
    //    }
    //    if (maxNumber!=pos)
    //    {
    //        swap(data[pos],data[maxNumber]);
    //        Max_Heapify(maxNumber);
    //    }
    //}

    //使用循环替代尾递归
    void Max_Heapify(int pos)
    {
        assert(pos<currentSize && pos>=0);
        while (pos<currentSize)
        {
            int l=leftChild(pos);
            int r=rightChild(pos);
            int maxNumber=pos;
            if (l<currentSize)
            {
                maxNumber=data[l]>data[maxNumber] ? l:maxNumber;
            }
            if (r<currentSize)
            {
                maxNumber=data[r]>data[maxNumber] ? r:maxNumber;
            }
            if (maxNumber!=pos)
            {
                swap(data[pos],data[maxNumber]);
            }
            else
            {
                break;
            }
            pos=maxNumber;
        }
    }
    bool isFull()
    {
        return currentSize==heapSize;
    }

    //插入，将元素插入到末尾，然后将元素上浮到合适的位置
    void insert(int elem)
    {
        if (isFull())
        {
            cout<<"Heap is full!!!"<<endl;
            return ;
        }
        data[currentSize++]=elem;
        int pa=parent(currentSize-1);
        int cur=currentSize-1;
        while ((pa>=0) && (data[pa]<data[cur]))
        {
            swap(data[pa],data[cur]);
            cur=pa;
            pa=parent(cur);
        }
    }

    //删除堆顶的元素
    //将堆顶元素和最后一个元素交换，然后将堆顶元素下降
    //到一个合适的位置
    void deleteMax()
    {
        swap(data[currentSize-1],data[0]);
        currentSize--;
        Max_Heapify(0);
    }

    //打印
    void print()
    {
        for (int i=0;i<heapSize;i++)
        {
            cout<<data[i]<<"  ";
        }
        cout<<endl;
    }

    //堆排序
    void HeapSort()
    {
        int i=currentSize-1;
        for (;i>=1;i--)
        {
            swap(data[i],data[0]);
            currentSize--;
            Max_Heapify(0);
        }
    }
    ~Myheap()
    {
        delete data;
    }
protected:
private:
    enum {DefaultSize=10};
    int heapSize;
    int currentSize;
    int *data;
};

int main()
{
    enum {length=11};
    int number[length]={12,23,2,34,5,123,6,0,1,34,0};
    Myheap myheap(length);
    for(int i=0;i<length;i++)
    {
        myheap.insert(number[i]);
    }
    myheap.print();
    //int pPos=myheap.parent(length-1);
    //for (int i=pPos;i>=0;i--)
    //{
    //    myheap.Max_Heapify(i);
    //}
    myheap.HeapSort();
    myheap.print();
    //myheap.deleteMax();
    //myheap.print();
}

4. 堆的应用：

　　（1） 一个文件中包含了1亿个随机整数，如何快速的找到最大(小)的100万个数字?（时间复杂度：O（n lg k））。

　　答：若要找出100万个最大的数，需要维护一个含有100万元素的小顶堆。遍历1亿个数，如果某个数比小顶堆最小元素大，则用这个数替代小顶堆中的最小数，之后使小顶堆最小堆化。遍历结束之后，堆中存储的就是最大的100万个数。遍历一次的时间复杂度O(n)，最小堆化O(lgk)。总的时间复杂度O（n lg k）。

5.

堆是一种非常基础但很实用的数据结构，很多复杂算法或者数据结构的基础就是堆，因而，了解和掌握堆这种数据结构显得尤为重要。

 

参考资料：

http://dongxicheng.org/structure/bitmap/

算法导论