二叉堆 算法基础篇（一）

// suanfa.cpp : 定义控制台应用程序的入口点。
//
/*********************************************************
********************优先级队列之堆 ***********************


设计者：cslave
代码免责说明：
本代码可以拷贝使用，或者用于商业应用，但是由代码本身问题
所导致的损失，本人概不负责。
**********************************************************/

#include "stdafx.h"
#include <stdio.h>
#include <string>
#include <assert.h>
#include <iostream>
using namespace std;
#define MinData  0x80000000
#define MinPQSize 1
typedef int ElementType;

struct HeapStruct                                   //堆结构 堆需要三个变量，1 数组 存储元素  2 容量，最大存储元素个数  3 大小 堆的体格大小 
{
    int capacity;
    int size;
    ElementType *Elements;
};

typedef struct HeapStruct* PriorityQueue;


PriorityQueue Initialize(PriorityQueue H,int MaxElements)          //堆的初始化
{
    try
    {
    if(H==NULL)
        throw "error memory";
    if(MaxElements<MinPQSize)
        throw "capacity too little";
    }
    catch (char* sz)
    {
        cout<<sz<<endl;
    }
    H->Elements=(ElementType* )malloc((MaxElements+1)*sizeof(ElementType));        //堆数据是从1开始的 所以要多申请一个变量
    H->capacity=MaxElements;
    H->size=0;
    H->Elements[0]=MinData;
    return  H;

}

bool IsFul(PriorityQueue H)                  //判断堆是否为满
{
    if(H->capacity<=H->size)
    {
        return true;
    }
    return false;
}

void Insert(ElementType X,PriorityQueue H)  //堆的插入算法 复杂度为log（n）
{
    int i;
    try
    {
    if(IsFul(H))
    {
        cerr<<"PriorityQueue is Ful";
        return;
    }
    }
    catch (char* sz)
    {
        cout<<sz<<endl;
    }
    for(i=++H->size;H->Elements[i/2]>X;i/=2) //和父节点比较相互调换 直至根节点。
        H->Elements[i]=H->Elements[i/2];
    H->Elements[i]=X;
}
bool IsEmpty(PriorityQueue H)            //判断堆是否为空
{
    return(H->size==0);
}

ElementType DeleteMin(PriorityQueue H)     //删除小顶堆的堆顶元素，此算法可用于排序。复杂度log(n)
{

    int  i ,child;
    ElementType MinElement,LastElement;
    try
    {
    if(IsEmpty(H))
    {
        throw "PriorityQueue  is  empty!";
        return H->Elements[0];
    }
    }
    catch (char* sz)
    {
        cout<<sz<<endl;
    }
    MinElement=H->Elements[1];
    LastElement=H->Elements[H->size--];
    for(i=1;i*2<=H->size;i=child)                 //堆的调整，让最小元素上升作为父亲
    {
        child=2*i;
        if(child!=H->size&&H->Elements[child+1]<H->Elements[child])
            child++;
        if(LastElement>H->Elements[child])
            H->Elements[i]=H->Elements[child];
        else 
            break;
    }
    H->Elements[i]=LastElement;
    return MinElement;
}

void IncreaseKey(PriorityQueue H,int index,ElementType key)
{
    assert(index>=1);
    int child;
    int i;
    H->Elements[index]=key;
    for(i=index;2*i<=H->size;i=child)                          //对堆进行调整，找到小儿子，调换。
    {
        child=2*i;
        if(child!=H->size&&H->Elements[child]>H->Elements[child+1])
            child++;
        if(key<H->Elements[child])
            break;
        H->Elements[i]=H->Elements[child];
    }
    H->Elements[i]=key;
}
void DecreaseKey(PriorityQueue H,int index,ElementType key)
{
    assert(index>=1);
    int parent;
    int i;
    H->Elements[index]=key;
    for(i=index;i/2>=1;i=parent)                                   //和父亲作对比，然后对调
    {
        parent=i/2;
        if(key>H->Elements[parent])
            break;
        H->Elements[i]=H->Elements[parent];
    }
    H->Elements[i]=key;
}

void PrintQueueNode(PriorityQueue H)
{
    for(int i=1;i<H->size+1;i++) 
        cout<<i<<":"<<H->Elements[i]<<"\t";
    cout<<endl;
}

void PercolateDown(PriorityQueue H,int index)                //下虑函数
{
    if(H==NULL) return;
    int i,child;
    ElementType temp;
    for(i=index;2*i<=H->size;i=child)
    {
        child=2*i;
        if(child!=H->size&&H->Elements[child+1]<H->Elements[child])
            child++;
        if(H->Elements[i]<H->Elements[child])
            break;
        temp=H->Elements[child];
        H->Elements[child]=H->Elements[i];
        H->Elements[i]=temp;

    }
}



void PercolateUp(PriorityQueue H,int index)                 //上虑函数
{
    if(H==NULL) return;
    int i,parent;
    ElementType temp;
    for(i=index;2/i>=1;i=parent)
    {
        parent=i/2;
        if(H->Elements[i]>H->Elements[parent])
            break;
        temp=H->Elements[parent];
        H->Elements[parent]=H->Elements[i];
        H->Elements[i]=temp;

    }
}

void BuildHeap(PriorityQueue H)                          //建堆，逐次过滤，从(H->size)/2开始，就是从倒数第二层开始往上，逐层向下过滤，这个值可以舍弃没有子节点的数据
{
   assert(H!=NULL);
   int i;
   for( i=(H->size)/2;i>=1;i--)
       PercolateDown(H,i);
}

int _tmain(int argc, _TCHAR* argv[])
{
    int MaxElements;
    int index,key;
//    ElementType arr[10]={13,21,16,24,31,19,68,65,26,32};
    ElementType arr[10]={13,14,19,65,26,21,32,31,16,19};
    cout<<"Please  Input the MaxElement!"<<endl;
    cin>>MaxElements;

    PriorityQueue H=(PriorityQueue )malloc(MaxElements*sizeof(struct HeapStruct));
    
    Initialize( H, MaxElements);
#if 0
    for(int i=0;i<10;i++)
    {
        Insert(arr[i],H);
    }
    PrintQueueNode(H);

    cout<<"Please input the index and key you want to "<<endl;
    cin>>index>>key;

    //IncreaseKey( H, index, key);
    DecreaseKey(H,index,key);
    PrintQueueNode(H);
#endif    
    
    cout<<"BuidHeap have begun"<<endl;
    for(int i=0;i<10;i++)
    {
        H->Elements[i+1]=arr[i];
        H->size++;
    }
    PrintQueueNode(H);
    BuildHeap(H);
        PrintQueueNode(H);

    for(int j=0;j<10;j++)
        cout<<DeleteMin(H)<<"  ";
    return 0;
}