堆的综合操作

          前几天写了一个堆的综合操作

 

#include <iostream.h>
#include <string.h>
#define DefaultSize 12
class MinHeap                 //最小堆的类
...{
private:

    int *heap;
    int CurrentSize;
    int MaxHeapSize;

public:
    MinHeap(int maxSize)
    ...{
        MaxHeapSize = DefaultSize < maxSize ? maxSize : DefaultSize;
        heap = new int[MaxHeapSize];
        CurrentSize = 0;
    }

    MinHeap(int array[], int n)
    ...{
        MaxHeapSize = DefaultSize < n ? n : DefaultSize;
        heap = new int[MaxHeapSize];
        memcpy(heap, array, n*sizeof(int));
        CurrentSize = n;
        int CurrentPos = (CurrentSize - 2) / 2; //当前位置指针指向最后一个有分支节点的子树
        while(CurrentPos >= 0) //如果当前位置指针大于0
        ...{
            FilterDown(CurrentPos, CurrentSize - 1); //依次将各子树调整为最小堆
            CurrentPos--;   //当前指针自减
        }
    }

    void FilterDown(const int start, const int EndOfHeap) 
    ...{
        int i = start;
        int j = 2 * i + 1;   //先让j指向i的左子女
        int temp = heap[i];  //将i指向的节点缓存

        while(j <= EndOfHeap)
        ...{
            if(j < EndOfHeap && heap[j] > heap[j+1])
                j++;        //令j指向i的左右子女当中最小的一个
            if(temp <= heap[j]) //如果缓存节点比j指向的节点小的话  
                break;
            else           //如果缓存节点大于j指向的节点的话
            ...{
                heap[i] = heap[j]; //j指向的节点的值付给i指向的节点
                i = j;             //令i指向刚才j的位置
                j = j * 2 + 1;     //j指向j的左子女
            }
        }
        heap[i] = temp;    //缓存节点付给i指向的节点
    }

    bool Insert(const int &x)  //插入元素
    ...{
        if(CurrentSize == MaxHeapSize)
        ...{
            cerr<<"堆满! " <<endl;
            return false;
        }

        heap[CurrentSize] = x;  //先把插入的元素放在堆的最后一个叶子节点的位置
        FilterUp(CurrentSize);  //向上调整
        CurrentSize++;

        return true;
    }

    void FilterUp(int start)
    ...{
        int j = start;
        int i = (j - 1) / 2;  //i指向j的双亲节点
        int temp = heap[j];   //暂存heap[j]的值

        while(j > 0)
        ...{
            if(temp >= heap[i])  //如果暂存大于它的双亲节点的话，跳出循环
                break;
            else
            ...{
                heap[j] = heap[i]; //双亲节点付给heap[j]
                j = i;             //j指向刚才的双亲
                i = (i - 1) / 2;
            }
        }

        heap[j] = temp;
    }

    void PrintHeap()
    ...{
        int *p = heap;

        for(int i = 0; i < CurrentSize; i++)
        ...{
            cout<<*p<<" ";
            p++;
        }
        cout<<endl;
    }

    int RemoveHeap()
    ...{
        int x = heap[0];

        heap[0] = heap[CurrentSize - 1];  //最后一个叶子节点将填补根节点
        CurrentSize--;

        FilterDown(0, CurrentSize - 1);   //调整为最小堆
        return x;
    }
    virtual ~ MinHeap()
    ...{
        delete []heap;
    }
};
void main()
...{
    int a[] = ...{53, 17, 78, 9, 45, 65, 87, 23};
    int n = sizeof(a)/sizeof(a[0]);
    MinHeap myHeap(a, n);
    cout<<"建立的最小堆为:"<<endl;
    myHeap.PrintHeap();
    cout<<"插入元素后的最小堆为: "<<endl;
    myHeap.Insert(11);
    myHeap.PrintHeap();
    cout<<"堆顶元素为:"<<endl;
    int x = myHeap.RemoveHeap();
    cout<<x<<endl;
    myHeap.PrintHeap();
}