C源码@数据结构与算法->BinomialQueue

/*
 * fatal.h
 */
#include 
   
   
    
    
#include 
    
    
     
     

#define Error(Str)		FatalError(Str)
#define FatalError(Str)	fprintf(stderr, "%s\n", Str), exit(-1)	
    
    
   
   

/*
 * testbin.cpp
 */
#include 
    
    
     
     
#include "binomial.h"

#define MaxSize (12000)

int main()
{
	BinQueue H;
	int i, j;
	ElementType AnItem;

	H = Initialize();
	for (i = 0, j = MaxSize / 2; i < MaxSize; ++i, j = (j + 71) % MaxSize)
	{
		H = Insert(j, H);
	}

	j = 0;
	while (!IsEmpty(H))
	{
		if (DeleteMin(H) != j++)
		{
			printf("Error in DeleteMin, %d\n", j);
		}
	}

	if (j != MaxSize)
	{
		printf("Error in counting!\n");
	}

	printf("Done...\n");

	return 0;
}
    
    

/*
 * binomial.h
 */
#ifndef _BINQUEUE_H
#define _BINQUEUE_H

#ifndef NULL
#define NULL (0)
#endif

typedef long ElementType;
#define Infinity (30000L)

#define MaxTrees (14)	/* Stores 2^14 - 1 items */
#define Capacity (16383)

struct BinNode;
typedef struct BinNode *BinTree;
struct Collection;
typedef struct Collection *BinQueue;

#ifdef __cplusplus
extern "C" {
#endif

BinQueue Initialize();
void Destroy(BinQueue H);
BinQueue MakeEmpty(BinQueue H);
BinQueue Insert(ElementType Item, BinQueue H);
BinQueue Merge(BinQueue H1, BinQueue H2);
int IsEmpty(BinQueue H);
int IsFull(BinQueue H);
ElementType FindMin(BinQueue H);
ElementType DeleteMin(BinQueue H);

#ifdef __cplusplus
}
#endif

#endif /* _BINQUEUE_H */

/*
 * binomial.cpp
 */
#include 
     
     
      
      
#include "fatal.h"
#include "binomial.h"

typedef struct BinNode *Position;

struct BinNode
{
	ElementType Element;
	Position LeftChild;
	Position NextSibling;
};

struct Collection
{
	int CurrentSize;
	BinTree TheTrees[MaxTrees];
};

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;
}

static 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;
	}

	return H;
}

BinQueue Insert(ElementType Item, BinQueue H)
{
	BinTree NewNode;
	BinQueue OneItem;

	NewNode = (BinTree)malloc(sizeof(struct BinNode));
	if (NewNode == NULL)
	{
		FatalError("Out of space!");
	}
	NewNode->LeftChild = NULL;
	NewNode->NextSibling = NULL;
	NewNode->Element = Item;

	OneItem = Initialize();
	OneItem->CurrentSize = 1;
	OneItem->TheTrees[0] = NewNode;

	return Merge(H, OneItem);
}

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("Merge would exceed capacity!");
	}

	H1->CurrentSize += H2->CurrentSize;
	for (i = 0, j = 1; j <= H1->CurrentSize; ++i, j *= 2)
	{
		T1 = H1->TheTrees[i];
		T2 = H2->TheTrees[i];

		switch (!!T1 + 2 * !!T2 + 4 * !!Carry)
		{
		case 0: /* No trees */
		case 1: /* Only H1 */
			break;
		case 2: /* Only H2 */
			H1->TheTrees[i] = T2;
			H2->TheTrees[i] = NULL;
			break;
		case 4: /* Only Carry */
			H1->TheTrees[i] = Carry;
			Carry = NULL;
			break;
		case 3: /* H1 and H2 */
			Carry = CombineTrees(T1, T2);
			H1->TheTrees[i] = NULL;
			H2->TheTrees[i] = NULL;
			break;
		case 5:	/* H1 and Carry */
			Carry = CombineTrees(T1, Carry);
			H1->TheTrees[i] = NULL;
			break;
		case 6:	/* H2 and Carry */
			Carry = CombineTrees(T2, Carry);
			H2->TheTrees[i] = NULL;
			break;
		case 7:	/* All threes */
			H1->TheTrees[i] = Carry;
			Carry = CombineTrees(T1, T2);
			H2->TheTrees[i] = NULL;
			break;
		}
	}

	return H1;
}

int IsEmpty(BinQueue H)
{
	return H->CurrentSize == 0;
}

int IsFull(BinQueue H)
{
	return H->CurrentSize == Capacity;
}

ElementType FindMin(BinQueue H)
{
	int i;
	ElementType MinItem;

	if (IsEmpty(H))
	{
		FatalError("Empty binomial queue!");
	}

	MinItem = Infinity;
	for (i = 0; i < MaxTrees; ++i)
	{
		if (H->TheTrees[i]
			&& H->TheTrees[i]->Element < MinItem)
		{
			MinItem = H->TheTrees[i]->Element < MinItem;
		}
	}

	return MinItem;
}

ElementType DeleteMin(BinQueue H)
{
	int i, j;
	int MinTree;	/* The tree with the minimum item */
	BinQueue DeletedQueue;
	Position DeletedTree, OldRoot;
	ElementType MinItem;

	if (IsEmpty(H))
	{
		FatalError("Empty binomial queue!");
	}

	MinItem = Infinity;
	for (i = 0; i < MaxTrees; ++i)
	{
		if (H->TheTrees[i]
			&& H->TheTrees[i]->Element < MinItem)
		{
			/* Update minimum */
			MinItem = H->TheTrees[i]->Element;
			MinTree = i;
		}
	}

	DeletedTree = H->TheTrees[MinTree];
	OldRoot = DeletedTree;
	DeletedTree = DeletedTree->LeftChild;
	free(OldRoot);

	DeletedQueue = Initialize();
	DeletedQueue->CurrentSize = (1 << MinTree) - 1;
	for (j = MinTree - 1; j >= 0; j--)
	{
		DeletedQueue->TheTrees[j] = DeletedTree;
		DeletedTree = DeletedTree->NextSibling;
		DeletedQueue->TheTrees[j]->NextSibling = NULL;
	}

	H->TheTrees[MinTree] = NULL;
	H->CurrentSize -= DeletedQueue->CurrentSize + 1;

	Merge(H, DeletedQueue);

	return MinItem;
}