数据结构-堆 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) 优先队列与普通队列的区别:普通队列遵循先进先出的原则:优先队列的出队顺序与入队顺序无关,与优先级相关. 优先队列可以使用队列的接口,只是在 ...
随机推荐
- JAVA入门[19]-Hibernate简单示例
一.Hibernate简介 在很多场景下,我们不需要使用JdbcTemplate直接操作SQL语句,这时候可以用ORM工具来节省数大量的的代码和开发时间.ORM工具能够把注意力从容易出错的SQL代码转 ...
- spring -boot s-tarter 详解
Starter POMs是可以包含到应用中的一个方便的依赖关系描述符集合.你可以获取所有Spring及相关技术的一站式服务,而不需要翻阅示例代码,拷贝粘贴大量的依赖描述符.例如,如果你想使用Sprin ...
- redis主从配置+哨兵模式
1.搭建redis主从,一个master两个slave,加一个哨兵监听(sentinel),可以新建三个虚拟机,模拟环境,我的电脑没那么多虚拟机,就在一台虚拟机上弄的. 2.安装redis,如果是三台 ...
- 【NOIP模拟】cut
Description F大爷热爱切树.今天他找到一棵黑白树,不到两秒钟,F大爷就把这棵树切掉了.已知原先树上共n个点,每个点都是黑点或者白点,F大爷切去若干条边后,分成的若干个连通子树中每块恰有一个 ...
- HTML篇（上）
1.Doctype作用?标准模式与兼容模式有什么区别? (1)<!doctype>声明位于HTML文档中的第一行,处于<html>标签之前.告知浏览器的解析器用什么文档标准解析 ...
- Hibernate问题浅析
1.什么是SessionFactory?什么是Session?httpsession和hibernate的session的有什么区别? SessionFactory接口负责初始化Hiber ...
- nova创建虚拟机源码分析系列之四 nova代码模拟
在前面的三篇博文中,介绍了restful和SWGI的实现.结合restful和WSGI配置就能够简单的实现nova服务模型的最简单的操作. 如下的内容是借鉴网上博文,因为写的很巧妙,将nova管理虚拟 ...
- [C#]获得WindowsForm上所有特定类型的控件
本文为原创文章.源代码为原创代码,如转载/复制,请在网页/代码处明显位置标明原文名称.作者及网址,谢谢! 开发工具:VS2017 语言:C# DotNet版本:.Net FrameWork 4.0及以 ...
- su 和 sudo 命令的区别-转载
link 一. 使用 su 命令临时切换用户身份 1.su 的适用条件和威力 su命令就是切换用户的工具,怎么理解呢?比如我们以普通用户beinan登录的,但要 ...
- Jmeter3.2版本中Generating Report Dashboard功能浅析
自从投入到Jmeter怀抱,一直想找到一个比较不错的测试结果报告模板用于展示,类似于Loadrunner中导出html那种,但是苦苦的寻找始终没有一款让我看上眼的,包括Jmeter自带的xsl,虽然展 ...