二项堆 算法基础篇（二）

// 二项堆.cpp : 定义控制台应用程序的入口点。
//
/***********************************************************

二项堆，算法数据结构复习

Designer By cslave



**************************************************************/


#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;
#define MaxTrees 14
#define INF (30000L)
#define Capacity (16383)
#define FatalError(Str) fprintf(stderr,"%s\n",Str),exit(1)
typedef int ElementType ;
typedef struct BinNode* Position;
typedef struct BinNode* BinTree;
struct BinNode                        //二项堆树节点
{
    ElementType Element;                     
    Position    LeftChild;            
    Position    NextSibling;
};
struct Collection                     //二项堆
{
    int CurrentSize;
    BinTree TheTrees[MaxTrees];
};

typedef struct Collection* BinQueue;       //二项堆类型的指针

bool IsEmpy(BinQueue H)                //二项堆是否为空 即是否含有节点       
{
    return H->CurrentSize==0;
}

bool IsFul(BinQueue H)                //二项堆是否为满，即节点数是否满载
{
    return H->CurrentSize==Capacity;
}

BinQueue Initialize()                   //二项堆初始化          
{
    BinQueue H;
    int i ;
    H=(BinQueue)malloc(sizeof (struct Collection));
    if(H==NULL)
    FatalError("out of space");
    H->CurrentSize=0;
    for(i=0;i<MaxTrees;i++)
        H->TheTrees[i]=NULL;           //初始化每一个二项堆树节点为空
    return H;
}

void DestroyTree(BinTree T)             //二项堆树节点的析构
{
    if(T!=NULL)
    {
        DestroyTree(T->LeftChild);
        DestroyTree(T->NextSibling);
        free(T);
    }
}

void Destroy(BinQueue H)               //二项堆的析构
{
    int i;
    for(i=0;i<MaxTrees;i++)
        DestroyTree(H->TheTrees[i]);
}


BinQueue MakeEmpty(BinQueue H)  //二项堆的置空
{
    int i;
    Destroy(H);
    for(i=0;i<MaxTrees;i++)
        H->TheTrees[i]=NULL;
    H->CurrentSize=0;
    return H;
}

BinTree CombineTrees(BinTree T1,BinTree T2) //子二项树的合并
{
    if(T1->Element>T2->Element)
        return CombineTrees(T2,T1);       //调整节点，根较小的二项树作为主合并点
    T2->NextSibling=T1->LeftChild;        //二项堆为了快速找出根的子树，采用的是左孩子，右兄弟存储策略 将小根的左孩子作为大根的右兄弟
    T1->LeftChild=T2;                    //将大根作为小根的左孩子
    return T1;
}

BinQueue Merge(BinQueue H1,BinQueue H2)  //子二项树的合并
{
    BinTree T1,T2,Carry=NULL;                               
    int i,j;
    if(H1->CurrentSize+H2->CurrentSize>Capacity)   //边界判定
        FatalError("Node Num too large!");
    H1->CurrentSize+=H2->CurrentSize;               
    for(i=0,j=1;j<=H1->CurrentSize;i++,j*=2)   //j作为判定条件，判断二项堆可以合并为几阶
    {
        T1=H1->TheTrees[i];                     //抽取对等子二项树树根
        T2=H2->TheTrees[i];
        switch(!!T1+2*!!T2+4*!!Carry)         //此处用法很巧妙 1  ！！取一个数的布尔真值  2 我们用三个变量的二进制三位码表征八种情况
        {
        case 0:                             //没有子二项树
        case 1:break;                        //只有T1 因为我们返回H1 所以什么都不用做。
        case 2:                             //只有T2，我们仅需将T2赋值给H1即可
            H1->TheTrees[i]=T2;
            H2->TheTrees[i]=NULL;
            break;
        case 4:                              //上一阶二项树有合并到本阶 ，本阶无二项树
            H1->TheTrees[i]=Carry;
            Carry=NULL;
            break;
        case 3:                          //本阶两堆都有要合并的子二项树，则产生高阶进位
            Carry=CombineTrees(T1,T2);
            H1->TheTrees[i]=H2->TheTrees[i]=NULL;    
            break;
        case 5:                           //有低阶来的进位，同时又自身的T1 则合并进位和T1
            Carry=CombineTrees(T1,Carry);
            H1->TheTrees[i]=NULL;
            break;
        case 6:                           //  有低阶来的进位，同时又自身的T2 则合并进位和T2
            Carry=CombineTrees(T2,Carry);
            H2->TheTrees[i]=NULL;
            break;
        case 7:                          //此处尚有迷惑，我个人感觉因该是先Tmp=Carry; Carry=CombineTrees(T1,T2);H1->TheTrees[i]=Tmp
            H1->TheTrees[i]=Carry;
            Carry=CombineTrees(T1,T2);
            H2->TheTrees[i]=NULL;
            break;
        }

    }
    return H1;
}


BinQueue insert(BinQueue H,ElementType X) //节点的插入，在二项堆插入节点值X 
{
    BinQueue TmpQue;
    BinTree NewNode;
    NewNode=(BinTree)malloc(sizeof(struct BinNode));
    if(NewNode==NULL)
        FatalError("memory insufficient!");
    NewNode->Element=X;
    NewNode->LeftChild=NULL;
    NewNode->NextSibling=NULL;
    TmpQue=Initialize();
    TmpQue->CurrentSize=1;
    TmpQue->TheTrees[0]=NewNode;          //创建仅含一个树节点的二项堆再与原来的堆做合并操作
    return Merge(H,TmpQue);
}

ElementType DeleteMin(BinQueue H)        //删除二项堆最小元素
{
    int i,j;
    int MinTree;
    BinQueue DeleteQueue;
    Position DeleteTree,OldRoot;
    ElementType MinItem;
    if(IsEmpy(H))
    {
        FatalError("BinQueue is Empty!");
        return -INF;
    }
    MinItem= INF;
    for(i=0;i<MaxTrees;i++)           //由二项堆性质可知，二项堆最小元素必然在每一个二项树的树根
    {
        if(H->TheTrees[i]&&H->TheTrees[i]->Element<MinItem) //找到并保存二项堆的最小值和索引i
        {
            MinItem=H->TheTrees[i]->Element;
            MinTree=i;
        }
    }
    DeleteTree=H->TheTrees[MinTree];      
    OldRoot=DeleteTree;
    DeleteTree=DeleteTree->LeftChild; //指向左儿子
    free(OldRoot);
    DeleteQueue=Initialize();        //初始化一二项堆
    DeleteQueue->CurrentSize=(1<<MinTree)-1; //更新堆元素个数
    for(j=MinTree-1;j>=0;j--)
    {
        DeleteQueue->TheTrees[j]=DeleteTree;//将左儿子作为堆的小一阶二项树
        DeleteTree=DeleteTree->NextSibling;        //将左儿子的右兄弟作为下一个处理对象
        DeleteQueue->TheTrees[j]->NextSibling=NULL; //处理后将二项树根节点右兄弟置空
    }
    H->TheTrees[MinTree]=NULL;//已经处理完最小树，将该树在堆数组中的元素置空
    H->CurrentSize-=DeleteQueue->CurrentSize+1;//从原始堆中减去处理掉的二项树元素个数，加1是因为还有二项树根我们删除了
    Merge(H,DeleteQueue);//合并H和新二项堆。
    return MinItem;



}





 





int _tmain(int argc, _TCHAR* argv[])
{
    ElementType arr[8]={12,24,21,65,14,16,18,26};
    BinQueue H=Initialize();
    for(int i=0;i<8;i++)
        insert(H, arr[i]);
    for(int j=0;j<8;j++)
        cout<<DeleteMin(H)<<" ";
    
    return 0;
}