数据结构-堆 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) 优先队列与普通队列的区别:普通队列遵循先进先出的原则:优先队列的出队顺序与入队顺序无关,与优先级相关. 优先队列可以使用队列的接口,只是在 ...
随机推荐
- 关于APICloud读取不到虚拟机及数据库的问题
工具:apicloud编辑器 虚拟机:夜神虚拟机(nox_setup_v6.0.1.0_full)版本 数据库:Oracle 11G 以为夜神虚拟机版本太高,进程adb.exe读取不出虚拟机和数据库, ...
- 基于低代码平台（Low Code Platform）开发中小企业信息化项目
前言:中小企业信息化需求强烈,对于开发中小企业信息化项目的软件工作和程序员来说,如何根据中小企业的特点,快速理解其信息化项目的需求并及时交付项目,是一个值得关注和研讨的话题. 最近几年来,随着全球经济 ...
- System.out.println()的解释
上周面试的时候,面试官让我解释一下输出语句每一个单词是什么意思.当是有点蒙,后来想想这不就是考察对java中常用的的包,类和其中的方法的熟悉程度吗? 我们首先来看看System:这是一个类名,存在于j ...
- CentOS下nginx php mysql 环境搭建
CentOS下搭建PHP运行环境. 首先是在虚拟机上装好一个命令行的CentOS,如果只是弄服务器的话,不要装图形界面,会比较卡. 一.安装编译工具及库文件 yum -y install make z ...
- 自学Zabbix3.10.1.5-事件通知Notifications upon events-媒介类型自定义脚本
自学Zabbix3.10.1.5-事件通知Notifications upon events-媒介类型自定义脚本
- Java Web 单表操作
为了测试 JavaWeb 项目,我做了一个关于一张表的更新操作. 1.加群 如果需要本项目的源码,欢迎加群:438255459 2.解压 解压开这个包,然后用 Eclipse 打开项目,至于涉及到 T ...
- mac与centos下redis的安装与配置
前言 最近在用redis,下面简单写一下mac和centos下redis的安装与配置方法. 安装 mac下面 安装命令:brew intall redis 运行命令:brew services sta ...
- 《精通c#（第6版）》【PDF】下载
图灵程序设计丛书:精通C#(第6版)是C#领域久负盛名的经典著作,深入全面地讲解了C#编程语言和.NET平台的核心内容,并结合大量示例剖析相关概念.全书分为八部分:C#和.NET平台.C#核心编程结构 ...
- 【java】获取当前环境属性及编码乱码示例
package 字符编码; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; impo ...
- JaveScript用二分法与普通遍历(冒泡)
二分法 查找 概念: 从有序的数列中,折半查找. 思路: --> 找到数组中最中间的元素,将其作为基准 --> 从0开始判断数组中的元素,与基准进行比较 --> 比基准小的元素,存入 ...