/************************************************************
*本程序为一个精简版的stl_sort，内部参考了GNU ISO C++ Library
*用到了部分C++11的特性，在g++ 4.8.1下编译通过
*************************************************************/
#include <iostream>
#include <vector>
#include <functional>
#include <cstdlib>
#include <cassert>
#include <ctime>
//元素数目最大值
const int kMaxNum = 10000000;
//Sort中所用的阀值
const int kThreshold = 16;
template <typename ForwardIterator>
void IterSwap(ForwardIterator a,
ForwardIterator b) {
auto tmp = *a;
*a = *b;
*b = tmp;
}
//这一部分是和堆相关的算法
/**************************************************************/
template <typename RandomAccessIterator, typename Distance,
typename Tp, typename Compare>
void PushHeap(RandomAccessIterator first,
Distance index, Distance top,
Tp val,
const Compare& comp) {
auto parent = (index - 1) / 2;
while (index > top && comp(*(first+parent), val)) {
*(first + index) = *(first + parent);
index = parent;
parent = (index - 1) / 2;
}
*(first + index) = val;
}
template <typename RandomAccessIterator, typename Distance,
typename Tp, typename Compare>
void AdjustHeap(RandomAccessIterator first,
Distance index, Distance len,
Tp val,
const Compare& comp) {
Distance top = index;
Distance child = 2*index + 2;
while (child < len) {
if (comp(*(first+child), *(first+child-1)))
--child;
*(first + index) = *(first + child);
index = child;
child = 2*index + 2;
}
if (child == len) {
*(first + index) = *(first + child - 1);
index = child - 1;
}
::PushHeap(first, index, top, val, comp);
}
template <typename RandomAccessIterator, typename Compare>
void MakeHeap(RandomAccessIterator first,
RandomAccessIterator last,
const Compare& comp) {
if (last - first < 2) return;
auto len = last - first;
auto parent = (len - 2) / 2;
for (;;) {
::AdjustHeap(first, parent, len, *(first+parent), comp);
if (parent == 0) return;
--parent;
}
}
template <typename RandomAccessIterator, typename Compare>
void PopHeap(RandomAccessIterator first,
RandomAccessIterator last,
RandomAccessIterator result,
const Compare& comp) {
assert(first < last);
auto val = *result;
*result = *first;
::AdjustHeap(first, 0, last-first, val, comp);
}
template <typename RandomAccessIterator, typename Compare>
void HeapSort(RandomAccessIterator first,
RandomAccessIterator last,
const Compare& comp) {
assert(first < last);
while (last - first > 1) {
--last;
::PopHeap(first, last, last, comp);
}
}
template <typename RandomAccessIterator, typename Compare>
void HeapSelect(RandomAccessIterator first,
RandomAccessIterator middle,
RandomAccessIterator last,
const Compare& comp) {
assert(first < last);
::MakeHeap(first, middle, comp);
for (RandomAccessIterator i = middle; i < last; ++i) {
if (comp(*i,*first)) ::PopHeap(first, middle, i, comp);
}
}
/**************************************************************/
//局部排序算法，内部用堆来处理
template <typename RandomAccessIterator, typename Compare>
inline void PartialSort(RandomAccessIterator first,
RandomAccessIterator middle,
RandomAccessIterator last,
const Compare& comp) {
assert(first < last);
::HeapSelect(first, middle, last, comp);
::HeapSort(first, middle, comp);
}
//3基准中位数选择算法
template <typename ForwardIterator, typename Compare>
void MoveMedianFirst(ForwardIterator a,
ForwardIterator b,
ForwardIterator c,
const Compare& comp) {
if (comp(*a, *b)) {
if (comp(*b, *c)) {
::IterSwap(a, b);
} else if (comp(*a, *c)) {
::IterSwap(a, c);
}
} else if (comp(*a, *c)) {
return;
} else if (comp(*b, *c)) {
::IterSwap(a, c);
} else {
::IterSwap(a, b);
}
}
//划分函数
template <typename RandomAccessIterator, typename Tp, typename Compare>
RandomAccessIterator
Partition(RandomAccessIterator first,
RandomAccessIterator last,
const Tp& pivot,
const Compare& comp) {
for (;;) {
while (comp(*first, pivot))
++first;
--last;
while (comp(pivot, *last))
--last;
if (!(first < last))
return first;
::IterSwap(first, last);
++first;
}
}
//根据基准点进行划分
template <typename RandomAccessIterator, typename Compare>
inline RandomAccessIterator
PartitionPivot(RandomAccessIterator first,
RandomAccessIterator last,
const Compare& comp) {
assert(first < last);
RandomAccessIterator mid = first + (last - first) / 2;
::MoveMedianFirst(first, mid, (last - 1), comp);
return ::Partition(first + 1, last, *first, comp);
}
//内省排序算法
template<typename RandomAccessIterator, typename Size, typename Compare>
void IntrosortLoop(RandomAccessIterator first,
RandomAccessIterator last,
Size depth_limit,
const Compare& comp) {
while (last - first > kThreshold) {
if (depth_limit == 0) {
::PartialSort(first, last, last, comp);
return;
}
--depth_limit;
RandomAccessIterator cut =
::PartitionPivot(first, last, comp);
::IntrosortLoop(cut, last, depth_limit, comp);
last = cut;
}
}
//插入排序算法
template <typename RandomAccessIterator, typename Compare>
void FinalInsertionSort(RandomAccessIterator first,
RandomAccessIterator last,
const Compare& comp) {
assert(first < last);
auto it = first;
auto tmp = *first;
for (auto i = first+1; i != last; ++i) {
it = i-1;
tmp = *i;
while (it >= first && comp(tmp, *it)) {
*(it+1) = *it;
--it;
}
*(it+1) = tmp;
}
}
template <class Size>
inline Size lg(Size n) {
assert(n > 0);
Size k = 0;
for (; n != 1; n >>= 1) ++k;
return k;
}
//Sort函数模板
template <typename RandomAccessIterator, typename Compare>
inline void Sort(RandomAccessIterator first,
RandomAccessIterator last, const Compare& comp) {
assert(first < last);
::IntrosortLoop(first, last, ::lg(last - first) * 2, comp);
::FinalInsertionSort(first, last, comp);
}
//初始化数组元素，用rand函数产生伪随机数
void Init(std::vector<int>& array) {
for (std::vector<int>::size_type si = 0;
si < array.size(); ++si) {
array[si] = rand();
}
}
//如果排序结果正确则返回排序所用时间
double Test(std::vector<int>& array) {
if (array.size() < 2) return 0.0;
clock_t start_time = clock();
::Sort(array.begin(), array.end(), std::less<int>());
double used_time = static_cast<double>(clock()-start_time);
for (std::vector<int>::size_type si = 0;
si < array.size()-1; ++si) {
assert(array[si] <= array[si+1]);
}
return used_time;
}
int main() {
srand((unsigned)time(NULL));
std::vector<int> array(kMaxNum);
double used_time = 0.0;
for (int i = 0; i < 1; ++i) {
Init(array);
used_time += Test(array);
}
double avg_used_time = used_time / 3 / CLOCKS_PER_SEC;
std::cout << "Average used time is " << avg_used_time << "(s)" << std::endl;
return 0;
}
