算法导论第六章-堆排序-Cpp代码实现

实现了算法导论第六章中堆排序

heap_sort.h

/*************************************************
Author:董小歪
Date:2016-06-04
Description:算法导论第六章-堆排序-Cpp代码实现
**************************************************/

//为了实现算法导论中的下标从1开始，在data下标为0的元素添加一个“哨兵”元素0

#pragma once

#ifndef HEAP_SORT_H
#define HEAP_SORT_H

#include <iostream>
#include <vector>

using namespace std;

template <typename T>
class Heap {
public:
	Heap();							//构造函数
	Heap(const vector<T> _data);			//构造函数

	void build_heapify();			//建堆
	void print_data(bool flag = false);			//打印数据		
	void heapsort();				//堆排序

	int heap_maximum();				//返回最大堆的最大值
	int heap_extract_max();			//返回最大堆的最大值并删除

	void heap_increase_key(int i, T key);	//将元素i的关键字增加到key
	void max_heap_insert(T key);			//插入关键字为key的元素

private:
	vector<T> data; //堆数据
	int heap_size;  //堆的大小

	inline int parent(int i) { return i / 2; }		//父结点
	inline int left(int i) { return 2 * i; }		//左子结点
	inline int right(int i) { return 2 * i + 1; }	//右子结点

	void max_heapify(int i);						//维护堆
};


template <typename T>
Heap<T>::Heap()
{
	data = vector<T>();
	data.push_back(0);
	heap_size = 0;
}

template<typename T>
Heap<T>::Heap(vector<T> _data)
{
	data = vector<T>();
	data.push_back(0);
	for (auto i : _data)
		data.push_back(i);
	heap_size = data.size() - 1;
}

template<typename T>
void Heap<T>::print_data(bool flag)
{
	if (flag)
	{
		if (data.size() > 1)
		{
			for (int i = 1; i < data.size(); ++i)
				cout << data[i] << " ";
			cout << endl;
		}
	}
	else
	{
		if (heap_size > 0)
		{
			for (int i = 1; i <= heap_size; ++i)
				cout << data[i] << " ";
			cout << endl;
		}
	}
}

template<typename T>
void Heap<T>::build_heapify()
{
	for (int i = heap_size / 2; i >= 1; --i)
		max_heapify(i);
}

template<typename T>
void Heap<T>::heapsort()
{
	for (int i = heap_size; i > 1; --i)
	{
		swap(data[1], data[heap_size]);
		--heap_size;
		max_heapify(1);
	}
}

template<typename T>
int Heap<T>::heap_maximum()
{
	if (heap_size > 0)
		return data[1];
	else
		return INT_MIN;
}

template<typename T>
int Heap<T>::heap_extract_max()
{
	if (heap_size < 1)
		return INT_MIN;
	int max = data[1];
	data[1] = data[heap_size];
	--heap_size;
	max_heapify(1);
	return max;
}

template<typename T>
void Heap<T>::heap_increase_key(int i, T key)
{
	if (data[i] >= key)
		return;
	data[i] = key;
	while (i > 1 && data[parent(i)] < data[i])
	{
		swap(data[i], data[parent(i)]);
		i = parent(i);
	}
}

template<typename T>
void Heap<T>::max_heap_insert(T key)
{
	++heap_size;
	data.push_back(INT_MIN);
	heap_increase_key(heap_size, key);
}

template<typename T>
void Heap<T>::max_heapify(int i)
{
	int l = left(i);
	int r = right(i);
	int largest = i;
	if (l <= heap_size && data[l] > data[largest])
		largest = l;
	if (r <= heap_size && data[r] > data[largest])
		largest = r;
	if (largest != i)
	{
		swap(data[largest], data[i]);
		max_heapify(largest);
	}
}
#endif

测试：

main_entrance.cpp

#include "heap_sort.h"

int main()
{
	vector<int> data = { 4,1,3,2,16,9,10,14,8,7 };
	Heap<int> h1(data);
	cout << "h原始数据" << endl;
	h1.print_data();
	cout << endl;
	
	cout << "建堆：" << endl;
	h1.build_heapify();
	h1.print_data();
	cout << endl;

	cout << "改变元素，将下标为9的元素8改为15：" << endl;
	h1.heap_increase_key(9, 15);
	h1.print_data();
	cout << endl;

	cout << "插入元素50：" << endl;
	h1.max_heap_insert(50);
	h1.print_data();
	cout << endl;

	cout << "返回最大值：" << endl;
	cout << h1.heap_maximum() << endl;
	cout << endl;

	cout << "连续取出最大值：" << endl;
	cout << h1.heap_extract_max() << endl;
	cout << h1.heap_extract_max() << endl;
	cout << h1.heap_extract_max() << endl;
	cout << endl;

	//因为这里堆排序是in-place，所以会破坏原始的数据堆，所以建立另外的对象进行测试
	Heap<int> h2(data);
	cout << "h2原始数据" << endl;
	h2.print_data();
	cout << endl;
	h2.build_heapify();
	cout << "堆排序：" << endl;
	h2.heapsort();
	h2.print_data(true);
	cout << endl;

	system("pause");
}

测试结果