堆排序c++实现

编写了一个堆排序的c++语言的方法，从小到大排序

目录

heap.h

heap.cpp

main.cpp

---

heap.h

#pragma once
#include<iostream>
#include<cassert>
using namespace std;
typedef int HPDataType;//数据类型
class Heap
{
public:
	//堆的创建
	Heap();

	//交换堆的元素
	void Swap(HPDataType& pa, HPDataType& pb);

	//打印堆中数据
	void HeapPrint();

	//向上调整
	void AdjustUp(HPDataType* a, size_t child);

	//堆的插入
    void HeapPush(HPDataType x);

	//向下调整
	void AdjustDown(HPDataType* a, size_t size, size_t root);

	// 堆的删除
    void HeapPop();

	// 堆的判空
	bool HeapEmpty(); 

	// 堆的数据个数
    size_t HeapSize(); 

    // 取堆顶的数据
    HPDataType HeapTop();

	//堆的析构
	~Heap();

private:
	HPDataType* a;
	size_t size;
	size_t capacity;
};
//堆排序
void HeapSort(int* a, int size);
//展示数据
void ShowArr(int* a, int n);

heap.cpp

#include"heap.h"

//初始化堆
Heap::Heap()
{	
	this->a = new HPDataType[1];
	assert(a);
	this->capacity = 1;
	this->size = 0;
}

//交换堆的元素
void Heap::Swap(HPDataType& pa, HPDataType& pb)
{
	HPDataType temp = pa;
	pa = pb;
	pb = temp;
}

//打印堆中元素
void Heap::HeapPrint()
{
	assert(a);
    for (size_t i = 0; i < this->size; i++)
	{
		cout << a[i] << " ";
	}
	cout << endl;
}

//向上调整
void Heap::AdjustUp(HPDataType* a, size_t child)
{	
	while (child > 0)
	{
		size_t parent = (child - 1) / 2;
		if (a[child] < a[parent])//如果想改成大堆就改成大于号
		{
			Swap(a[child], a[parent]);
			child = parent;
		}
		else
		{
			break;
		}
	}
}

//堆的插入
void Heap::HeapPush(HPDataType x)
{
	assert(a);
	//扩容
	if (this->size == this->capacity)
	{
		size_t newCapacity = this->capacity == 0 ? 4 : 2 * this->capacity;
		HPDataType* tmp = (HPDataType*)realloc(this->a, sizeof(HPDataType) * newCapacity);
		assert(tmp);
		this->a = tmp;
		this->capacity = newCapacity;
	}
	//插入
	this->a[this->size] = x;
	++this->size;
	//保持堆，移位
	AdjustUp(this->a, this->size - 1);
}
		
//向下调整
void Heap::AdjustDown(HPDataType* a, size_t size, size_t root)
{
	size_t parent = root;
	size_t child = root * 2 + 1;
	while (child < size)
	{
		//选左右孩子中小的孩子
		if (child + 1 < size && a[child] > a[child + 1])//如果想改成大堆就改第二个大于号
		{
			child++;
		}
		//如果孩子小于父亲，则交换，并继续向下调整
		if (a[parent] > a[child])//如果想改成大堆就改成小于号
		{
			Swap(a[parent], a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}


// 堆的删除
void Heap::HeapPop()
{
	assert(this->a);
	assert(this->size > 0);

	Swap(this->a[0], this->a[this->size - 1]);
	this->size--;

	//向下调整
	AdjustDown(this->a, this->size, 0);
}

// 堆的判空
bool Heap::HeapEmpty()
{
	assert(this->a);
	return this->size == 0;
}

// 堆的数据个数
size_t Heap::HeapSize()
{
	assert(this->a);
	return this->size;
}

// 取堆顶的数据
HPDataType Heap::HeapTop()
{
	assert(this->a);
	assert(this->size > 0);
	return this->a[0];
}

//析构堆属性
Heap::~Heap()
{
	if (!a)
	{
		delete a;
		a = NULL;
	}
	this->capacity = this->size = 0;
}

//堆排序
void HeapSort(int* a, int size)
{
	Heap h;
	for (int i = 0; i < size; i++)
	{
		h.HeapPush(a[i]);
	}
	int j = 0;
	while (!h.HeapEmpty())
	{
		a[j] = h.HeapTop();
		h.HeapPop();
		j++;
	}
}

//展示数组信息
void ShowArr(int* a, int n)
{
	for (int i = 0; i < n; i++)
	{
		cout << a[i] << " ";
	}
	cout << endl;
}

main.cpp

#include<iostream>
#include<ctime>
using namespace std;
#include"heap.h"

int main()
{
	srand(time(NULL));
	int arr[15];
	cout << "随机的数据为：";

	int size = sizeof(arr) / sizeof(arr[0]);

	for (int i = 0; i < size; i++)
	{
		int temp = rand() % 20;
		arr[i] = temp;
		cout << temp << " ";
	}
	cout << endl << endl;

	cout << "排序前数据为：";
	ShowArr(arr, size);
	cout << endl;

	HeapSort(arr, size);
	cout << "排序后数据为：";
	ShowArr(arr, size);

	return 0;
}