堆的綜合操作

          前幾天寫了一個堆的綜合操作

 

#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();
}