算法导论： 第六章 堆排序算法

堆排序， 一种基础算法， 实现了一个二叉树， 根节点的值大于子节点， 就是最大堆。 小于子节点， 就是最小堆。 堆排序的性能是O(nlg(n)). 插入, 取值都是O(lg(n)). 优先级队列经常用堆排序来实现。 以下是我的实现：

inline int heapLeft(int i) {return 2 * i + 1;}
inline int heapRight(int i) {return 2 * i + 2;}
inline int heapParent(int i) {return (i - 1) / 2;}

用来取得子女和父母的下标。

template<class Iter, class Function>
void maxHeapify(Iter first, int length, int index, Function f)
{
int largest = index;
int l = heapLeft(index);
int r = heapRight(index);
if (l < length && f(*(first + l) , *(first + largest)))
{
largest = l;
}
if (r < length && f(*(first + r) , *(first + largest)))
{
largest = r;
}
if (largest != index)
{
std::swap(*(first + largest), *(first + index));
maxHeapify(first, length, largest, f);
}
}

维持堆的特性。

template<class Iter, class Function>
void buildHeap(Iter first, Iter last, Function f)
{
for (int i = (last - first) / 2; i >= 0; --i)
{
maxHeapify(first, last - first, i, f);
}
}

生成堆函数。

template<class _RandomAccessIterator, class Function>
void heapSort(_RandomAccessIterator first, _RandomAccessIterator last, Function f)
{
buildHeap(first, last, f);
size_t length = last - first;
for (int i = length - 1; i > 0; --i)
{
std::swap(*(first + i), *first);
--length;
maxHeapify(first, length, 0, f);
}
}

堆排序算法。

还利用堆的函数实现了一个优先级队列， vector是队列的容器。 传入一个堆比较函数。 实现如下：

template<class _Ty, class Function>
class PriorityQueue
{
public:
template<class Iter>
PriorityQueue(Iter first, Iter last)
{
assign(first, last);
}

PriorityQueue()
{

}

template<class Iter>
void assign(Iter first, Iter last)
{
for (Iter it = first; it != last; ++it)
{
m_data.push_back(*it);
}
buildHeap(m_data.begin(), m_data.end(), m_function);
}

inline _Ty top()
{
return m_data[0];
}

inline size_t size() {return m_data.size();}

_Ty extract()
{
if (m_data.empty())
{
return _Ty();
}
_Ty _result = top();
std::swap(m_data[0], m_data[m_data.size() - 1]);
m_data.pop_back();
maxHeapify(m_data.begin(), m_data.size(), 0, m_function);
return _result;
}

void increaseKey(int index, const _Ty& addValue)
{
if (index < m_data.size())
{
m_data[index] += addValue;
}
bottomMaxHeapify(index);
}

void insert(const _Ty& value)
{
m_data.push_back(value);
bottomMaxHeapify(m_data.size() - 1);
}

private:
void bottomMaxHeapify(int index)
{
while (index > 0 && m_function(m_data[index], m_data[heapParent(index)]))
{
std::swap(m_data[heapParent(index)], m_data[index]);
index = heapParent(index);
}
}

private:
std::vector<_Ty> m_data;
Function m_function;
};