数据结构-堆 C与C++的实现
堆，是一种完全二叉树。而且在这颗树中，父节点必然大于（对于小顶堆为小于）子节点。
关于树的概念不了解可以看这里：http://www.cnblogs.com/HongYi-Liang/p/7231440.html
由于堆是一种完全二叉树，很适合保存为数组的形式。如下图示意的堆，红色数字为数组索引，黑色数字为数组的值，那么这个堆保存为数组的形式:heap={9,8,5,6,7,1,4,0,3,2};
值得注意的是，在堆中，若设父亲的索引为i，左儿子的索引刚好等于2i，而右儿子的索引等于2i+1。这个公式会大量地出现在下边的程序中。
关键概念：
大顶堆：树根元素为最大值往叶子递减，（父节点总是大于子节点）
小顶堆：树根元素为最小值往叶子递增，（父节点总是小于子节点）
下为一个大顶堆的示意图，父节点总是大于子节点
在下面的程序中，C将以大顶堆的形式编写，C++以小顶堆的形式编写。
C语言
程序源码：
本例子为大顶堆，包含4个文件（如下图）
MaxHeap.c
#include "MaxHeap.h" bool MaxHeapConstructByBuffer(MaxHeap *heap,MAXHEAP_ELEM buff[],int length);
bool MaxHeapDesturct(MaxHeap *heap);
bool MaxHeap_getSize(MaxHeap *heap);
bool MaxHeap_isFull(MaxHeap *heap);
bool MaxHeap_isEmpty(MaxHeap *heap);
void MaxHeap_swap(MAXHEAP_ELEM *a,MAXHEAP_ELEM *b);
void MaxHeap_floating(MaxHeap *heap,int index);
void MaxHeap_sink(MaxHeap *heap, int index);
bool MaxHeap_push(MaxHeap *heap,MAXHEAP_ELEM data);
bool MaxHeap_push(MaxHeap *heap,MAXHEAP_ELEM data);
bool MaxHeap_pop(MaxHeap *heap,int index);
void MaxHeap_printfAll(MaxHeap *heap); bool MaxHeapConstructByBuffer(MaxHeap *heap,MAXHEAP_ELEM buff[],int length)
{
int i;
if(NULL != heap->iDatas)
{
return false;
}
heap->iHeapCapacity=length;
heap->iHeapSize=;
heap->iDatas = (MAXHEAP_ELEM*)malloc(sizeof(MAXHEAP_ELEM)*length);
for(i=;i<length;i++)
{
MaxHeap_push(heap,buff[i]);
}
return true;
} bool MaxHeapDesturct(MaxHeap *heap)
{
if(NULL == heap->iDatas)
{
return false;
}
free(heap->iDatas);
return true;
} bool MaxHeap_getSize(MaxHeap *heap)
{
return heap->iHeapSize;
} bool MaxHeap_isFull(MaxHeap *heap)
{
if(heap->iHeapCapacity == heap->iHeapSize)
{
return true;
}
return false;
} bool MaxHeap_isEmpty(MaxHeap *heap)
{
if( == heap->iHeapSize)
{
return true;
}
return false;
} void MaxHeap_swap(MAXHEAP_ELEM *a,MAXHEAP_ELEM *b)
{
MAXHEAP_ELEM temp;
temp=*a;
*a=*b;
*b=temp;
} void MaxHeap_floating(MaxHeap *heap,int index)
{
int i;
for(i=index;i>;i=(int)(i*0.5))
{
if(heap->iDatas[i-] > heap->iDatas[(int)(i*0.5-)] )
{
MaxHeap_swap(&heap->iDatas[i-],&heap->iDatas[(int)(i*0.5-)]);
}
else
{
break;
}
}
} void MaxHeap_sink(MaxHeap *heap, int index)
{
int i=index; while(i*<=heap->iHeapSize)
{
if(heap->iDatas[i-] < heap->iDatas[i*-])//it compare to left child
{
MaxHeap_swap(&heap->iDatas[i-],&heap->iDatas[i*-]);
if(i*+<=heap->iHeapSize && heap->iDatas[i-] < heap->iDatas[i*])//it compare to right child
{
MaxHeap_swap(&heap->iDatas[i-],&heap->iDatas[i*]);
}
/*index*/
i=i*;
}
else if(i*+<=heap->iHeapSize && heap->iDatas[i-] < heap->iDatas[i*])//it compare to right child
{
MaxHeap_swap(&heap->iDatas[i-],&heap->iDatas[i*]);
i=i*+;
}
else
{
break;
}
}
} bool MaxHeap_push(MaxHeap *heap,MAXHEAP_ELEM data)
{
if( MaxHeap_isFull(heap))
return false;
heap->iDatas[heap->iHeapSize]=data;
heap->iHeapSize++;
MaxHeap_floating(heap,heap->iHeapSize); return true;
} bool MaxHeap_pop(MaxHeap *heap,int index)
{
if(MaxHeap_isEmpty(heap))
return false;
heap->iDatas[index]=heap->iDatas[heap->iHeapSize-];
heap->iHeapSize--;
MaxHeap_sink(heap,index+); return true;
} void MaxHeap_printfAll(MaxHeap *heap)
{
int i;
printf("heap:");
for( i=;i<heap->iHeapSize;i++)
{
printf("%d ",heap->iDatas[i]);
}
printf("\r\n");
}
MaxHeap.h
#ifndef __MAXHEAP_H
#define __MAXHEAP_H #include <stdlib.h>
#include <stdio.h>
#include "Mystdbool.h" typedef int MAXHEAP_ELEM;
typedef struct
{
int iHeapCapacity;
int iHeapSize;
MAXHEAP_ELEM *iDatas;
}MaxHeap; bool MaxHeapConstructByBuffer(MaxHeap *heap,MAXHEAP_ELEM buff[],int length);
bool MaxHeapDesturct(MaxHeap *heap);
bool MaxHeap_getSize(MaxHeap *heap);
bool MaxHeap_isFull(MaxHeap *heap);
bool MaxHeap_isEmpty(MaxHeap *heap);
void MaxHeap_swap(MAXHEAP_ELEM *a,MAXHEAP_ELEM *b);
void MaxHeap_floating(MaxHeap *heap,int index);
void MaxHeap_sink(MaxHeap *heap, int index);
bool MaxHeap_push(MaxHeap *heap,MAXHEAP_ELEM data);
bool MaxHeap_push(MaxHeap *heap,MAXHEAP_ELEM data);
bool MaxHeap_pop(MaxHeap *heap,int index);
void MaxHeap_printfAll(MaxHeap *heap); #endif
Mystdbool.h(仅用于声明布尔类)
#ifndef _MYSTDBOOL_H
#define _MYSTDBOOL_H typedef enum Bool
{
false=,
true,
}bool; #endif
main.c
#include "MaxHeap.h" int main()
{
/*int buffer[10]={9,8,7,6,5,4,3,2,1,0};*/
int buffer[]={,,,,,,,,,};
MaxHeap heap={};
MaxHeapConstructByBuffer(&heap,buffer,);
MaxHeap_printfAll(&heap);
MaxHeap_pop(&heap,);
MaxHeap_printfAll(&heap);
MaxHeap_pop(&heap,);
MaxHeap_printfAll(&heap);
system("pause");
return ;
}
运行结果：
源码详解：
上浮：floating(int index)
- 将堆第index个元素与它的父亲比较，若小于它的父亲，则与它父亲交换数值。
- 上述过程如果发生，则把它继续上浮。
void MaxHeap_floating(MaxHeap *heap,int index)
{
int i;
for(i=index;i>;i=(int)(i*0.5))
{
if(heap->iDatas[i-] > heap->iDatas[(int)(i*0.5-)] )
{
MaxHeap_swap(&heap->iDatas[i-],&heap->iDatas[(int)(i*0.5-)]);
}
else
{
break;
}
}
}
添加元素：push(T data)
- 把元素添加到堆的最后。
- 并使用上浮方法把堆的最后一个元素上浮。
bool MaxHeap_push(MaxHeap *heap,MAXHEAP_ELEM data)
{
if( MaxHeap_isFull(heap))
return false;
heap->iDatas[heap->iHeapSize]=data;
heap->iHeapSize++;
MaxHeap_floating(heap,heap->iHeapSize); return true;
}
构建堆：MaxHeapConstructByBuffer()
- 用malloc为数据申请空间。
- 一个一个地将buff中的数据push()到堆中。
bool MaxHeapConstructByBuffer(MaxHeap *heap,MAXHEAP_ELEM buff[],int length)
{
int i;
if(NULL != heap->iDatas)
{
return false;
}
heap->iHeapCapacity=length;
heap->iHeapSize=0;
heap->iDatas = (MAXHEAP_ELEM*)malloc(sizeof(MAXHEAP_ELEM)*length);
for(i=0;i<length;i++)
{
MaxHeap_push(heap,buff[i]);
}
return true;
}
下沉：
- 从根开始，用父节点与左子节点比较。若父节点大于左子，则交换它们的值
- 用父节点与右子节点比较。若父节点大于右子，则交换它们的值。
- 若上述情况发生了，则继续下沉，直到无法下沉为止。
void MaxHeap_sink(MaxHeap *heap, int index)
{
int i=index; while(i*<=heap->iHeapSize)
{
if(heap->iDatas[i-] < heap->iDatas[i*-])//it compare to left child
{
MaxHeap_swap(&heap->iDatas[i-],&heap->iDatas[i*-]);
if(i*+<=heap->iHeapSize && heap->iDatas[i-] < heap->iDatas[i*])//it compare to right child
{
MaxHeap_swap(&heap->iDatas[i-],&heap->iDatas[i*]);
}
/*index*/
i=i*;
}
else if(i*+<=heap->iHeapSize && heap->iDatas[i-] < heap->iDatas[i*])//it compare to right child
{
MaxHeap_swap(&heap->iDatas[i-],&heap->iDatas[i*]);
i=i*+;
}
else
{
break;
}
}
}
删除元素：pop(int index)
- 把堆的第index个元素删除，并把堆的最后一个元素放到index处。
- 把堆的第index个元素下沉
bool MaxHeap_pop(MaxHeap *heap,int index)
{
if(MaxHeap_isEmpty(heap))
return false;
heap->iDatas[index]=heap->iDatas[heap->iHeapSize-];
heap->iHeapSize--;
MaxHeap_sink(heap,index+); return true;
}
C++
程序源码：
本例子为小顶堆，包含2个文件（如下图）
MyMinHeap.h:
此文件中为小顶堆的类模板。
#ifndef __MYMINHEAP_H
#define __MYMINHEAP_H
#include <iostream>
#include <vector> using namespace std; template <typename T>
class MyMinHeap
{
public:
MyMinHeap(T buff[],int length);
MyMinHeap(int capacity);
virtual ~MyMinHeap();
int getSize();
bool isFull();
bool isEmpty();
void swap(vector<T> &vec,int i,int j);
void floating(int index);
void sink(int index);
bool push(T data);
bool pop(int index);
//transval
void printfAll();
private:
int m_iHeapCapacity;
int m_iHeapSize;
vector<T> m_vecData;
}; template <typename T>
MyMinHeap<T>::MyMinHeap(T buff[],int length)
{
m_iHeapCapacity=length;
m_iHeapSize=;
m_vecData.resize(length);
for(int i=;i<length;i++)
{
push(buff[i]);
}
} template <typename T>
MyMinHeap<T>:: MyMinHeap(int capacity)
{
m_iHeapCapacity=capacity;
m_iHeapSize=;
m_vecData.resize(capacity);
} template <typename T>
MyMinHeap<T>::~MyMinHeap()
{ } template <typename T>
int MyMinHeap<T>::getSize()
{
return m_iHeapSize;
} template <typename T>
bool MyMinHeap<T>::isFull()
{
if(m_iHeapSize>=m_iHeapCapacity)
{
return true;
}
return false;
}
template <typename T>
bool MyMinHeap<T>::isEmpty()
{
if(m_iHeapSize==)
return true;
return false;
} template <typename T>
void MyMinHeap<T>::swap(vector<T> &vec,int i,int j)
{
T temp = vec[i];
vec[i]=vec[j];
vec[j]=temp;
} template <typename T>
void MyMinHeap<T>::floating(int index)
{
T temp;
for(int i=index;i>;i*=0.5)
{
if(m_vecData[i-]<m_vecData[i*0.5-] )
{
swap(m_vecData,i-,i*0.5-);
}
else
{
break;
}
}
} template <typename T>
void MyMinHeap<T>::sink(int index)
{
int i=index; while(i*<=m_iHeapSize)
{
if(m_vecData[i-]>m_vecData[i*-])//it compare to left child
{
swap(m_vecData,i-,i*-);
if(i*+<=m_iHeapSize && m_vecData[i-]>m_vecData[i*])//it compare to right child
{
swap(m_vecData,i-,i*);
}
/*index*/
i=i*;
}
else if(i*+<=m_iHeapSize && m_vecData[i-]>m_vecData[i*])//it compare to right child
{
swap(m_vecData,i-,i*);
i=i*+;
}
else
{
break;
}
}
} template <typename T>
bool MyMinHeap<T>::push(T data)
{
if(isFull())
return false;
m_vecData[m_iHeapSize]=data;
m_iHeapSize++;
floating(m_iHeapSize); return true;
} template <typename T>
bool MyMinHeap<T>::pop(int index)
{
if(isEmpty())
return false;
m_vecData[index]=m_vecData[m_iHeapSize-];
m_iHeapSize--;
sink(index+); return true;
} template <typename T>
void MyMinHeap<T>::printfAll()
{
cout<<"heap:";
for(int i=;i<m_iHeapSize;i++)
{
cout<<m_vecData[i]<<" ";
}
cout<<endl<<endl;
} #endif
main.h:
主程序用于测试运行。
#include <iostream>
#include "MyMinHeap.h"
using namespace std; int main()
{
int buffer[]={,,,,,,,,,};
MyMinHeap<int> heap(buffer,);
heap.printfAll();
heap.pop();
heap.printfAll();
heap.push();
heap.printfAll();
system("pause");
return ;
}
运行结果：
源码详解：
上浮：floating(int index)
- 将堆第index个元素与它的父亲比较，若小于它的父亲，则与它父亲交换数值。
- 上述过程如果发生，则把它继续上浮。
template <typename T>
void MyMinHeap<T>::floating(int index)
{
T temp;
for(int i=index;i>;i*=0.5)
{
if(m_vecData[i-]<m_vecData[i*0.5-] )
{
swap(m_vecData,i-,i*0.5-);
}
else
{
break;
}
}
}
添加元素：push(T data)
- 把元素添加到堆的最后。
- 并使用上浮方法把堆的最后一个元素上浮。
template <typename T>
bool MyMinHeap<T>::push(T data)
{
if(isFull())
return false;
m_vecData[m_iHeapSize]=data;
m_iHeapSize++;
floating(m_iHeapSize); return true;
}
构造函数：使用数组构建堆：
连续使用push（）把buff中所有元素一个一个地加入堆中。
template <typename T>
MyMinHeap<T>::MyMinHeap(T buff[],int length)
{
m_iHeapCapacity=length;
m_iHeapSize=;
m_vecData.resize(length);
for(int i=;i<length;i++)
{
push(buff[i]);
}
}
下沉：
- 从根开始，用父节点与左子节点比较。若父节点大于左子，则交换它们的值
- 用父节点与右子节点比较。若父节点大于右子，则交换它们的值。
- 若上述情况发生了，则继续下沉，直到无法下沉为止。
template <typename T>
void MyMinHeap<T>::sink(int index)
{
int i=index; while(i*<=m_iHeapSize)
{
if(m_vecData[i-]>m_vecData[i*-])//it compare to left child
{
swap(m_vecData,i-,i*-);
if(i*+<=m_iHeapSize && m_vecData[i-]>m_vecData[i*])//it compare to right child
{
swap(m_vecData,i-,i*);
}
/*index*/
i=i*;
}
else if(i*+<=m_iHeapSize && m_vecData[i-]>m_vecData[i*])//it compare to right child
{
swap(m_vecData,i-,i*);
i=i*+;
}
else
{
break;
}
}
}
删除元素：pop(int index)
- 把堆的第index个元素删除，并把堆的最后一个元素放到index处。
- 把堆的第index个元素下沉
template <typename T>
bool MyMinHeap<T>::pop(int index)
{
if(isEmpty())
return false;
m_vecData[index]=m_vecData[m_iHeapSize-];
m_iHeapSize--;
sink(index+); return true;
}
数据结构-堆 C与C++的实现的更多相关文章
- 基本数据结构——堆(Heap)的基本概念及其操作
基本数据结构――堆的基本概念及其操作 小广告:福建安溪一中在线评测系统 Online Judge 在我刚听到堆这个名词的时候,我认为它是一堆东西的集合．．． 但其实吧它是利用完全二叉树的结构来维护一组 ...
- 数据结构-堆 Java实现
数据结构-堆 Java实现. 实现堆自动增长 /** * 数据结构-堆. 自动增长 * */ public class Heap<T extends Comparable> { priva ...
- C 数据结构堆
引言 - 数据结构堆 堆结构都很耳熟, 从堆排序到优先级队列, 我们总会看见它的身影. 相关的资料太多了, 堆 - https://zh.wikipedia.org/wiki/%E5%A0%86%E7 ...
- java数据结构----堆
1.堆:堆是一种树,由它实现的优先级队列的插入和删除的时间复杂度都是O(logn),用堆实现的优先级队列虽然和数组实现相比较删除慢了些,但插入的时间快的多了.当速度很重要且有很多插入操作时,可以选择堆 ...
- 数据结构 - 堆(Heap）
数据结构 - 堆(Heap) 1.堆的定义 堆的形式满足完全二叉树的定义: 若 i < ceil(n/2) ,则节点i为分支节点,否则为叶子节点 叶子节点只可能在最大的两层出现,而最大层次上的叶 ...
- [数据结构]——堆（Heap）、堆排序和TopK
堆(heap),是一种特殊的数据结构.之所以特殊,因为堆的形象化是一个棵完全二叉树,并且满足任意节点始终不大于(或者不小于)左右子节点(有别于二叉搜索树Binary Search Tree).其中,前 ...
- 数据结构&堆&heap&priority_queue&实现
目录 什么是堆? 大根堆 小根堆 堆的操作 STL queue 什么是堆? 堆是一种数据结构,可以用来实现优先队列 大根堆 大根堆,顾名思义就是根节点最大.我们先用小根堆的建堆过程学习堆的思想. 小根 ...
- 基本数据结构 —— 堆以及堆排序（C++实现）
目录 什么是堆 堆的存储 堆的操作 结构体定义 判断是否为空 往堆中插入元素 从堆中删除元素 取出堆中最大的元素 堆排序 测试代码 例题 参考资料 什么是堆 堆(英语:heap)是计算机科学中一类特殊 ...
- 数据结构——堆（Heap）大根堆、小根堆
目录 Heap是一种数据结构具有以下的特点: 1)完全二叉树: 2)heap中存储的值是偏序: Min-heap: 父节点的值小于或等于子节点的值: Max-heap: 父节点的值大于或等于子节点的值 ...
- 第二十八篇 玩转数据结构——堆（Heap）和有优先队列(Priority Queue)
1.. 优先队列(Priority Queue) 优先队列与普通队列的区别:普通队列遵循先进先出的原则:优先队列的出队顺序与入队顺序无关,与优先级相关. 优先队列可以使用队列的接口,只是在 ...
随机推荐
- 网友"就像一支烟"山寨币分析估值方法
[注:素材取自QQ群,2017年12月28日的聊天记录."就像一支烟"分享了自己的山寨币分析估值方法.因为删去了其他人的聊天记录,部分文字可能断章取义,仅供参考,具体情况请自行分析 ...
- iOS 页面之间的专长动画控制器间的转换
p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; line-height: 24.0px; font: 14.0px "Heiti SC Light" ...
- 关于js代码执行顺序
上网查了一下关于这个方面的资料,大部分都是关于两个script标签中的js代码和变量以及函数提升方面的知识. 1.两个script标签 <script> alert("我是代码块 ...
- JavaScript及jQuery中的各种宽高属性图解
文/poetries(简书作者)原文链接:http://www.jianshu.com/p/60332df38393 著作权归作者所有,转载请联系作者获得授权, 并标注“简书作者”. 作者声明:本 ...
- Lambda表达式补充
l“Lambda 表达式”是一个匿名函数,它可以包含表达式和语句,并且可用于创建委托或表达式树类型. lLambda 表达式的运算符 =>,该运算符读为“goes to”. l=> 运算符 ...
- Java 反编译工具下载
反编译,通俗来讲,就是将.java 文件经过编译生成的 .class 文件还原.注意这里的还原不等于 .java 文件.因为Java编译器在编译.java 文件的时候,会对代码进行一些处理. 那么接下 ...
- 洛谷 P1485 火枪打怪
题目描述 LXL进入到了一片丛林,结果他发现有n只怪物排成一排站在他面前.LXL有一杆火枪能对付这些怪物.他知道从左至右数第i只怪物的血量是mi.现在LXL可以将一些子弹射向某个怪物.LXL可以控制他 ...
- ADO.NET访问数据库
1:ADO.NET数据库的方法和技术 2:ADO.NET的主要组成: 1>DataSet(数据集)-----独立于数据间的数据访问 2>.NETFramework(数据提供程序)----- ...
- VS2010 Extension实践（2）
在上一篇(VS2010 Extension (1)实践)里,主要展示了如何使用MEF扩展VS2010,来扩展编辑控制和展现自己的UI:在实现QuickToolbar的时候,发现MEF仅仅提供了很基本的 ...
- 【转】完美解读Linux中文件系统的目录结构
一.前 言 接触Linux也有一段时间了,不过这几天在编译开源程序时,才发现自己对linux文件系统的目录结构了解的不够透彻,很多重要目录都说不清楚是用来干嘛的,于是在网上百度了一下这方面的介绍,根据 ...