最大最小堆排序

HeapSort.h

#ifndef _MAX_HEAPSORT_H_
#define _MAX_HEAPSORT_H_

template <typename T>
class CMaxHeap
{
	int m_capacity;
	int m_size;
	T*m_data;
public:
	CMaxHeap();
	CMaxHeap(const CMaxHeap& that);
	CMaxHeap& operator = (const CMaxHeap& that);
	~CMaxHeap();

	void Enter(const T& data);
	void Quit(T& data);
	void Clear();
	int Size();
};

#endif

HeapSort.cpp

#include "HeapSort.h"

template <typename T>
CMaxHeap<T>::CMaxHeap():m_capacity(8),m_size(0),m_data(new T[m_capacity])
{}

template <typename T>
CMaxHeap<T>::CMaxHeap(const CMaxHeap& that)
	:
	m_capacity(that.m_capacity),
	m_size(that.m_size)
{
	m_data = new T[m_capacity];
	for (int i = 0; i < m_size; ++i)
		m_data[i] = that.m_data[i];
}

template <typename T>
CMaxHeap<T>& CMaxHeap<T>::operator = (const CMaxHeap& that)
{
	if (*this != that)
	{
		delete m_data;
		m_capacity = that.m_capacity;
		m_size = that.m_size;
		m_data = new T[m_capacity];
		for (int i = 0; i < m_size; ++i)
			m_data[i] = that.m_data[i];
	}
}

template <typename T>
CMaxHeap<T>::~CMaxHeap()
{
	delete[] m_data;
}

template <typename T>
void CMaxHeap<T>::Enter(const T& data)
{
	//下表从1开始
	//先放入数据
	m_size += 1;
	m_data[m_size] = data;

	//调整下标
	//得到子节点下表以及父节点下标
	int child_index = m_size;//子节点下标
	int parent_index = child_index / 2;//父节点下标

	while (child_index > 1 &&
		m_data[child_index] > m_data[parent_index])
	{
		//数据交换
		T t = m_data[parent_index];
		m_data[parent_index] = m_data[child_index];
		m_data[child_index] = t;

		//更新下标
		child_index = parent_index;
		parent_index = child_index / 2;
	}

	//扩容
	if (m_size + 1 == m_capacity)
	{
		m_capacity *= 2;
		T* p = new T[m_capacity];
		for (int i = 1; i <= m_size; ++i)
			p[i] = m_data[i];
		delete[] m_data;
		m_data = p;
	}
}

template<typename T>
void CMaxHeap<T>::Quit(T & data)
{
	//没有数据的时候
	if (m_size == 0)
		return false;
	//只有一个数据的时候
	else if (m_size == 1)
	{
		data = m_data[1];
		m_size -= 1;
		return true;
	}

	//得到根节点数据
	data = m_data[1];
	//得到当前最大堆的下标
	int cur_index = 1;
	while (true)
	{
		//有3种可能需要调整情况
		//1)如果有左右子树
		//2)有左无右
		//3)无子树

		//得到左右子树的下标
		int left_index = cur_index * 2;
		int right_index = cur_index * 2 + 1;

		//有左有右子树
		if (right_index <= m_size)
		{
			if (m_data[left_index] < m_data[right_index])
			{
				m_data[cur_index] = m_data[right_index];
				cur_index = right_index;
			}
			else
			{
				m_data[cur_index] = m_data[left_index];
				cur_index = left_index;
			}
		}
		//有左无右
		else if (left_index <= m_size)
		{
			//只有左边的话一定是最后一个子节点放到头上面
			//就行再让下标数减少1位就好
			m_data[cur_index] = m_data[left_index];
			m_size -= 1;
			return true;
		}
		//无子节点
		else
		{
			//将当前最后一个节点补齐到当前位置
			m_data[cur_index] = m_data[m_size];
			m_size -= 1;

			//调整下标
			//得到子节点、父节点
			int child_index = cur_index;//子节点
			int parent_index = cur_index / 2;//父节点

			while (child_index > 1 &&
				m_data[parent_index] < m_data[child_index])
			{
				//数据交换
				T t = m_data[parent_index];
				m_data[parent_index] = m_data[child_index];
				m_data[child_index] = t;

				cur_index = child_index;
				parent_index = child_index / 2;
			}
			return true;
		}
	}
}


template <typename T>
void CMaxHeap<T>::Clear()
{
	m_size = 0;
}

template <typename T>
int CMaxHeap<T>::Size()
{
	return m_size;
}

HeapSort.cpp