堆基础总结（算法导论）

最新推荐文章于 2022-01-14 19:45:31 发布
最新推荐文章于 2022-01-14 19:45:31 发布
阅读量4.3k 收藏 15
点赞数 6
分类专栏： 数据结构与基础算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChinaJane163/article/details/49662033
版权

0.二叉堆

排序和顺序统计学中的堆排序所用到的堆，是一棵完全二叉树。存放时利用了二叉树，父亲节点序号（i），子节点序号（2*i，2*i+1）的性质
堆的建立，调整，输出实例如下：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
//root从data[1]开始存起 
//我想到的是左右孩子先比较，返回大孩子序号。大孩子再与父节点比较，如果不调换，调整结束，直接返回；如果调换，调换后，再将大孩子作为序号递归调用调整函数。但他使用迭代似乎可以更加的简洁 
//大顶堆 
void heapAdjust(vector<int> &data,int s,int l)//data为数据源，s为需要调整的节点 ,l为有效节点个数 
{
	int rc=data[s];//要调整的数值 
	int i=s;
	while(i<=l/2)
	{
		s=i;//此时s已经作为一个temp，临时的辅助变量 
		if(data[2*i]<data[2*i+1])//左孩子的数值小于右孩子的数值
		{
			i=2*i+1;//我要右孩子 
		}
		else
		{
			i=2*i;//我要左孩子 
		}
		
		if(rc>data[i])//父节点数值大于大孩子数值
		{
			return;//无需调整，结束堆调整 
		} 
		else
		{
			swap(data[s],data[i]);//小于则交换父节点和子节点的数值
		}	 
	}
}

void heapMake(vector<int> &data,int l)
{
	for(int i=l/2;i>=1;i--)
	{
		heapAdjust(data,i,l);
	}
}

void heapOutput(vector<int> &data,int l)
{
	for(int i=0;i<l;i++)
	{
		cout<<data[1]<<"\t";
		data[1]=-1;
		swap(data[1],data[l-i]);
		heapAdjust(data,1,l-i-1);
	}	
}

int main()
{
	vector<int> data;
	int l;
	cin>>l;
	data.push_back(-1);
	for(int i=0;i<l;i++)
	{
		int temp;
		cin>>temp;
		data.push_back(temp);
	}
	if(l%2==0)
	{
		data.push_back(-1);
	}
	heapMake(data,l);
	heapOutput(data,l);
}

1.二项堆

a.二项树

定义：

二项树Bk是一种递归定义的有序树。二项树B0只包含一个结点。二项树Bk由两个子树Bk-1连接而成：其中一棵树的根是另一棵树的根的最左孩子。

性质：

1）共有2的k次方个结点；

2）树的高度为k；

3）在深度i处恰有(上k,下i)（因此叫二项树）个结点，其中i=0,...,k；

4）根的度数为k，它大于任何其他结点的度数，并且，如果对根的子女从左到右编号为k-1，k-2,...，0，子女i是子树Bi的根。

b.二项堆

定义：由一组二项树组成，同时满足以下两个性质

1）H中的每个二项树遵循最小堆的性质：结点的关键字大于等于其父结点的关键字。

2）对于任意非负整数k，在H中至多有一棵二项树的根具有度数k。（如下图对于非负整数0,1,2,3，至多只有一棵度数为0,1,2,3的二项树）


存储模型：

struct heapNode
{
	int key;//该节点的值
	int degree;//当前节点作为根节点的树的度数，也即k
	heapNode *parent;//父亲节点，对于每棵树的根节点而言没有父亲节点，值为NULL
	heapNode *chlid;//该树的第一个孩子
	heapNode *sibling;//串联同一父节点下的所有子节点 
	heapNode(int x):key(x),degree(0),parent(NULL),child(NULL),sibling(NULL){}
}; 
class heap
{
	private:
		heapNode *head;
		heapNode *min;
};

c.二项堆的建立，插入，删除，合并等 
#include<iostream>
#include<queue>
#include<stack>
#include<algorithm>
using namespace std;
//析构函数和复制构造函数不再重载 
struct heapNode
{
	int key;//该节点的值，为方便操作，关键字均大于0 
	int degree;//当前节点作为根节点的树的度数，也即k
	heapNode *parent;//父亲节点，对于每棵树的根节点而言没有父亲节点，值为NULL
	heapNode *child;//该树的第一个孩子
	heapNode *sibling;//串联同一父节点下的所有子节点 
	heapNode(int x):key(x),degree(0),parent(NULL),child(NULL),sibling(NULL){}
}; 
struct heap
{
	heapNode *root;
	heapNode *min;	
	heap():root(NULL),min(NULL){}	
};
/***********************堆合并的辅助函数*************以下*********/
void mergeSort(heapNode *p,heapNode *q,heapNode *m)
{
	while(p!=NULL&&q!=NULL)
	{
		if(p->degree<=q->degree)
		{
			m->sibling=p;
			m=m->sibling;
			p=p->sibling;
		}	
		else
		{
			m->sibling=q;
			m=m->sibling;
			q=q->sibling;
		}
	}
	while(p!=NULL)
	{
		m->sibling=p;
		m=m->sibling;
		p=p->sibling;
	}
	while(q!=NULL)
	{
		m->sibling=q;
		m=m->sibling;
		q=q->sibling;
	}
}

void link(heapNode *root,heapNode *child)
{
	child->sibling=root->child;
	child->parent=root;
	root->child=child;
	root->degree++;
} 

void adjustMin(heapNode *root)
{
	while(root->child!=NULL)
	{
		if(root->key>root->child->key)
		{
			swap(root->key,root->child->key);
			root=root->child;
		}
		else
		{
			return;
		}
	}
}

void adjustD(heapNode *m,heapNode *mpre)
{
	if(m->sibling==NULL)
	{
		return;
	}
	if(m->degree>m->sibling->degree)
	{
		heapNode *temp=m->sibling;
		m->sibling=temp->sibling;
		temp->sibling=m;
		mpre->sibling=temp;
		mpre=temp;
	}
} 

void heapMin(heap *h)
{
	heapNode *root=h->root;
	int minkey=root->key;
	h->min=root;
	while(root->sibling!=NULL)
	{
		if(root->sibling->key<minkey)
		{
			minkey=root->sibling->key;
			h->min=root->sibling;
		}
		root=root->sibling;
	}
} 
/***********************堆合并的辅助函数***************以上********/
//合并两个堆 
void unionHeap(heap *a,heap *b)
{
	heapNode *p=a->root;
	heapNode *q=b->root;
	if(p==NULL)
	{
		a->root=b->root;//仅在该题中，c指向的那块内存可以是b指向的那块，没必要要重载复制构造函数 
		return; 
	}
	if(q==NULL)
	{
		return;
	}
	heapNode *t1=new heapNode(-1);//为方便计算所设的头结点 
	heapNode *m=t1;
	mergeSort(p,q,m);
	m=t1->sibling;
	heapNode *mpre=t1;
	while(m->sibling!=NULL)
	{
		if(m->degree!=m->sibling->degree)
		{
			m=m->sibling;
			mpre=mpre->sibling;
		}
		else
		{
			heapNode *temp=m->sibling;
			m->sibling=temp->sibling;
			link(m,temp);//链接两个堆的根 
			adjustMin(m);//调整，保持每棵二项树树根最小的性质 
			adjustD(m,mpre);//调整，保证度数小的二项树在前，以防止间隔的两棵二项树具有相同的度，却得不到合并的现象 
		}
	}
	a->root=t1->sibling;
	heapMin(a);
	return;
}
//遍历（遍历函数有误） 
void levelTraversal(heap *r)
{
	queue<heapNode*> q;
	q.push(r->root);
	while(!q.empty())
	{
		heapNode *root=q.front();
		q.pop();
		if(root->key>=0)
		{
			cout<<"key("<<root->key<<") degree("<<root->degree<<")"<<"\t";
		}
		if(root->child!=NULL)
		{
			q.push(root->child);	
		}
		if(root->sibling!=NULL)
		{
			q.push(root->sibling);
		}
	}	
	cout<<endl;
}
//插入一个节点，就先构造一个只有一个节点的二项堆，然后在和原二项堆合并 
void insertNode(int x,heap *h)
{
	heap *temp=new heap();
	heapNode *t=new heapNode(x);
	temp->root=t;
	temp->min=t;
	unionHeap(h,temp);
} 
/***********************删除关键字的辅助函数***************以下********/
//删除有最小关键字的节点 
void deleteMinKeyNode(heap *h)
{
	//把含最小（根）节点的那棵二项树给拎出来 
	heapNode *temp;  
	if(h->root==h->min)
	{
		temp=h->root;
		h->root=temp->sibling;
	}
	else
	{
		heapNode *pre=h->root;
		while(pre->sibling!=h->min)
		{
			pre=pre->sibling;
		}
		temp=pre->sibling;
		pre->sibling=temp->sibling;
	}
	//删除最小节点 
	heapNode *dele=temp;
	temp=temp->child;
	delete dele;
	if(temp==NULL)//无孩子，度为0，直接返回 
	{
		return;
	}
	//把最小节点原来的孩子逆序排列
	stack<heapNode*> s;
	while(temp!=NULL)
	{
		heapNode *tempbother=temp->sibling;
		temp->parent=NULL;
		temp->sibling=NULL;	
		s.push(temp);
		temp=tempbother;
	}
	//组成新堆 
	heap *t=new heap();
	t->root=s.top();
	s.pop();
	temp=t->root;
	while(!s.empty())
	{
		temp->sibling=s.top();
		temp=temp->sibling;
		s.pop();
	}
	//新堆与原堆合并
	unionHeap(h,t); 
	heapMin(h);
}
//减少关键字的值成负值-1 
void decreaseKey(heap *h,int key)
{
	heapNode *temp;
	queue<heapNode*> q;
	q.push(h->root);
	while(!q.empty())
	{
		heapNode *root=q.front();
		q.pop();
		if(root->key==key)
		{
			temp=root;
			break;
		}
		if(root->child!=NULL)
		{
			q.push(root->child);	
		}
		if(root->sibling!=NULL)
		{
			q.push(root->sibling);
		}
	}
	temp->key=-1;
	while(temp->parent!=NULL)
	{
		swap(temp->parent->key,temp->key);
		temp=temp->parent;			
	}
	heapMin(h);
} 
/***********************删除关键字的辅助函数***************以上********/
//删除关键字
void deleteKey(heap *h,int key) 
{
	//先减少关键字的值，使它达到根节点 
	decreaseKey(h,key);
	//然后删除这个最小根节点
	deleteMinKeyNode(h); 
}
int main()
{
	heap *h=new heap();
	heapNode *ht0=new heapNode(11);
	h->root=ht0;
	h->min=ht0;
	insertNode(12,h);
	insertNode(13,h);
	 
	heap *h1=new heap();
	heapNode *ht1=new heapNode(21);
	h1->root=ht1;
	h1->min=ht1;
	insertNode(22,h1);
	insertNode(23,h1);
	
	unionHeap(h,h1);
	levelTraversal(h);
	deleteKey(h,23);
	levelTraversal(h);
}

3.斐波那契堆

类似于平衡树-红黑树与高度自平衡的AVL的关系。斐波那契堆较二项堆更为松散，除抽取最小元素和删除操作，其他操作的平摊时间复杂度在O(1)

a.斐波那契堆与二项堆的异同：

同：1、都是由有序树构成。2、每棵有序树均具有最小堆性质。3.斐波那契堆中的树不一定是二项树

异：1、斐波那契堆无论是有序树之间，还是有序树孩子均是由双向循环链表串联起来，已达到插入等操作的O(1)。2、斐波那契堆中，各棵树的度可以有重叠，并且并不需要像二项堆那样按度的大小对二项树进行排列。3、斐波那契堆的插入并不像二项堆那样，插入一个节点就合并一次，为减小频繁合并的消耗，斐波那契堆把合并操作推迟到删除一个节点时再做。4、斐波那契堆的根节点就是关键字最小的节点，而不是像二项堆那样根节点是度数最小（大）的节点

b.存储模型

struct Node
{
	Node *lbother;
	Node *rbother;
	Node *parent;
	Node *child;
	int key;
	int degree;
	bool mark;//是否被删除过孩子
	Node(int x):key(x),degree(0),mark(false),lbother(NULL),rbother(NULL),parent(NULL),child(NULL){} 
};
struct Heap
{
	int n;//堆中节点个数	
	Node *min;//最小节点，同时作为根节点 
	Heap():min(NULL),n(0){}
};
环形双链表的两个好处：1、可以在O(1)的时间内删除某个节点；2、也可以在O(1)的时间内插入某个节点。

mark标记的作用是用来标记“该节点的子节点是否有被删除过”，它的作用是来实现级联剪切。而级联剪切的真正目的是为了防止'最小堆'由树演化成链表（无节制的删孩子，删的只剩一个时，就成了链表）。

c.斐波那契堆的插入、删除、合并等

斐波那契堆代码不是自己编的来自：http://dsqiu.iteye.com/blog/1714961

//说明：
//代码中Fibonacci Heap 用变量heap表示
//结点通常用x，y等表示
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<climits>
using namespace std;
 
//斐波那契结点ADT
struct FibonacciHeapNode {
    int key;       //结点
    int degree;    //度
    FibonacciHeapNode * left;  //左兄弟
    FibonacciHeapNode * right; //右兄弟
    FibonacciHeapNode * parent; //父结点
    FibonacciHeapNode * child;  //第一个孩子结点
    bool marked;           //是否被删除第1个孩子
};
 
typedef FibonacciHeapNode FibNode;
 
//斐波那契堆ADT
struct FibonacciHeap {
    int keyNum;   //堆中结点个数
    FibonacciHeapNode * min;//最小堆，根结点
    int maxNumOfDegree;   //最大度
    FibonacciHeapNode * * cons;//指向最大度的内存区域
};
 
typedef FibonacciHeap FibHeap;
 
/*****************函数申明*************************/
//将x从双链表移除
inline void FibNodeRemove(FibNode * x);
 
//将x堆结点加入y结点之前(循环链表中)
void FibNodeAdd(FibNode * x, FibNode * y);
 
//初始化一个空的Fibonacci Heap
FibHeap * FibHeapMake() ;
 
//初始化结点x
FibNode * FibHeapNodeMake();
 
//堆结点x插入fibonacci heap中
void FibHeapInsert(FibHeap * heap, FibNode * x);
 
//将数组内的值插入Fibonacci Heap
void FibHeapInsertKeys(FibHeap * heap, int keys[], int keyNum);
 
//将值插入Fibonacci Heap
static void FibHeapInsertKey(FibHeap * heap, int key);
 
//抽取最小结点
FibNode * FibHeapExtractMin(FibHeap * heap);
 
//合并左右相同度数的二项树
void FibHeapConsolidate(FibHeap * heap);
 
//将x根结点链接到y根结点
void FibHeapLink(FibHeap * heap, FibNode * x, FibNode *y);
 
//开辟FibHeapConsolidate函数哈希所用空间
static void FibHeapConsMake(FibHeap * heap);
 
//将堆的最小结点移出，并指向其有兄弟
static FibNode *FibHeapMinRemove(FibHeap * heap);
 
//减小一个关键字
void FibHeapDecrease(FibHeap * heap, FibNode * x, int key);
 
//切断x与父节点y之间的链接，使x成为一个根
static void FibHeapCut(FibHeap * heap, FibNode * x, FibNode * y);
 
//级联剪切
static void FibHeapCascadingCut(FibHeap * heap, FibNode * y);
 
//修改度数
void renewDegree(FibNode * parent, int degree);
 
//删除结点
void FibHeapDelete(FibHeap * heap, FibNode * x);
 
//堆内搜索关键字
FibNode * FibHeapSearch(FibHeap * heap, int key);
 
//被FibHeapSearch调用
static FibNode * FibNodeSearch(FibNode * x, int key);
 
//销毁堆
void FibHeapDestory(FibHeap * heap);
 
//被FibHeapDestory调用
static void FibNodeDestory(FibNode * x);
 
//输出打印堆
static void FibHeapPrint(FibHeap * heap);
 
//被FibHeapPrint调用
static void FibNodePrint(FibNode * x);
/************************************************/
 
//将x从双链表移除
inline void FibNodeRemove(FibNode * x) {
    x->left->right = x->right;
    x->right->left = x->left;
}
 
/*
将x堆结点加入y结点之前(循环链表中)
    a …… y
    a …… x …… y
*/
inline void FibNodeAdd(FibNode * x, FibNode * y) {
    x->left = y->left;
    y->left->right = x;
    x->right = y;
    y->left = x;
}
 
//初始化一个空的Fibonacci Heap
FibHeap * FibHeapMake() {
    FibHeap * heap = NULL;
    heap = (FibHeap *) malloc(sizeof(FibHeap));
    if (NULL == heap) {
        puts("Out of Space!!");
        exit(1);
    }
    memset(heap, 0, sizeof(FibHeap));
    return heap;
}
 
//初始化结点x
FibNode * FibHeapNodeMake() {
    FibNode * x = NULL;
    x = (FibNode *) malloc(sizeof(FibNode));
    if (NULL == x) {
        puts("Out of Space!!");
        exit(1);
    }
    memset(x, 0, sizeof(FibNode));
    x->left = x->right = x;
    return x;
}
 
//堆结点x插入fibonacci heap中
void FibHeapInsert(FibHeap * heap, FibNode * x) {
    if (0 == heap->keyNum) {
        heap->min = x;
    } else {
        FibNodeAdd(x, heap->min);
        x->parent = NULL;
        if (x->key < heap->min->key) {
            heap->min = x;
        }
    }
    heap->keyNum++;
}
 
//将数组内的值插入Fibonacci Heap
void FibHeapInsertKeys(FibHeap * heap, int keys[], int keyNum) {
    for (int i = 0; i < keyNum; i++) {
        FibHeapInsertKey(heap, keys[i]);
    }
}
 
//将值插入Fibonacci Heap
static void FibHeapInsertKey(FibHeap * heap, int key) {
    FibNode * x = NULL;
    x = FibHeapNodeMake();
    x->key = key;
    FibHeapInsert(heap, x);
}
 
//抽取最小结点
FibNode * FibHeapExtractMin(FibHeap * heap) {
    FibNode * x = NULL, * z = heap->min;
    if (z != NULL) {
 
        //删除z的每一个孩子
        while (NULL != z->child) {
            x = z->child;
            FibNodeRemove(x);
            if (x->right == x) {
                z->child = NULL;
            } else {
                z->child = x->right;
            }
            FibNodeAdd(x, z);//add x to the root list heap
            x->parent = NULL;
        }
 
        FibNodeRemove(z);
        if (z->right == z) {
            heap->min = NULL;
        } else {
            heap->min = z->right;
            FibHeapConsolidate(heap);//合并两个度相同的树
        }
        heap->keyNum--;
    }
    return z;
}
 
//合并左右相同度数的二项树
void FibHeapConsolidate(FibHeap * heap) {
    int D, d;
    FibNode * w = heap->min, * x = NULL, * y = NULL;
    FibHeapConsMake(heap);//开辟哈希所用空间
    D = heap->maxNumOfDegree + 1;
    for (int i = 0; i < D; i++) {
        *(heap->cons + i) = NULL;
    }
 
    //合并相同度的根节点，使每个度数的二项树唯一
    while (NULL != heap->min) {
        x = FibHeapMinRemove(heap);
        d = x->degree;
        while (NULL != *(heap->cons + d)) {
            y = *(heap->cons + d);
            if (x->key > y->key) {//根结点key最小
                swap(x, y);
            }
            FibHeapLink(heap, y, x);
            *(heap->cons + d) = NULL;
            d++;
        }
        *(heap->cons + d) = x;
    }
    heap->min = NULL;//原有根表清除
 
    //将heap->cons中结点都重新加到根表中，且找出最小根
    for (int i = 0; i < D; i++) {
        if (*(heap->cons + i) != NULL) {
            if (NULL == heap->min) {
                heap->min = *(heap->cons + i);
            } else {
                FibNodeAdd(*(heap->cons + i), heap->min);
                if ((*(heap->cons + i))->key < heap->min->key) {
                    heap->min = *(heap->cons + i);
                }//if(<)
            }//if-else(==)
        }//if(!=)
    }//for(i)
}
 
//<辅助函数>将x根结点链接到y根结点
void FibHeapLink(FibHeap * heap, FibNode * x, FibNode *y) {
    FibNodeRemove(x);
    if (NULL == y->child) {
        y->child = x;
    } else {
        FibNodeAdd(x, y->child);
    }
    x->parent = y;
    y->degree++;
    x->marked = false;
}
 
//<辅助函数，c++中可以用map代替>开辟FibHeapConsolidate函数哈希所用空间
static void FibHeapConsMake(FibHeap * heap) {
    int old = heap->maxNumOfDegree;
    heap->maxNumOfDegree = int(log(heap->keyNum * 1.0) / log(2.0)) + 1;
    if (old < heap->maxNumOfDegree) {
        //因为度为heap->maxNumOfDegree可能被合并,所以要maxNumOfDegree + 1
        heap->cons = (FibNode **) realloc(heap->cons,
            sizeof(FibHeap *) * (heap->maxNumOfDegree + 1));
        if (NULL == heap->cons) {
            puts("Out of Space!");
            exit(1);
        }
    }
}
 
//<辅助函数>将堆的最小结点移出，并指向其有兄弟
static FibNode *FibHeapMinRemove(FibHeap * heap) {
    FibNode *min = heap->min;
    if (heap->min == min->right) {
        heap->min = NULL;
    } else {
        FibNodeRemove(min);
        heap->min = min->right;
    }
    min->left = min->right = min;
    return min;
}
 
//减小一个关键字
void FibHeapDecrease(FibHeap * heap, FibNode * x, int key) {
    FibNode * y = x->parent;
    if (x->key < key) {
        puts("new key is greater than current key!");
        exit(1);
    }
    x->key = key;
 
    if (NULL != y && x->key < y->key) {
        //破坏了最小堆性质，需要进行级联剪切操作
        FibHeapCut(heap, x, y);
        FibHeapCascadingCut(heap, y);
    }
    if (x->key < heap->min->key) {
        heap->min = x;
    }
}
 
//切断x与父节点y之间的链接，使x成为一个根
static void FibHeapCut(FibHeap * heap, FibNode * x, FibNode * y) {
    FibNodeRemove(x);
    renewDegree(y, x->degree);
    if (x == x->right) {
        y->child = NULL;
    } else {
        y->child = x->right;
    }
    x->parent = NULL;
    x->left = x->right = x;
    x->marked = false;
    FibNodeAdd(x, heap->min);
}
 
//级联剪切
static void FibHeapCascadingCut(FibHeap * heap, FibNode * y) {
    FibNode * z = y->parent;
    if (NULL != z) {
        if (y->marked == false) {
            y->marked = true;
        } else {
            FibHeapCut(heap, y, z);
            FibHeapCascadingCut(heap, z);
        }
    }
}
 
//修改度数
void renewDegree(FibNode * parent, int degree) {
    parent->degree -= degree;
    if (parent-> parent != NULL) {
        renewDegree(parent->parent, degree);
    }
}
 
//删除结点
void FibHeapDelete(FibHeap * heap, FibNode * x) {
    FibHeapDecrease(heap, x, INT_MIN);
    FibHeapExtractMin(heap);
}
 
//堆内搜索关键字
FibNode * FibHeapSearch(FibHeap * heap, int key) {
    return FibNodeSearch(heap->min, key);
}
 
//被FibHeapSearch调用
static FibNode * FibNodeSearch(FibNode * x, int key) {
    FibNode * w = x, * y = NULL;
    if (x != NULL) {
        do {
            if (w->key == key) {
                y = w;
                break;
            } else if (NULL != (y = FibNodeSearch(w->child, key))) {
                break;
            }
            w = w->right;
        } while (w != x);
    }
    return y;
}
 
//销毁堆
void FibHeapDestory(FibHeap * heap) {
    FibNodeDestory(heap->min);
    free(heap);
    heap = NULL;
}
 
//被FibHeapDestory调用
static void FibNodeDestory(FibNode * x) {
    FibNode * p = x, *q = NULL;
    while (p != NULL) {
        FibNodeDestory(p->child);
        q = p;
        if (p -> left == x) {
            p = NULL;
        } else {
            p = p->left;
        }
        free(q->right);
    }
}
 
//输出打印堆
static void FibHeapPrint(FibHeap * heap) {
    printf("The keyNum = %d\n", heap->keyNum);
    FibNodePrint(heap->min);
    puts("\n");
};
 
//被FibHeapPrint调用
static void FibNodePrint(FibNode * x) {
    FibNode * p = NULL;
    if (NULL == x) {
        return ;
    }
    p = x;
    do {
        printf(" (");
        printf("%d", p->key);
        if (p->child != NULL) {
            FibNodePrint(p->child);
        }
        printf(") ");
        p = p->left;
    }while (x != p);
}
 
int keys[10] = {1, 2, 3, 4, 5, 6, 7, 9, 10, 11};
 
int main() {
    FibHeap * heap = NULL;
    FibNode * x = NULL;
    heap = FibHeapMake();
    FibHeapInsertKeys(heap, keys, 10);
    FibHeapPrint(heap);
 
    x = FibHeapExtractMin(heap);
    printf("抽取最小值%d之后：\n", x->key);
    FibHeapPrint(heap);
 
    x = FibHeapSearch(heap, 11);
    if (NULL != x) {
        printf("查找%d成功,", x->key);
        FibHeapDecrease(heap, x, 8);
        printf("减小到%d后：\n", x->key);
        FibHeapPrint(heap);
    }
 
    x = FibHeapSearch(heap, 7);
    if (NULL != x) {
        printf("删除%d成功:\n", x->key);
        FibHeapDelete(heap, x);
        FibHeapPrint(heap);
    }
 
    FibHeapDestory(heap);
    return 0;
}

4.用于不相交集合的数据结构

其实就是并查集，链表形式不再给出，非链表形式，参见树基础总结：http://blog.csdn.net/chinajane163/article/details/49468737


罗磐
关注
专栏目录
《算法导论》第二十章febonacci heap_斐波纳契堆的实现
作一个独立连续的思考者
09-01 3329
对于febonacci heap的分析： 1.extract-min，抽取最小结点花销O(D(n))。因为将min[H]抽取出时，需要实际花销O(D(n))将其子结点并入根表中；其次，合并同度根结点时，由于根表此时最多有T(n)+D(n)-1个根结点，故将同度根结点链接时T
斐波那契堆
朱广健的博客
06-08 1787
本文将要介绍的斐波那契堆是一种保有最小堆性质的“森林集合”。和二叉堆一样，他可以用来实现优先队列，而且比二叉堆在某些操作上有更优的时间复杂度。比如插入操作，二叉堆插入一个结点需要从底向上调整堆结构，因此需要O(lgn)的时间，而斐波那契堆则只需要O(1)的时间。下面将会解析斐波那契堆的各个基本操作及其c/cpp实现代码。下面是一个斐波那契堆的结构示意图。除了插入操作，斐波那契堆总是保持着一个性质：
堆（heap）基础总结
weixin_46009158的博客
04-08 238
二叉树的顺序存储 1.使用数组来保存二叉树结构，就是将二叉树层序遍历放到数组中。 这种方法一般指适用于完全二叉树，因为非完全二叉树会存在空间上的浪费。主要用法，就是堆的表示。 2.在数组中的下标的关系 已知根节点下标（parent），则： 左子树下标=2*parent+1 右子树下标=2+parent+2 已知左右子树（child）下标，则： 根节点下标=（child-1）/2 堆的概念 1....
斐波那契堆(一)之 图文解析 和 C语言的实现
xiedeacc的专栏
06-01 1560
斐波那契堆(一)之 图文解析 和 C语言的实现   概要 本章介绍斐波那契堆。和以往一样，本文会先对斐波那契堆的理论知识进行简单介绍，然后给出C语言的实现。后续再分别给出C++和Java版本的实现；实现的语言虽不同，但是原理如出一辙，选择其中之一进行了解即可。若文章有错误或不足的地方，请不吝指出！ 目录 1. 斐波那契堆的介绍 2. 斐波那契堆的基本操作 3. 斐波那契堆
算法设计与分析——斐波那契堆
jmhIcoding
11-10 7602
引言 这章，我们来看看大名鼎鼎的斐波那契堆。这个堆就很有意思了，居然能和大名鼎鼎的斐波那契数列挂上边。
算法导论第四版 英文
09-12
《算法导论第四版》系统地介绍了多种排序算法，如冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序等。书中不仅解释了每种算法的工作原理和性能特性，还对比了它们在不同情况下的应用效果。此外，作者还...
算法导论讲义--答案.rar
05-27
《算法导论》是计算机科学领域的一本经典教材，它深入浅出地介绍了算法的设计、分析和实现。这本书涵盖了各种核心算法，包括排序、搜索、图算法、动态规划等，并探讨了它们在实际问题中的应用。MIT（麻省理工学院）...
算法导论中文版第二版（书+课后习题答案）
12-20
总结，《算法导论》中文版第二版是一本全面且深入的教材，无论是初学者还是经验丰富的程序员，都能从中受益匪浅。结合书中的习题答案，读者可以系统地学习和掌握算法这门核心的计算机科学知识。
科大算法导论上课ppt完整版
12-21
《科大算法导论上课ppt完整版》是针对中国科学技术大学算法导论课程的一套全面且详尽的讲义资源，由经验丰富的教师精心编制。这份资料覆盖了算法设计、分析与实现的关键知识点，旨在帮助学生深入理解算法的核心概念...
3.3 斐波那契堆
你的指尖有改变世界的力量
01-14 541
结构 斐波那契堆的基础是可合并堆。 数据结构是一个森林。也就是N棵树。这点和二项堆一样。 这个结构没有二项堆那么多的要求。 Rank的概念,是子节点的数目 与二项堆不同的是，斐波那契堆的底层链表要成环，要双向链表。 而斐波那契堆的节点，是这样的。每个节点有parent，只有一个child。但是每个child都是个双向链表节点。 所以斐波那契节点实际上是多了两个属性的双向链表节点。所以继承自LinkedListNode。 斐波那契堆节点主要有以下属性： # _*_ coding:utf-8 _*_ fro
（五）高级数据结构
lzm420241的专栏
05-05 956
第十八章  B树          第十九章  二项堆
数据结构 - 堆的应用场景
it_lihongmin的博客
03-08 3565
目录 1、优先级队列的使用场景 1)、定时任务轮训问题 2)、合并有序小文件 2、求Top K值问题【使用一个堆解决】 3、求中位数、百分位数【使用一个大顶堆一个小顶堆解决】 4、大数据量日志统计搜索排行榜【散列表+堆】 堆作为数据结构其特殊的结构完全二叉树，作为数据特点堆顶元素大于等于（或者小于等于）索引叶子节点。前面篇博客分析了，堆排序也算是堆的一个应用场景，并且分析了堆排序的第一步建堆，允许在时间复杂度O(N)内就获取到了最大或者最小的元素。Java中的Prior...
数据结构：堆
runfeel
10-16 215
已移到：http://www.wypblog.com/archives/97 堆常用来实现优先队列，在这种队列中，待删除的元素为优先级最高（最低）的那个。在任何时候，任意优先元素都是可以插入到队列中去的，是计算机科学中一类特殊的数据结构的统称 一、堆的定义 最大（最小）堆是一棵每一个节点的键值都不小于（大于）其孩子（如果存在）的键值的树。大顶堆是一棵完全二叉树，同时也是一棵最大树。小顶堆是一棵完全...
题解报告：hdu 2516 取石子游戏（斐波那契博弈）
weixin_30826761的博客
05-27 311
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2516 Problem Description 1堆石子有n个,两人轮流取.先取者第1次可以取任意多个，但不能全部取完.以后每次取的石子数不能超过上次取子数的2倍。取完者胜.先取者负输出"Second win".先取者胜输出"First win". Input 输入有多组.每组第1行是...
LeetCode 114. 二叉树展开为【单】链表（Medium）/ 897. 二叉搜索树重排为【递增顺序搜索树】（Easy）/ 783. 二叉搜索树节点最小距离（Easy）
newCraftsman的博客
12-18 183
【题目链接】 题解 二叉树展开为链表 思路 代码 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution: ### 1218 寻找.
二之再续、Dijkstra 算法+fibonacci堆的逐步c实现
热门推荐
结构之法 算法之道
03-18 3万+
二之再续、Dijkstra 算法+fibonacci堆的逐步c实现作者:JULY、二零一一年三月是八日出处：----------------------------------引言：    来考虑一个问题，平面上6个点，A,B,C,D,E,F，假定已知其中一些点之间的距离，现在，要求A到其它5个点，B,C,D,E,F各点的最短距离。如下图所示：经过上图，我们可以轻而易举的得到A->B,C,D,E,F各点的最短距离：目的            路径              最短距离A=>A，      A-
动态规划算法
GUI1259802368的博客
02-25 766
动态规划        通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题。      基本思想        若要解一个给定问题，我们需要解其不同部分（即子问题），再合并子问题的解以得出原问题的解。 通常许多子问题非常相似，为此动态规划法试图仅仅解决每个子问题一次，从而减少计算量： 一旦某个给定子问题的解已经算出，则将其记忆化存...
9. 斐波那契数列的应用
stay hungry ! stay foolish!
12-10 320
9.1 输出斐波那契数列的第 n 项 题目描述：现在要求输入一个整数 n，请你输出斐波那契数列的第 n 项。n<=39思路：递归的效率低，使用循环方式。 代码实现： public long fibonacci(int n) { long result=0; long preOne=1; long preTwo=0; if(n==0) { return 0; } if(n==1) { return 1; } for (int i = 2; i <= n; i++) .
算法导论第三版：计算机编程与算法基础详解
《算法导论》第三版是一本由Thomas H. Cormen、Charles E. Leiserson、Ronald L. Rivest和Clifford Stein合著的经典之作，专为计算机科学领域的入门者设计，是理解和掌握算法理论和技术的基石。本书详细介绍了各种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值