自己实现的一个高效快速排序: )

      最近准备把基础算法都高效地实现一遍，放入BaseAlgo.h中。大概LSGTL 1.05中会包含这个新的头文件吧。现在LSGTL已经越来越偏离纯粹的图算法库了，或许到1.05的时候都已经不再叫LSGTL了吧: ) 下面是和VC++ 9.0的std::sort的一个简单时间效率对比：

5百万随机数据：
quickSort 609ms
std::sort 750ms
5百万相同数据：
quickSort 47ms
std::sort 16ms
另外，quickSort的空间复杂度为log2(N)

代码：

/******************************************************************************* ** ** Copyright (c) 2010, Li Lingxi (TrutherCn@yahoo.com.cn) ** All rights reserved. ** ** Redistribution and use in source and binary forms, with or without ** modification, are permitted provided that the following conditions ** are met: ** ** * Redistributions of source code must retain the above copyright ** notice, this list of conditions and the following disclaimer. ** ** * Redistributions in binary form must reproduce the above copyright ** notice, this list of conditions and the following disclaimer in ** the documentation and/or other materials provided with the ** distribution. ** ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ** FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ** COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, ** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, ** BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER ** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ** ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ** POSSIBILITY OF SUCH DAMAGE. ** ********************************************************************************/ #pragma once #include <ctime> #include <cassert> #include <cmath> #include <numeric> #include <functional> #include <algorithm> #include <iostream> #include <fstream> #include <sstream> #include <string> #include <list> template <typename Iterator> inline typename std::iterator_traits<Iterator>::value_type* getValueType(Iterator) { return NULL; } const int QUICK_SORT_CUTOFF_SIZE = 31; int ceilLog2(int v) { assert(v > 0); int cnt = v < (1 << 15) ? -1 : 14; while ((1 << ++cnt) < v); return cnt; } template <typename Iterator> inline void sort2(Iterator a, Iterator b) { if (*a > *b) { std::swap(*a, *b); } } template <typename Iterator> inline void sort3(Iterator a, Iterator b, Iterator c) { sort2(a, b); sort2(b, c); sort2(a, b); } template <typename Iterator> inline void insertSort(Iterator first, Iterator last) { insertSort(first, last, getValueType(first)); } template <typename Iterator, typename Type> void insertSort(Iterator first, Iterator last, Type*) { assert(first <= last); Type val; Iterator i = first, hole, prev; while (++i < last) // i addresses the element to insert { val = *i; // back up if (*first > val) { std::copy_backward(first, i, i + 1); *first = val; // put val in position } else // *first acts as sentinel { hole = i; prev = i - 1; while (*prev > val) { *hole-- = *prev--; } *hole = val; // put val in position } } } // quickSort with three-way partitioning template <typename Iterator> inline void quickSort(Iterator first, Iterator last) { quickSort(first, last, getValueType(first)); } template <typename Iterator, typename Type> void quickSort(Iterator first, Iterator last, Type*) { assert(first <= last); Iterator *stk = new Iterator[ceilLog2(last - first) << 1]; Iterator *top = stk; *top++ = first; *top++ = last; std::pair<Iterator, Iterator> delims; Iterator mid; while (top != stk) { last = *--top; first = *--top; if (last - first < QUICK_SORT_CUTOFF_SIZE) { // insertion sort is used when range is small insertSort(first, last); continue; } mid = first + ((last - first) >> 1); sort3(first, mid, last - 1); std::swap(*mid, *(last - 1)); delims = partition(first, last); if (delims.first - first < last - delims.second) { // push right subrange first *top++ = delims.second; *top++ = last; *top++ = first; *top++ = delims.first; } else // do the other way around { *top++ = first; *top++ = delims.first; *top++ = delims.second; *top++ = last; } } delete[] stk; } template <typename Iterator> std::pair<Iterator, Iterator> partition(Iterator first, Iterator last) { assert(first <= last); Iterator left = first - 1, right = --last; // ll delimits equal elements in left subrange // rr delimits equal elements in right subrange Iterator ll = left, rr = right; while (true) { while (*++left < *last); while (*--right > *last); if (left < right) { std::swap(*left, *right); if (*left == *last) { std::swap(*left, *++ll); } if (*right == *last) { std::swap(*right, *--rr); } } else { break; } } // move elements in position if (left == right) { --right; ++left; } while (first <= ll) { std::swap(*first++, *right--); } while (last >= rr) { std::swap(*last--, *left++); } return std::make_pair(++right, left); }