SeqHeap.h
#pragma once
#include<iostream>
#define MAXSIZE 1000000
using namespace std;
template <class DataType>
class SeqHeap
{
public:
SeqHeap(); //无参构造函数构建无序堆
SeqHeap(DataType arr[], int n); //有参构造函数构建无序堆
~SeqHeap(); //析构函数
void MakeMaxSeqHeap(SeqHeap *h); //构建最大顶堆
void MakeMinSeqHeap(SeqHeap *h); //构建最小顶堆
void PrintSeqHeap(SeqHeap h); //打印堆
void MaxHeapSort(SeqHeap *h); //堆排序:从小到大(小根堆)
void MinHeapSort(SeqHeap *h); //堆排序:从大到小(大根堆)
void Sink(DataType arr[], int k, int N); //由上到下的堆有序化(下沉):根结点元素值比其子结点小的就下沉(得到的堆是大根堆)
void Swin(DataType arr[], int k, int N); //由下到上的堆有序化(上浮):子结点元素值比其根结点大的就上浮(得到的堆是大根堆)
void SinkConversely(DataType arr[], int k, int N); //由上到下的堆有序化(下沉):根结点元素值比其子结点大的就下沉(得到的堆是小根堆)
void SwinConversely(DataType arr[], int k, int N); //由下到上的堆有序化(上浮):根结点元素值比其子结点大的就下沉(得到的堆是小根堆)
void Swap(DataType arr[], int i, int j); //交换下标为 i、j 两个元素
void OutputInFile(SeqHeap h, string filename); //把排序结果输出到文件中。
void Clear(SeqHeap *h);
bool Less(DataType v, DataType w); //若 v < w,返回true; 否则返回 false
private:
DataType *heap = new DataType[MAXSIZE + 1]; //存储堆元素:heap[0]不存储数据
int size; //堆的元素个数
};
/*
基本概念:
1、完全二叉树:若二叉树的深度为h,则除第h层外,其他层的结点全部达到最大值,且第h层的所有结点都集中在左子树。
2、满二叉树:满二叉树是一种特殊的的完全二叉树,所有层的结点都是最大值。
堆定义:
1、堆是一颗完全二叉树;
2、堆中的某个结点的值总是大于等于(最大堆)或小于等于(最小堆)其孩子结点的值。
3、堆中每个结点的子树都是堆树。
*/
SeqHeap.cpp
#include"SeqHeap.h"
template<class DataType>
SeqHeap<DataType>::SeqHeap()
{
size = 0;
}
template<class DataType>
SeqHeap<DataType>::SeqHeap(DataType arr[], int n)
{
for (int i = 0; i < n; i++) {
heap[i+1]=arr[i];
}
size = n;
}
template<class DataType>
SeqHeap<DataType>::~SeqHeap()
{
}
template<class DataType>
void SeqHeap<DataType>::MakeMaxSeqHeap(SeqHeap *h)
{
h->MaxHeapSort(h);//构建最大顶堆
}
template<class DataType>
void SeqHeap<DataType>::MakeMinSeqHeap(SeqHeap *h)
{
h->MinHeapSort(h);//构建最小顶堆
}
template<class DataType>
void SeqHeap<DataType>::PrintSeqHeap(SeqHeap h)
{
for (int i = 1; i <= size; i++) {
cout << h.heap[i] << " ";
if (i%20 == 0)
cout << endl;
}
cout << endl;
}
template<class DataType>
void SeqHeap<DataType>::MaxHeapSort(SeqHeap * h)
{
int N = h->size;
for (int k = N / 2; k >= 1; k--) {
SinkConversely(h->heap, k, N);//此步是堆的构造:构造的结果是部分堆有序,即头结点的值是最小的。
}
while (N > 1)
{
Swap(h->heap, 1, N--);
SinkConversely(h->heap, 1, N);
}
}
template<class DataType>
void SeqHeap<DataType>::MinHeapSort(SeqHeap *h)
{
int N = h->size;
for (int k = N / 2; k >= 1; k--) {
Sink(h->heap, k, N);//此步是堆的构造:构造的结果是部分堆有序,即头结点的值是最大的。
}
while (N > 1)
{
Swap(h->heap, 1, N--);
Sink(h->heap, 1, N);
}
}
/*
arr[]:即 h->heap
k:把位置为k的结点下沉
【该结点的特点:heap[k] < heap[2*k] (OR||AND) heap[k]<heap[2*k+1],即该结点值比其两个子结点中的一个或两个小 】
N:堆里(即heap[])有N个元素,即 h->size的值
*/
template<class DataType>
void SeqHeap<DataType>::Sink(DataType arr[], int k, int N)
{
while (2*k <= N) //当结点k 的子结点2*k 不超过当前数组元素的最大下标时【结点 2*k 是 结点 k 的子结点】,才有机会继续下沉
{
int j = 2 * k;
if (j < N && Less(arr[j], arr[j + 1]))
j++;
if (Less(arr[j], arr[k])) break;//also could be !Less(arr[k], arr[j]),即当 arr[k]>arr[j]时跳出循环体
Swap(arr, k, j);
k = j;
}
}
/*
arr[]:即 h->heap
k:把位置为k的结点上浮【该结点的特点:heap[k] > heap[k/2],即该结点值比其父结点值大 】
N:堆里(即heap[])有N个元素,即 h->size的值
*/
template<class DataType>
void SeqHeap<DataType>::Swin(DataType arr[], int k, int N)
{
while ( k>1 && Less(arr[k/2],arr[k]) )//若结点 k 不是根结点、且其值比其父结点大时,循环体进行,结点k上浮
{
Swap(arr, k / 2, k);
k = k / 2;
}
}
template<class DataType>
void SeqHeap<DataType>::SinkConversely(DataType arr[], int k, int N)
{
while (2 * k <= N) //当结点k 的子结点2*k 不超过当前数组元素的最大下标时【结点 2*k 是 结点 k 的子结点】,才有机会继续下沉
{
int j = 2 * k;
if (j < N && Less(arr[j + 1], arr[j]))
j++;
if (Less(arr[k], arr[j])) break;//also could be !Less(arr[k], arr[j]),即当 arr[k]<arr[j]时跳出循环体
Swap(arr, k, j);
k = j;
}
}
template<class DataType>
void SeqHeap<DataType>::SwinConversely(DataType arr[], int k, int N)
{
while (k>1 && Less(arr[k / 2], arr[k]))//若结点 k 不是根结点、且其值比其父结点小时,循环体进行,结点k上浮
{
Swap(arr, k / 2, k);
k = k / 2;
}
}
template<class DataType>
void SeqHeap<DataType>::Swap(DataType arr[], int i, int j)
{
DataType temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
template<class DataType>
void SeqHeap<DataType>::OutputInFile(SeqHeap h, string filename)
{
ofstream outfile(filename);
for (int i = 1; i <= size; i++) {
outfile << h.heap[i] << endl;
}
outfile.close();
}
template<class DataType>
void SeqHeap<DataType>::Clear(SeqHeap * h)
{
h->size = 0;
}
template<class DataType>
bool SeqHeap<DataType>::Less(DataType v, DataType w)
{
return v < w;;
}