大根堆，小根堆，堆排序 木

大根堆: 根节点value不小于子节点的value，满足这条性质的二叉树即为大根堆。

小根堆：根节点value不大于子节点的value，满足这条性质的二叉树即为小根堆。

从大根堆的定义可知：在大根堆里要得到最大值只需o(1)的时间。所以很明显，大根堆可以求最大值和维护前k小的数。注意是前k小的数，不是前k大的数，因为当前要插入到堆里的数可以直接和堆里最大值考虑，如果比堆里最大的都还要小，那就那这个值放到堆里，这样就维护了前k小的数。

如果k很大的话，要划分为很多个堆。小根堆和大根堆相反。

堆的操作主要有：

bool isEmpty(int *a); // 判断堆是否为空
bool isFull(int *a); //判断堆是否为满
int top(int *a);// 返回堆顶元素
void pop(int *a);//删除堆顶元素

pop是删除堆顶元素，直接把最后面那个元素的值赋给堆顶，同时元素个数减一，然后是调整堆。

void push(int *a，int);//插入元素

push之前要判断空间是否为满，直接把value放到堆最后，然后是调整堆。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

#define maxSize 200008<<2
int heap[maxSize];

bool isEmpty(int *a);
bool isFull(int *a);
int top(int *a);
void pop(int *a);
void push(int *a, int);

template <typename T>
void Swap( T& a, T& b)
{
    T tmp = a; a = b; b = tmp;
}

// 判空
bool isEmpty(int *a){
    return a[0]<=0? true: false;
}
//
bool isFull(int *a){
     return a[0]+1>=maxSize? true: false;
}

int top(int *a){
    if(isEmpty(a) ) {
         puts("since for the heap is empty, the operation is illegel!");
         exit(0);
    }
    return heap[1];
};

// 调整堆，自上往下
void adjust( int *a ) {
     int i = 1;
     while(  i <= a[0] ){
         if((i<<1|1) <= a[0] ) // 存在左右子树。
         {
             if(a[i<<1] > a[i] && a[i<<1]>a[i<<1|1]){
                   Swap(a[i<<1], a[i]); i <<= 1;
             }else if(a[i<<1|1] > a[i]) {
                  Swap(a[i<<1|1], a[i]);
                  i = i<<1|1;
             }else break;

         }else if( (i<<1) <= a[0] ) { // 只存在左子树
             if(a[i<<1] > a[i]){
                 Swap(a[i<<1], a[i]); i <<= 1;
             }else break;

         }else break;
     }
}

void pop(int *a){
    if(isEmpty(a) ) {
         fprintf(stderr, "the heap is empty!");
         exit(0);
    }
    a[1] = a[a[0]-- ];
    adjust(a);
}

void outPut(int *a){
     puts("***********************************\n");
     if(isEmpty(a) ) puts("the heap is empty!");
     else
     {
         for ( int i=1; i<=a[0]; ++i)
            printf("%d %d\n", i, a[i]);
     }
     puts("***********************************\n");
}

void push(int *a, int value){
    if(isFull(a) ) {
         fprintf(stderr, "the heap is full!\n");
         return ;
    }
    a[++a[0] ] = value;
    int i = a[0]; // 调整堆,自下而上
    while(i > 1 && a[i] > a[i/2]) {
        Swap(a[i], a[i/2]); i >>= 1;
    }
};

int main()
{
    heap[0] = 0; // 记录元素个数；
    printf("push five intgers: ");
    for ( int i=0, tmp; i<5; ++i ) {
        scanf ("%d", &tmp);
        push(heap, tmp); // 插入元素
    }
    outPut(heap); // 输出堆

    int maxx = top(heap); // 取出堆的最大值
    printf("the maxx in current tree is %d \n", maxx);

    // 删除堆顶(最大值)
    printf("delete tha top node.\n");
    pop(heap);
    outPut(heap);

    printf("输入一个元素进行插入操作：");
    int tmp; scanf("%d", &tmp);
    push(heap, tmp);
    outPut(heap);

    printf("clear the heap.\n");
    while(!isEmpty(heap) ) pop(heap);
    printf("the size of the heap is %d\n", heap[0]);

    system("pause");
};

堆排序： 向大根堆中插入和删除元素的时间都是0(logn)，根据这两个操作的时间，可以知道堆排序的时间复杂度为n*log(n). 堆排序思路： 在待排序的元素中建立大根堆，每次都把最大的取出来，这样就完成了排序。未完，待续。。。。