二项队列实现文件C语言

最新推荐文章于 2021-07-15 22:30:27 发布
最新推荐文章于 2021-07-15 22:30:27 发布
阅读量1.3k 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 语言 c struct traversal insert
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Golden_Shadow/article/details/6009172
版权 

/*	binomial-queue.c --  二项队列实现文件	*/
#include "binomial-queue.h"

/*	局部函数声明	*/

static SubTree Combine_Trees (SubTree t1, SubTree t2) ;
static Node * Make_Node (const Item item) ;
static void Recursively (const SubTree t, void (* pfun) (const Item item)) ;

/*	接口函数定义	*/

int InitializeBinQueue (BinQueue * const pbq, const int size)
{
	int i ;

	if (size <= 0)
		return 0 ;
	*pbq = (struct binqueue *) malloc (sizeof (struct binqueue)) ;
	if (NULL == *pbq)
		return 0 ;
	(*pbq) -> forest = (SubTree *) malloc (sizeof (SubTree) * size) ;
	if (NULL == (*pbq) -> forest)
	{
		free (*pbq) ;
		return 0 ;
	}
	for (i = 0; i < size; i++)
		(*pbq) -> forest[i] = NULL ;
	(*pbq) -> size = size ;
	(*pbq) -> current = 0 ;

	return 1 ;
}

int BinQueueIsEmpty (const BinQueue bq)
{
	return 0 == bq -> current ;
}

BinQueue Merge (BinQueue bq1, BinQueue bq2)
{
	BinQueue temp ;
	SubTree t1, t2, carry = NULL ;
	int i, j, ct, index = 0 ;

	//	此处的检测, 很重要.
	if (bq1 == bq2)
		return bq1 ;
	if (bq1 -> current + bq2 -> current > bq1 -> size)
		return bq1 ;
	bq1 -> current += bq2 -> current ;
	//	保障 bq1 -> current > bq2 -> current								-->
	if (bq1 -> current < bq2 -> current)
	{
		temp = bq1 ;
		bq1 = bq2 ;
		bq2 = temp ;
	}
	//	这样就可以通过下面的 bq2 所有子树都已被合并过的条件检测有
	//	效地避免当 bq2 -> current 很小的时候将造成的太多次不必要的条件检测	-->
	for (i = 0, j = 1, ct = 0; j <= bq1 -> current; i++, j *= 2)
	{
		t1 = bq1 -> forest[i] ;
		//	以下判断是为了应对Insert的情况, 因为我在Insert时只分配了1棵子树的空间
		if (1 == index)
			t2 = NULL ;
		else if (1 == bq2 -> size)
		{
			index = 1 ;
			t2 = bq2 -> forest[i] ;
		}
		else
			t2 = bq2 -> forest[i] ;
		//	这个方法真的很巧妙, 开了眼界
		switch (!!t1 + 2 * !!t2 + 4 * !!carry)
		{
			//	no trees
			case 0 :	break ;
			//	only bq1
			case 1 :	if (ct == bq2 -> size)
						{
							Release (bq2) ;
							return bq1 ;
						}
						break ;
			//	only bq2
			case 2 :	bq1 -> forest[i] = t2 ;
						bq2 -> forest[i] = NULL ;
						ct++ ;
						break ;
			//	only carry
			case 4 :	bq1 -> forest[i] = carry ;
						carry = NULL ;
						break ;
			//	bq1 and bq2
			case 3 :	carry = Combine_Trees (t1, t2) ;
						bq1 -> forest[i] = bq2 -> forest[i] = NULL ;
						ct++ ;
						break ;
			//	bq1 and carry
			case 5 :	carry = Combine_Trees (t1, carry) ;
						bq1 -> forest[i] = NULL ;
						break ;
			//	bq2 and carry
			case 6 :	carry = Combine_Trees (t2, carry) ;
						bq2 -> forest[i] = NULL ;
						ct++ ;
						break ;
			//	all there
			case 7 :	bq1 -> forest[i] = carry ;
						carry = Combine_Trees (t1, t2) ;
						bq2 -> forest[i] = NULL ;
						break ;
		}
	}

	return bq1 ;
}

BinQueue Insert (BinQueue bq, const Item item)
{
	BinQueue temp ;
	int size = 1 ;

	if (bq -> size == bq -> current)
		return bq ;
	if (!InitializeBinQueue (&temp, size))
	{
		free (temp -> forest) ;
		free (temp) ;
		return bq ;
	}
	temp -> forest[0] = Make_Node (item) ;
	if (NULL == temp -> forest[0])	// 话说这个位置原先有一个";"
	{
		free (temp -> forest[0]) ;
		free (temp) ;
		return bq ;
	}
 	temp -> current = 1 ;
	bq = Merge (bq, temp) ;

	return bq ;
}

Item DeleteMin (BinQueue bq)
{
	BinQueue deleted_queue ;
	SubTree deleted_tree, old_root ;
	Item min ;
	int i, j, size, min_index ;

	if (BinQueueIsEmpty (bq))
		return -INFINITY ;
	min = INFINITY ;
	for (i = 0, size = bq -> size; i < size; i++)
	{
		if (bq -> forest[i] && bq -> forest[i] -> item < min)
		{
			min = bq -> forest[i] -> item ;
			min_index = i ;
		}
	}
	if (INFINITY == min)
		return INFINITY ;
	deleted_tree = bq -> forest[min_index] ;
	old_root = deleted_tree ;
	deleted_tree = deleted_tree -> left ;
	free (old_root) ;
	InitializeBinQueue (&deleted_queue, (1 << min_index) - 1) ;
	for (j = min_index - 1; j >= 0; j--)
	{
		deleted_queue -> forest[j] = deleted_tree ;
		deleted_tree = deleted_tree -> nextsibling ;
		deleted_queue -> forest[j] -> nextsibling = NULL ;
	}
	bq -> forest[min_index] = NULL ;
	bq -> current -= deleted_queue -> current + 1 ;

	bq = Merge (bq, deleted_queue) ;

	return min ;
}

void Traversal (const BinQueue bq, void (* pfun) (const Item item))
{
	int i, size ;

	for (i = 0, size = bq -> size; i < size; i++)
		if (bq -> forest[i])
			Recursively (bq -> forest[i], pfun) ;
}

void Release (const BinQueue bq)
{
	int i, size ;

	for (i = 0, size = bq -> size; i < size; i++)
	{
		if (bq -> forest[i])
			free (bq -> forest[i]) ;
	}
	free (bq) ;
}

/*	局部函数定义	*/

static SubTree Combine_Trees (SubTree t1, SubTree t2)
{
	if (t1 -> item > t2 -> item)
		return Combine_Trees (t2, t1) ;	//	话说这个地方的 t1 原来是 t2, 真不知道我这一天都在想些什么
	t2 -> nextsibling = t1 -> left ;
	t1 -> left = t2 ;

	return t1 ;
}

static Node * Make_Node (const Item item)
{
	Node * new_node ;

	new_node = (Node *) malloc (sizeof (Node)) ;
	if (NULL == new_node)
		return NULL ;
	new_node -> item = item ;
	new_node -> left = new_node -> nextsibling = NULL ;

	return new_node ;
}

static void Recursively (const SubTree t, void (* pfun) (const Item item))
{
	if (t -> left)
		Recursively (t -> left, pfun) ;
	if (t -> nextsibling)
		Recursively (t -> nextsibling, pfun) ;
	(* pfun) (t -> item) ;
}

Golden_Shadow
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二项队列 C语言
you-know-who的博客
04-11 837
实现了二项队列的基本功能，参考书籍 数据结构与算法分析 C描述 头文件 #ifndef _BINQUEUE_H #define _BINQUEUE_H struct Binnode; struct Collection; typedef struct Collection *BinQueue; typedef struct Binnode *BinTree; typedef int Ite
二项队列--C语言实现
fktr_70的博客
01-01 630
binqueue.h#ifndef _BINQUEUE_H_ #define _BINQUEUE_H_ #define MaxTrees 100 #define Capacity 1000struct BinNode; struct Collection; typedef int ElementType; typedef struct BinNode *Position; typedef Posit
二项队列头文件C语言
让阳光照进心里
11-15 1196
/* binomial-queue.c -- 二项队列实现文件 */ #include "binomial-queue.h" /* 局部函数声明 */ static SubTree Combine_Trees (SubTree t1, SubTree t2) ; static Node * Make_Node (const Item item) ; static void Recursively (const SubTree t, void (* pfun) (const Item it
二项队列的C实现
11-30
二项队列的C实现
一种二项队列实现
yxw0609131056的博客
03-02 269
二项队列的优势：不仅支持insert、delete_min和merger操作，而且最坏情况下运行时间为O（logN），插入操作平均花费                                   时间为O(1)二项队列不是一颗堆序的树，而是堆序树的集合，其中每一颗堆序树又称为二项树二项队列性质：高度为K的二项树恰好有2的K次幂个节点我们可以使用二项树的集合唯一地表示任意大小的优先队列#in...
队列_队列、C语言_
10-02
C语言虽然没有内置的队列类型，但我们可以使用结构体和指针来实现自己的队列数据结构。 在提供的文件中，我们有三个关键的文件：`queue.c`、`use_q.c`和`queue.h`。`queue.c`通常包含了队列数据结构的定义和相关...
详解数据结构C语言实现之循环队列
09-01
在C语言中，实现循环队列通常涉及定义一个结构体来存储队列的属性，包括存储元素的数组、队头指针`front`、队尾指针`rear`以及队列的最大容量`maxsize`。 1. 循环队列基础： - 参数：循环队列需要两个关键参数，即...
c语言实现队列功能
11-04
`cquene.cpp`是实现文件，它将具体实现`cquene.h`中声明的函数。例如，可能会有以下函数： - `initQueue()`: 初始化队列。 - `enqueue(data)`: 向队列中插入一个元素`data`。 - `dequeue()`: 移除并返回队头元素。 ...
用C语言实现（块）队列
07-17
本文将详细介绍如何使用C语言实现一个块队列，以及如何通过提供的`queue_dt_init`、`queue_dt_in`和`queue_dt_out`函数来操作这个队列。 队列是一种先进先出（FIFO，First In First Out）的数据结构，它的主要特点...
二项队列
kdb_viewer的博客
10-10 171
是对左式树的改进，对于insert操作有O(1)平均时间 源码如下： #ifdef _cplusplus extern "C" { #endif #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; #define MaxTrees 16 #define Infinity 0x800000...
Binomial Queue C语言实现
andy的专栏
12-21 966
typedef struct BinNode *Position; typedef struct Collection *BinQueue; typedef struct BinNode *BinTree; #define MaxTrees 500 #define Infinity 32767 struct BinNode{ ElementType element; Position left
数据结构：二项队列原理及其C++实现
weixin_41427400的博客
03-25 1400
前言：        这次，将进行介绍的是一个特殊而有趣的队列——二项队列。在二项队列中你会发现人们是怎么把二进制的思想体现在数据结构中的；同时二项队列也是一种很高效的队列，对于合并、插入以及DeleteMin操作，它的最坏运行时间为O(LogN)，而插入平均花费常数时间进行。那么接下来开始我们的讲解吧~~原理：        首先我们得知道，二项队列并不是一颗堆序的树，而是堆序树的一个集合，也可...
优先队列——二项队列（binominal queue）
PacosonSWJTU的博客
01-22 1516
【0】README0.1） 本文文字描述部分转自 数据结构与算法分析， 旨在理解 优先队列——二项队列（binominal queue） 的基础知识； 0.2） 本文核心的剖析思路均为原创（insert，merge和deleteMin的操作步骤图片示例）， 源代码均为原创； 0.3） for original source code, please visit https://github
优先队列之二项队列
Coding365
06-05 851
1 二项队列的结构 二项队列不同于我们已经看到的所有优先队列的实现之处在于，一个二项队列不是一棵堆序的树，而是堆序树的集合，成为森林。堆序树的每一棵树都是有约束的形式，叫做二项树。每一个高度至多存在一棵二项树。高度为0的二项树是一棵单节点树；高度为k的二项树Bk通过一棵二项树BK-1附接到另一棵二项树Bk-1的根上而构成。如下图，B0，B1，B2，B3，B4皆为二项树。而它们合起来就是二项队
C源码@数据结构与算法->BinomialQueue
头像是我的偶像的专栏
08-24 456
/* * fatal.h */ #include #include #define Error(Str) FatalError(Str) #define FatalError(Str) fprintf(stderr, "%s\n", Str), exit(-1) /* * testbin.cpp */ #include #include "binomia
二项队列介绍及其实现
Castria的博客
07-15 1180
注：此博客改编自《数据结构与算法分析：C语言描述》中二项队列一节。
看图说话之二项队列(优先队列)——原理解析
涂印的博客
10-16 5182
详细介绍了二项树，二项队列的基本原理，介绍了二项队列的建队，入队，出队等操作。
最小生成树（普利姆算法）
m980828的博客
06-11 1219
源代码： #include<stdio.h> #include<stdlib.h> #define MVNum 100 //最大顶点数 #define INFINITY 32767 //表示权值很大，意味着两个顶点之间没有连接 typedef char VerTexType; //定义数据类型 typedef int ArcType; typedef struct ...
c语言队列存入文件,队列实现文件C语言
最新发布
06-12
要实现队列存入文件，可以考虑以下几个步骤： 1. 定义队列结构体，包括队列的头节点、尾节点、节点数量和节点数据类型等信息。 ``` typedef struct node { int data; struct node* next; } Node; typedef struct queue { Node* head; Node* tail; int size; } Queue; ``` 2. 初始化队列，将头节点和尾节点都指向NULL，节点数量设为0。 ``` void initQueue(Queue* q) { q->head = NULL; q->tail = NULL; q->size = 0; } ``` 3. 实现入队操作，将新节点加入队列末尾，同时更新尾节点和节点数量。 ``` void enqueue(Queue* q, int data) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; newNode->next = NULL; if (q->head == NULL) { q->head = newNode; } else { q->tail->next = newNode; } q->tail = newNode; q->size++; } ``` 4. 实现出队操作，将队列头节点弹出，同时更新头节点和节点数量。 ``` int dequeue(Queue* q) { if (q->head == NULL) { return -1; // 队列为空，返回错误码 } int data = q->head->data; Node* temp = q->head; q->head = q->head->next; free(temp); q->size--; return data; } ``` 5. 将队列中的数据存入文件，可以使用标准C库中的文件操作函数，例如fopen、fprintf和fclose等。 ``` void saveQueue(Queue* q, char* filename) { FILE* fp = fopen(filename, "w"); if (fp == NULL) { printf("Error opening file.\n"); return; } Node* curr = q->head; while (curr != NULL) { fprintf(fp, "%d\n", curr->data); curr = curr->next; } fclose(fp); } ``` 完整代码示例： ``` #include <stdio.h> #include <stdlib.h> typedef struct node { int data; struct node* next; } Node; typedef struct queue { Node* head; Node* tail; int size; } Queue; void initQueue(Queue* q) { q->head = NULL; q->tail = NULL; q->size = 0; } void enqueue(Queue* q, int data) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; newNode->next = NULL; if (q->head == NULL) { q->head = newNode; } else { q->tail->next = newNode; } q->tail = newNode; q->size++; } int dequeue(Queue* q) { if (q->head == NULL) { return -1; } int data = q->head->data; Node* temp = q->head; q->head = q->head->next; free(temp); q->size--; return data; } void saveQueue(Queue* q, char* filename) { FILE* fp = fopen(filename, "w"); if (fp == NULL) { printf("Error opening file.\n"); return; } Node* curr = q->head; while (curr != NULL) { fprintf(fp, "%d\n", curr->data); curr = curr->next; } fclose(fp); } int main() { Queue q; initQueue(&q); enqueue(&q, 1); enqueue(&q, 2); enqueue(&q, 3); saveQueue(&q, "queue.txt"); return 0; } ``` 运行此程序后，会在当前目录下生成一个名为“queue.txt”的文件，其中包含队列中的所有元素（每个元素占一行）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值