C++博客-Cottage Technology-随笔分类-算法和数据结构

Base64

cottage technology — Tue, 22 Jun 2021 09:54:00 GMT

摘要: 转自：https://github.com/ReneNyffenegger/cpp-base64 Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->/* base64.cpp and base64.h... 阅读全文

cottage technology 2021-06-22 17:54 发表评论

using gcc_x86 assembly to scan the most significant one bit and the least significant one bit

cottage technology — Sun, 15 Jun 2014 09:38:00 GMT

原来发过搜索第一位的帖子，这次算再补充一下吧。以下取自网络，作者不详。

1 #ifdef __GNUC__
2
3 #if (defined _WIN64 || defined __x86_64__)
4
5 /**
6  * ../bit_scan_forward
7  * @return index (0..63) of least significant one bit
8  */
9 unsigned bit_scan_forward(unsigned long long x)
10 {
11    asm("bsfq %0, %0" : "=r" (x) : "0" (x));
12    return unsigned(x);
13 }
14
15 /**
16  * bit_scan_reverse
17  * @return index (0..63) of most significant one bit
18  */
19 unsigned bit_scan_reverse(unsigned long long x)
20 {
21    asm("bsrq %0, %0" : "=r" (x) : "0" (x));
22    return unsigned(x);
23 }
24
25 #elif (defined _WIN32) || (defined __linux__)
26
27 /**
28  * ../bit_scan_forward
29  * @return index (0..63) of least significant one bit
30  */
31 unsigned bit_scan_forward(unsigned long long x)
32 {
33    asm("bsf %0, %0" : "=r" (x) : "0" (x));
34    return unsigned(x);
35 }
36
37 /**
38  * bit_scan_reverse
39  * @return index (0..63) of most significant one bit
40  */
41 unsigned bit_scan_reverse(unsigned long long x)
42 {
43    asm("bsr %0, %0" : "=r" (x) : "0" (x));
44    return unsigned(x);
45 }
46
47 #endif
48
49 #endif

cottage technology 2014-06-15 17:38 发表评论

单数组哈希表unordered_map和unordered_set

cottage technology — Sun, 09 Sep 2012 14:53:00 GMT

摘要: 以静态表为例，原理如下图，也就是多个单链表存储在同一个数组中。勉强算开地址哈希表吧，但跟一般开地址哈希表原理不太一样。存储在同一个数组的目的是节省一个表头指针，有表头指针的哈希表见本主页"双数组哈希unordered_xxx"相对于传统的拉链哈希表，这个哈希表的原理不太好理解(传统的好理解，但耗费内存多且速度慢～～)看上图。使用默认值覆盖的原因是我们原本用它计算陆地坐标，(0,0,0)这个点在海里... 阅读全文

cottage technology 2012-09-09 22:53 发表评论

双数组哈希unordered_xxx

cottage technology — Sun, 26 Aug 2012 08:49:00 GMT

摘要: 简单的类层次结构以静态表unorered_set为例，工作原理见下图简单的效率测试 Sample是本处讲述的双数组unordered_xxx，standard是编译器的unordered_xxx，boost1.50表示它的unordered_xxx测试环境： Win7 x64 Ultimate (Kernel 6.1.7601), g++4.6.3 64bit (-O3), Intel Xeo... 阅读全文

cottage technology 2012-08-26 16:49 发表评论

bogo_sort (名副其实最慢的的排序)

cottage technology — Tue, 10 Jan 2012 05:10:00 GMT

一直追求的目标是写出高效低内存消耗的程序，时间久了觉得换个方向了，呵呵。就拿排序试试吧。
bogo sort又称stupid sort或slow sort，我觉得应该是最慢的排序算法了吧，至少理论上比蜗牛排序(本主页有介绍)慢。
该排序算法的思想是对于一个给定的序列，随机的生成各种可能的序列，直到遇到某个序列有序为止。时间复杂度最好情况下是O(n)，最坏情况下是无穷大，一般情况是O(n*n!)，可见相当的恐怖。看代码就明白了。

  1 // bogo_sort.hpp
  2 #ifndef BOGO_SORT_HPP_
  3 #define BOGO_SORT_HPP_
  4
  5 template <typename ForwardIterator, typename Compare>
  6 bool is_sorted(ForwardIterator first, ForwardIterator last, Compare cmp)
  7 {
  8   if (first == last)
  9     return true;
10   ForwardIterator next = first;
11   for(++next; next != last; first = next, ++next)
12     if(cmp(*next, *first))
13       return false;
14   return true;
15 }
16
17 template <typename T>
18 inline void swap(T& x, T& y)
19 {
20   const T tmp(x);
21   x = y;
22   y = tmp;
23 }
24
25 template <typename RandomIterator, typename RandomGen>
26 void shuffle(RandomIterator first, RandomIterator last, RandomGen gen)
27 {
28   unsigned long d = last - first;
29   if(d < 2)
30     return;
31   for(RandomIterator it = first; first != last; ++first)
32     swap(*(it + gen()%d), *first);
33 }
34
35 #include "random.hpp"
36
37 template <typename RandomIterator, typename Compare>
38 void bogo_sort(RandomIterator first, RandomIterator last, Compare cmp)
39 {
40   while(!is_sorted(first, last, cmp))
41     shuffle(first, last, random());
42 }
43
44 #endif
45
46 // random.hpp
47 #ifndef RANDOM_HPP_
48 #define RANDOM_HPP_
49 #include <ctime>
50
51 class random
52 {
53 private:
54   typedef unsigned long UInt32; // 如果你的编译器不认识uint32_t，就用unsigned long代替
55   UInt32 a;
56   UInt32 b;
57   UInt32 c;
58   UInt32 d;
59
60   UInt32 randomize()
61   {
62     UInt32 e = a - ((b << 27) | (b >> 5));
63     a = b ^ ((c << 17) | (c >> 15));
64     b = c + d;
65     c = d + e;
66     d = e + a;
67     return d;
68   }
69
70   void init()
71   {
72     for(UInt32 i = 0; i < 20; ++i)
73       randomize();
74   }
75
76 public:
77   explicit random(UInt32 s = std::time(0)) : a(4058668781ul), b(s), c(s), d(s)
78   {
79     init();
80   }
81
82   void reset(UInt32 s = 0)
83   {
84     if(0 == s)
85       s = std::time(0);
86     a = 4058668781ul;
87     b = c = d = s;
88     init();
89   }
90
91   UInt32 rand()
92   {
93   //returns a random integer in the range [0, 4294967296)
94     return randomize();
95   }
96
97   double real()
98   {
99   //returns a random real number in the range [0.0, 1.0)
100     return randomize() / 4294967296.0;
101   }
102
103   UInt32 operator()() { return rand(); }
104 };
105
106 #endif  // RANDOM_HPP_

1 // main.cpp
2 #include "bogo_sort.hpp"
3 #include <iostream>
4
5 template <typename T>
6 struct greater
7 {
8   bool operator ()(const T& x, const T& y) const { return y < x; }
9 };
10
11 int main()
12 {
13   const int LEN = 4;
14   int arr[LEN] = { 2, 5, 1, 4 };
15   while(!is_sorted(arr, arr + LEN, greater<int>())) // 就来个从大到小的顺序吧
16     shuffle(arr, arr + LEN, random());
17   for(int i = 0; i < LEN; ++i)                              // 序列这么短，输出看看就行
18     std::cout << arr[i] << ' ';
19
20   return 0;
21 }
22

cottage technology 2012-01-10 13:10 发表评论

用排序数组代替平衡树实现关联容器

cottage technology — Tue, 27 Sep 2011 11:55:00 GMT

摘要: STL中的关联容器一般用平衡树来实现，多数是红黑树，平衡树的单个插入、查找、删除操作时间复杂度都为O(logn)，但是为了保证元素之间的相对次序，每个元素需要三个指针和一个状态位的内存开销，还有，在堆上分配的每块内存都有几个字节的metadata开销。如果用于处理短类型的元素，这实在不划算。况且很多场合我们并不需要频繁插入和删除元素，仅仅是大量检索操作。如果仅需要大量查找，且不会频繁的插入和... 阅读全文

cottage technology 2011-09-27 19:55 发表评论

查找一个64位整数二进制第一个1

cottage technology — Tue, 23 Aug 2011 04:41:00 GMT

有时候用到位运算。需要快速找到一个整数的二进制第一个1或0在哪个位(下标)？例如：十进制数100的二进制是1100100，那么它的第一个1在下标为2的位置(bsf, bit scan forward)或6的位置(bsr, bit scan in reverse order)，由于只用于存储一个状态，至于用bsf还是bsr则无所谓。

解决这个问题的第一个想法就是用内联汇编的做法，使用特别的CPU指令去找，但汇编的可移植性比较差，不同的CPU型号使用的指令可能不一样，执行速度也不一样。
假设找一个64位无符号整数二进制的第一个1，用bsf, AT& T汇编(gcc汇编)可以这样做：

1 // bit scan forward for 64 bit integral number
2 /* ============================================ */
3 inline int bsf_asm (uint64_t w)
4 {
5   int x1, x2;
6   asm ("bsf %0,%0\n" "jnz 1f\n" "bsf %1,%0\n" "jz 1f\n" "addl $32,%0\n"
7      "1:": "=&q" (x1), "=&q" (x2):"1" ((int) (w >> 32)),
8      "0" ((int) w));
9   return x1;
10 }

如果用C来实现的话，那就有点麻烦了，在此不讲复杂的数学原理，仅仅给出代码。

1 // bit scan forward for 64 bit integral number
2 /* ============================================ */
3 inline int bsf_folded (uint64_t bb)
4 {
5      static const int lsb_64_table[64] =
6    {
7       63, 30,  3, 32, 59, 14, 11, 33,
8       60, 24, 50,  9, 55, 19, 21, 34,
9       61, 29,  2, 53, 51, 23, 41, 18,
10       56, 28,  1, 43, 46, 27,  0, 35,
11       62, 31, 58,  4,  5, 49, 54,  6,
12       15, 52, 12, 40,  7, 42, 45, 16,
13       25, 57, 48, 13, 10, 39,  8, 44,
14       20, 47, 38, 22, 17, 37, 36, 26
15    };
16    unsigned int folded;
17    bb ^= bb - 1;
18    folded = (int) bb ^ (bb >> 32);
19    return lsb_64_table[folded * 0x78291ACF >> 26];
20 }

如果想从后往前搜索一个整数的二进制第一个1的下标，用汇编可以这样做。

1 // bit scan in reverse order for 64 bit integral number
2 /* ============================================ */
3 inline int bsr_asm (uint64_t w)
4 {
5   int x1, x2;
6   asm ("bsr %1,%0\n" "jnz 1f\n" "bsr %0,%0\n" "subl $32,%0\n"
7      "1: addl $32,%0\n": "=&q" (x1), "=&q" (x2):"1" ((int) (w >> 32)),
8      "0" ((int) w));
9   return x1;
10 }

如果用C来实现的话，也比较简单，用divide and conquer 的原理就不会太慢。

1 // a logn (n == 32)algorithm for bit scan in reverse order
2 /* ============================================ */
3 inline int bsr32(uint32_t bb)
4 {
5      static const char msb_256_table[256] =
6    {
7       0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
8       4, 4, 4, 4, 4, 4, 4, 4,4, 4, 4, 4,4, 4, 4, 4,
9       5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
10       6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
11       6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
12       7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
13       7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
14       7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
15       7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
16    };
17    int result = 0;
18
19    if (bb > 0xFFFF)
20      {
21       bb >>= 16;
22       result += 16;
23    }
24    if (bb > 0xFF)
25      {
26       bb >>= 8;
27       result += 8;
28    }
29
30    return (result + msb_256_table[bb]);
31 }
32
33 /* ============================================ */
34 inline int bsr_in_C(uint64_t bb)
35 {
36   const uint32_t hb = bb >> 32;
37   return hb ? 32 + bsr32((uint32_t)hb) : bsr32((uint32_t)bb);
38
39 }
40

下面这个似乎也可以，失败时返回-1023，至于速度快慢就要看编译器的嗜好了。

1 // bit scan in reverse order for 64 bit integral number
2 /* ============================================ */
3 inline int bsr_double (uint64_t bb)
4 {
5    union
6    {
7       double d;
8       struct
9       {
10          unsigned int mantissal : 32;
11          unsigned int mantissah : 20;
12          unsigned int exponent : 11;
13          unsigned int sign : 1;
14       };
15    } ud;
16    ud.d = (double)(bb & ~(bb >> 32));
17    return ud.exponent - 1023;
18 }
19

以上uint64_t和uint32_t是新C++标准可以支持的整型，分别相当于旧的unsigned long long和unsigned long类型。以上代码不是我的原创，而是来自国外某位朋友，我稍微加工了一下贴到这里，版权属于原作者，如果我没有记错的话应该是GNU。

cottage technology 2011-08-23 12:41 发表评论

B+树的C++实现

cottage technology — Tue, 16 Aug 2011 07:05:00 GMT

关于B+树的实现和测试，我见过的最详细的C++代码在：
http://idlebox.net/2007/stx-btree/
一位德国朋友的杰作。

cottage technology 2011-08-16 15:05 发表评论

排序大比武

cottage technology — Tue, 16 Aug 2011 06:14:00 GMT

摘要: 该比武只比速度，单线程测试随机正整数，不包括蜗牛排序，它弃权啦，哈哈。操作系统：Windows XP Pro SP3，英文版编译器：g++4.5.2(-O3)CPU： Intel Core2 Q9500内存：DDR3普条 1066MHz， 4GB 插入排序、选择排序和冒泡排序最慢，时间复杂度为O(n2)，希尔排序的速度依赖于使用的增量序列，堆排序、归并排序和改进的快速排序处于中等水平，时间复杂度... 阅读全文

cottage technology 2011-08-16 14:14 发表评论

二分插入排序

cottage technology — Tue, 16 Aug 2011 06:08:00 GMT

二分插入排序

直接插入排序时后面的元素从后向前逐个比较寻找插入位置，有时候没有必要这样做，因为此时需要寻找合适插入位置的当前这个元素前面的子序列已经有序，如果使用二分查找插入位置往往可以减少平均搜索长度。对于一个待排序的随机序列而言，用二分插入排序取代直接插入排序，尽管总的移动元素次数不可能减少，但是可能减少总的平均比较次数。二分插入排序的平均时间复杂度为O(n²)，最坏情况下的时间复杂度为(n²)，当待排序序列已经有序时，排序时间复杂度为O(nlogn)。空间复杂度为O(1)。二分插入排序是否稳定依赖于具体实现。

假设一个序列已经有序，此时我们需要向这个序列里插入一个新的值，那么我们如何找到合适的位置呢？

首先跟序列最中间的那个元素比较，如果比最中间的这个元素小，则插入位置在它的左边，否则在它的右边。以当前最中间位置为分割点，如果在左边，则当前最中间位置是待搜索子序列的终点，如果在右边，右边邻接的元素将是待搜索子序列的起点。按照这种原则，继续寻找下一个中间位置，并继续这种过程，直到找到合适的插入位置为止。

问题是何谓合适的插入位置？如果序列中有一个元素与当前待插入的元素值相等，那么插入位置应该选在该元素的前面还是后面呢？选在后面则二分插入排序稳定，选在前面则二分插入排序不稳定。如果序列中有多个元素与当前待插入的元素值相等，插入位置选在哪里呢？选在最后一个的后面则二分插入排序稳定，其它情况均不稳定。这里的“前面”位置和“后面”位置通常被称为上界和下界。

还有，对数组二分插入排序比较简单，那么能对链表进行二分插入排序吗？理论上没有什么问题，如果希望代码复用程度高的话，链表需要提供迭代器。问题关键不在于代码复用性怎么样，而是插入排序的速度太慢，一般不采纳。

使用二分插入排序对一个无序序列排序的场合极其罕见，因为太多的时候让一个静态序列有序则有更快的排序算法可以选用，当一个序列很短时，直接插入排序由于开销小比二分插入排序要快一点，当待排序序列较长时有很多排序算法(本文后面会介绍一些)均比二分插入排序快得多。

1 template <typename RandomIter, typename T, typename Compare>
2 inline void linear_binary_insertion(RandomIter first, RandomIter
3                                     last, T value, Compare cmp)
4 {
5   RandomIter curr = upper_bound(first, last, value, cmp); // 见本主页的原地归并排序介绍
6   copy_backward(curr, last, last + 1);                               // 暂且需要用标准库，将来也许添加该部分的代码
7   *curr = value;
8 }
9
10 template <typename RandomIter, typename Compare>
11 void binary_insertion_sort(RandomIter first, RandomIter last, Compare cmp)
12 {
13   if(last - first < 2)
14     return;
15   for(RandomIter it = first + 1; it != last; ++it)
16     linear_binary_insertion(first, it, *it, cmp);
17 }

cottage technology 2011-08-16 14:08 发表评论

桶排序

cottage technology — Tue, 16 Aug 2011 06:03:00 GMT

桶排序

当待排序的随机序列密集的分布于一个狭窄区间时，使用计数排序速度比较快，当待排序的随机序列比较均匀的分布于一个较宽区间时，可以考虑使用桶排序。桶排序的时间复杂度为O(n)，空间复杂度也为O(n)。

既然一个待排序的随机序列比较均匀的分布于一个区间，就很容易散列到各个桶中，假设有 n 个元素比较均匀的散列到 m 个桶中，则每个桶中的元素数目约为 n/m，可以使用普通排序算法对每个桶中的元素排序，排序完毕后再把所有元素复制到最初序列的位置覆盖原始序列。实际应中n/m 通常很小，可以使用直接插入排序给每个桶中的元素排序，总的时间复杂度为O(n + m*(n/m)² + n) = O(n²/m + 2n) = O(n)。如果每个桶的元素用链表存储，链表可以用归并排序，各桶排序完毕后把各个链表连接起来就可以了，省去一次复制元素的麻烦，这样操作的时间复杂度为O(n + m(n/m)log(n/m)) = O(n + nlogk) = O(n)。

以随机整数为例，桶排序过程如下表。

48 40 66 91 47 68 31 30 29 23 99 35 23 88 88 87	待排序的随机序列
01 2 3 4 5 6 7 8 9	桶号
29 23 23 31 30 35 48 40 47 66 68 88 88 87 91 99	散列(/10)到各个桶内
23 23 29 30 31 35 40 47 48 66 68 87 88 88 91 99	各桶分别排序
23 23 29 30 31 35 40 47 48 66 68 87 88 88 91 99	最终排序结果

1 inline unsigned long power2ceil(unsigned long x)
2 {
3   --x;
4   x |= x >> 1;
5   x |= x >> 2;
6   x |= x >> 4;
7   x |= x >> 8;
8   x |= x >> 16;
9 //  x |= x >> 32;
10   return ++x;
11 }
12
13 inline unsigned long hash_bits(unsigned long x)
14 {
15  unsigned long sum = 0;
16  for(; x > 1; x >>= 1)
17    ++sum;
18  return sum;
19 }
20
21 // non-portable implementation only for unsigned long type
22 template <typename Compare>
23 void bucket_sort(std::vector<unsigned long>& v, Compare cmp)
24 {
25  unsigned long max = *max_element(v.begin(), v.end()); // 见本主页的计数排序
26  unsigned long min = *min_element(v.begin(), v.end());    // 见本主页的计数排序
27  unsigned long max_bits = hash_bits(power2ceil(max - min));
28  unsigned long base = hash_bits(power2ceil(v.size()) / 100);
29  unsigned long bins = 1 << base;
30  unsigned long offset = (max_bits <= base ? base >> 7 : max_bits - base);
31  unsigned long pits = 128;
32  typedef std::vector<unsigned long> VECTOR;
33   std::vector<VECTOR> vec(bins + 1);
34  for(VECTOR::size_type i = 0; i < vec.size(); ++i)
35     vec[i].reserve(pits);
36  for(VECTOR::size_type i = 0; i < v.size(); ++i)
37     vec[(v[i] - min) >> offset].push_back(v[i]);
38  for(VECTOR::size_type i = 0; i < vec.size(); ++i)
39    insertion_sort(vec[i].begin(), vec[i].end(), cmp);           // 插入排序见本主页的快排
40  unsigned long k = 0;
41  for(std::vector<VECTOR>::size_type i = 0; i < vec.size(); ++i)
42    for(VECTOR::size_type j = 0; j < vec[i].size(); ++j)
43      v[k++] = vec[i][j];
44 }

cottage technology 2011-08-16 14:03 发表评论

计数排序

cottage technology — Tue, 16 Aug 2011 05:58:00 GMT

计数排序

如果给一个分布于区间[min, max)的随机序列排序，可以考虑使用计数排序，max-min 越小说明分布越集中，此时使用计数排序效果就越好，计数排序是一种稳定的排序算法。一般而言，计数排序的时间复杂度为O(n)，空间复杂度O(n)，从理论上来看，它比时间复杂度O(nlogn)的算法明显快一些。

使用计数排序算法对一个正整数序列进行升序排序时，假设对于某个元素比它小的元素个数为 i(其中0≤i，获取该信息无需借助比较运算)，则排序后该元素就应该位于数组下标为i的位置。现在的问题是，如果对于等于某个值的正整数不止一个该如何确定各自位置呢？这个问题在实现中容易解决。

为了能够正常排序，需要用max-min 个辅助空间记录不同正整数的个数，由于排序无法原地进行，还需要开辟等大的辅助空间容纳排序后的所有正整数，一般而言，max-min 不大于待排序的正整数个数或与之相当，可见空间复杂度为O(n + (max-min)) = O(n)。

以一个随机整数序列为例，计数排序过程如下。

13 11 13 11 13 12 15 17 15	待排序序列
0 1 2 3 4 5 6 7 8	计数数组下标
1 2 1 4 0 5 1 1 1	依次计数
1 3 4 8 8 13 14 15 16	计数累计
10 11 11 12 13 13 13 13 15	根据累计归位

1 #include <vector>
2 template <typename ForwardIter>
3 const ForwardIter max_element(ForwardIter first, ForwardIter last)
4 {
5   ForwardIter it = first;
6   while(++first != last)
7   {
8     if(*it < *first)
9       it = first;
10   }
11   return it;
12 }
13
14 template <typename ForwardIter>
15 const ForwardIter min_element(ForwardIter first, ForwardIter last)
16 {
17   ForwardIter it = first;
18   while(++first != last)
19   {
20     if(*first < *it)
21       it = first;
22   }
23   return it;
24 }
25 // not portable implementation
26 void counting_sort(std::vector<unsigned long>& s)
27 {
28   if(s.empty() || 1 == s.size())
29     return;
30   typedef std::vector<unsigned long>::value_type value_type;
31   value_type max = *max_element(s.begin(), s.end());
32   value_type min = *min_element(s.begin(), s.end());
33   typedef std::vector<unsigned long>::size_type size_type;
34   std::vector<unsigned long> h(max - min + 1), d(s.size());
35   for(size_type i = 0; i < s.size(); ++i)
36     ++h[s[i]-min];
37   for(size_type i = 1; i < h.size(); ++i)
38     h[i] += h[i-1];
39   for(size_type i = 0; i < s.size(); ++i)
40     d[--h[s[i]-min]] = s[i];
41   s.swap(d);
42 }

cottage technology 2011-08-16 13:58 发表评论

二路归并排序(非原地进行，需要缓冲区)

cottage technology — Tue, 16 Aug 2011 05:55:00 GMT

二路归并

如果内存充足，可以考虑使用非原地的归并排序获得更快的速度。非原地的归并排序算法空间复杂度为O(n)，时间复杂度O(nlogn)。它的核心是归并，下面看看归并的基本实现过程。

待排序序列：

52, 50, 50, 74, 61, 46, 84, 85, 73, 23, 94, 53, 97, 98, 65, 87, 29, 13, 61, 58, 19

可以把上面的无序序列分成四段并对各段进行插入排序，得到四个有序子序列：

46, 50, 50, 52, 61, 74, 84, 23, 73, 85, 94, 13, 29, 53, 65, 87, 97, 98, 19, 58, 61

两两归并成一段，得到两个有序子序列：

23, 46, 50, 50, 52, 61, 73, 74, 84, 85, 94, 13, 19, 29, 53, 58, 61, 65, 87, 97, 98

归并成一个有序序列，排序完成。

13, 19, 23, 29, 46, 50, 50, 52, 53, 58, 61, 61, 65, 73, 74, 84, 85, 87, 94, 97, 98

  1 template <typename InputIterator, typename OutputIterator, typename Compare>
  2 OutputIterator merge(InputIterator first1, InputIterator last1, InputIterator first2,
  3                      InputIterator last2, OutputIterator result, Compare cmp)
  4 {
  5   while(first1 != last1 && first2 != last2)
  6   {
  7     if(cmp(*first2, *first1))
  8     {
  9       *result = *first2;
10       ++first2;
11     }
12     else
13     {
14       *result = *first1;
15       ++first1;
16     }
17     ++result;
18   }
19   return copy(first2, last2, copy(first1, last1, result));
20 }
21
22 template <typename RandomIterator, typename Compare>
23 void merge_sort_loop(RandomIterator first, RandomIterator last,
24                      RandomIterator result, int step_size, Compare cmp)
25 {
26   int two_steps = step_size << 1;
27   while(last - first >= two_steps)
28   {
29     result = merge(first, first + step_size, first + step_size,
30                    first + two_steps, result, cmp);
31     first += two_steps;
32   }
33   if(last - first < step_size)
34     step_size = last - first;
35   merge(first, first + step_size, first + step_size, last, result, cmp);
36 }
37
38 template <typename RandomIterator, typename Compare>
39 void chunk_insertion(RandomIterator first, RandomIterator last,
40                      int chunk_size, Compare cmp)
41 {
42   while(last - first >= chunk_size)
43   {
44     insertion_sort(first, first + chunk_size, cmp);
45     first += chunk_size;
46   }
47   insertion_sort(first, last, cmp);
48 }
49
50 template <typename RandomIterator, typename Compare>
51 void merge_with_buffer(RandomIterator first, RandomIterator last,
52                        RandomIterator buffer, Compare cmp)
53 {
54   int len = last - first;
55   RandomIterator buffer_last = buffer + len;
56   int step_size = 7;
57   chunk_insertion(first, last, step_size, cmp);
58   while(step_size < len)
59   {
60     merge_sort_loop(first, last, buffer, step_size, cmp);
61     step_size <<= 1;
62     merge_sort_loop(buffer, buffer_last, first, step_size, cmp);
63     step_size <<= 1;
64   }
65 }
66
67 template <typename RandomIterator, typename Compare>
68 RandomIterator merge_backward(RandomIterator first1, RandomIterator last1,
69                               RandomIterator first2, RandomIterator last2,
70                               RandomIterator result, Compare cmp)
71 {
72   if(first1 == last1)
73     return copy_backward(first2, last2, result);
74   if(first2 == last2)
75     return copy_backward(first1, last1, result);
76   --last1, --last2;
77   while(true)
78     if(cmp(*last2, *last1))
79     {
80       *--result = *last1;
81       if(first1 == last1)
82         return copy_backward(first2, ++last2, result);
83       --last1;
84     }
85     else
86     {
87       *--result = *last2;
88       if(first2 == last2)
89         return copy_backward(first1, ++last1, result);
90       --last2;
91     }
92 }
93
94 template <typename RandomIterator, typename Compare>
95 inline void buffered_merge_sort_adaptive(RandomIterator first, RandomIterator last,
96                                          RandomIterator buffer, Compare cmp)
97 {
98   RandomIterator middle = first + ((last - first + 1) >> 1);
99   merge_with_buffer(first, middle, buffer, cmp);
100   merge_with_buffer(middle, last, buffer, cmp);
101   int len1 = middle - first, len2 = last - middle;
102   if(len1 <= len2)
103   {
104     RandomIterator buffer_end = copy(first, middle, buffer);
105     merge(buffer, buffer_end, middle, last, first, cmp);
106   }
107   else
108   {
109     RandomIterator buffer_end = copy(middle, last, buffer);
110     merge_backward(first, middle, buffer, buffer_end, last, cmp);
111   }
112 }
113
114 template <typename RandomIterator, typename T, typename Compare>
115 inline void buffered_merge_sort_aux(RandomIterator first, RandomIterator last, Compare cmp, T)
116 {
117   T* buf = new(std::nothrow)T[last - first];
118   if(0 != buf)
119     buffered_merge_sort_adaptive(first, last, buf, cmp);
120   delete [] buf;
121 }
122
123 template <typename RandomIterator, typename Compare>
124 inline void buffered_merge_sort(RandomIterator first, RandomIterator last, Compare cmp)
125 {
126  if(last - first > 1)
127     buffered_merge_sort_aux(first, last, cmp, *first);
128 }

以上代码实现中用到了直接插入排序和拷贝算法，直接插入排序见本主页快排的介绍，拷贝算法见标准库，本主页暂无介绍(以后也许会加上)。

cottage technology 2011-08-16 13:55 发表评论

原地归并排序

cottage technology — Tue, 16 Aug 2011 05:49:00 GMT

原地归并排序的时间复杂度为O(nlog²n)，空间复杂度为O(logn)，相对于传统的非原地归并排序(时间复杂度O(nlogn)，空间复杂度O(n))而言，十分节约内存，但排序速度稍慢。在内存紧张且需要排序稳定的场合，原地稳定排序可以发挥其特长。

在介绍原地稳定排序的原理之前，需要先了解两个基本算法，旋转和二分查找。

a) 旋转

旋转又称循环移动，假设有这样一个序列：e₀, e₁, …, e_i-1, e_i, e_i+1, …, e_n-1, e_n。现在我们需要把它向左循环移动i个位置变成：e_i, e_i+1, …, e_n-1, e_n,e₀, e₁, …, e_i-1。为了尽可能的节约内存和保证较快的速度，我们可以在时间复杂度O(n)，空间复杂度O(1)的情况下达到目的。一种解决方案如下：

把原始序列看成两个子序列：e₀, e₁, …, e_i-1和e_i, e_i+1, …, e_n-1, e_n

把这两个子序列分别逆序得：e_i-1, …, e₁, e₀和e_n,e_n-1, …, e_i+1, e_i

也就是得到了这样一个序列：e_i-1, …, e₁, e₀, e_n,e_n-1, …, e_i+1, e_i

再把上面的序列整体逆序得：e_i, e_i+1, …, e_n-1, e_n,e₀, e₁, …, e_i-1

以上旋转过程的时间复杂度为O(n/2) + O(n/2) + O(n) = O(2n) = O(n)，逆序时仅需要一个元素的辅助空间，空间复杂度O(1)。

b) 二分查找

二分查找比较简单，在前面的二分插入排序算法里使用了二分查找获得上界(假设序列升序，序列中最后一个相同值的下一个位置或没有相同值时刚好比它大的那一个元素位置)。这里看看怎么使用二分查找获得下界(假设序列升序，序列中第一个相同值的位置或没有相同值时刚好比它小的那一个元素位置)。

下面以整数为例，看看怎么获得下界。

假设在一个有序序列10, 12, 12, 13, 13, 13 14, 14, 17, 17, 18, 19, 19中查找16。

该序列长度为13，找到中间值14，它比16小，查找的子序列长度降为6，在子序列[14, 19]中继续查找。找到中值18，它比16大，查找的子序列长度降为3，在子序列[14, 17]中继续查找。找到中值17，它比16大，查找的子序列长度降为1，在子序列[14, 14]中继续查找，找到14，它比16大，查找的子序列长度降为0，查找失败。返回14后面的元素位置，即第一个17的位置。

使用二分查找的前提条件是待查序列必须有序。无论查找上界还是下界，以及是否查找成功，二分查找的时间复杂度为O(logn)。或许有些读者在有的书上见过有的二分查找算法既不获得确定的上界也不获得确定的下界，可惜这样的二分查找算法除了考试以外似乎没有多大实用价值。

c) 原地稳定排序的原理

以整数为例，假设有一个需要稳定排序的无序序列：

52, 50, 50, 74, 61, 46, 84, 85, 73, 23, 94, 53, 97, 98, 65, 87, 29

首先需要把较长的序列使用插入排序分成多个有序的短序列。上面的序列可以分成两个子序列，然后分别进行插入排序，得到：

46, 50, 50, 52, 61, 74, 84, 85, 23, 29, 53, 65, 73, 87, 94, 97, 98

在前段[46, 85]查找后段[23, 98]的中值得73，返回74，这样后段[23, 98]的前部分[23, 65]中的任何元素比前段[46, 85]的后部分[74, 85]任何元素都小，旋转这两部分，得到：

46, 50, 50, 52, 61, 23, 29, 53, 65, 74, 84, 85, 73, 87, 94, 97, 98

在[23, 85]中查找[46, 61]的中值50，返回53，旋转[50, 61]和[23, 29]，得到：

46, 50, 23, 29, 50, 52, 61, 53, 65, 74, 84, 85, 73, 87, 94, 97, 98

在[46, 50]之间查找29，返回46，旋转得到：

23, 46, 50, 29, 50, 52, 61, 53, 65, 74, 84, 85, 73, 87, 94, 97, 98

在[29, 29]之间查找50，返回50，旋转得到：

23, 29, 46, 50, 50, 52, 61, 53, 65, 74, 84, 85, 73, 87, 94, 97, 98

在[53, 65]之间查找52，返回53，旋转，得到：

23, 29, 46, 50, 50, 52, 53, 61, 65, 74, 84, 85, 73, 87, 94, 97, 98

在[74, 85]之间查找94，返回73，在[73, 87]之间查找84，返回87，旋转得到：

23, 29, 46, 50, 50, 52, 53, 61, 65, 74, 73, 84, 85, 87, 94, 97, 98

交换73 和74，最终排序完毕。

23, 29, 46, 50, 50, 52, 53, 61, 65, 73, 74, 84, 85, 87, 94, 97, 98

1 // cycly moving left middle - first vacancies
2 template<typename RandomIterator>
3 void rotate(RandomIterator first, RandomIterator middle, RandomIterator last)
4 {
5  if(first == middle || last  == middle) return;
6   reverse(first,  middle);
7  reverse(middle, last);
8   while(first != middle && middle != last)
9  {
10    swap(*first, *--last);
11    ++first;
12  }
13  if(first == middle)
14    reverse(middle, last);
15  else
16    reverse(first, middle);
17 }
18
19 // find the lower bound, the returned value is the address of that bound
20 template <typename RandomIterator, typename T, typename Compare>
21 RandomIterator lower_bound(RandomIterator first, RandomIterator last,
22                             const T& value, Compare cmp)
23 {
24   int len = last - first, half;
25   RandomIterator middle;
26   while(len > 0)
27   {
28     half = len >> 1;
29     middle = first + half;
30     if(cmp(*middle, value))
31     {
32       first = middle;
33       ++first;
34       len = len - half - 1;
35     }
36     else
37       len = half;
38   }
39   return first;
40 }
41
42 // find the upper bound, the returned value is the address of that bound
43 template <typename RandomIterator, typename T, typename Compare>
44 RandomIterator upper_bound(RandomIterator first, RandomIterator last,
45                             const T& value, Compare cmp)
46 {
47   int len = last - first, half;
48   RandomIterator middle;
49
50   while(len > 0)
51   {
52     half = len >> 1;
53     middle = first + half;
54     if(cmp(value, *middle))
55       len = half;
56     else
57     {
58       first = middle;
59       ++first;
60       len = len - half - 1;
61     }
62   }
63   return first;
64 }

1 // no heap memory needed to merge two sequence
2 template <typename RandomIterator, typename Compare>
3 void merge_without_buffer(RandomIterator first, RandomIterator middle,
4                           RandomIterator last, int len1, int len2, Compare cmp)
5 {
6   if(0 == len1 || 0 == len2) return;
7   if(2 == len1 + len2)
8   {
9     if(cmp(*middle, *first)) swap(*first, *middle);
10     return;
11   }
12   RandomIterator first_cut = first, second_cut = middle;
13   int len11 = 0, len22 = 0;
14   if(len1 > len2)
15   {
16     len11 = len1 >> 1;
17     first_cut += len11;
18     second_cut = lower_bound(middle, last, *first_cut, cmp);
19     len22 = second_cut - middle;
20   }
21   else
22   {
23     len22 = len2 >> 1;
24     second_cut += len22;
25     first_cut = upper_bound(first, middle, *second_cut, cmp);
26     len11 = first_cut - first;
27   }
28   rotate(first_cut, middle, second_cut);
29   RandomIterator new_middle = first_cut + (second_cut - middle);
30   merge_without_buffer(first, first_cut, new_middle, len11, len22, cmp);
31   merge_without_buffer(new_middle, second_cut, last, len1 - len11, len2 - len22, cmp);
32 }
33
34 // inplace merge sort
35 template <typename RandomIterator, typename Compare>
36 void inplace_merge_sort(RandomIterator first, RandomIterator last, Compare cmp)
37 {
38   if(last - first < 17)
39   {
40     insertion_sort(first, last, cmp);
41     return;
42   }
43   RandomIterator middle = first + ((last - first) >> 1);
44   inplace_merge_sort(first, middle, cmp);
45   inplace_merge_sort(middle, last, cmp);
46   merge_without_buffer(first, middle, last, middle - first, last - middle, cmp);
47 }

以上代码实现中用到了直接插入排序，该部分内容见本主页的快排介绍。

cottage technology 2011-08-16 13:49 发表评论

选择排序

cottage technology — Tue, 16 Aug 2011 05:41:00 GMT

选择排序

假设一个待排序的序列中有 n 个元素，从这 n 个元素中选出一个最小(大)的元素放在第 0 个元素的位置，再从余下的 n-1 元素中选出一个次小(大)的元素放在第 1 个元素的位置，继续这个过程...，经过 n-1 次选择和交换，整个序列成为一个升(降)序序列，这就是选择排序的排序过程。无论最好还是最坏情况，选择排序的时间复杂度始终为O(n²)，空间复杂度为O(1)，选择排序并不稳定。

以一个随机整数序列为例，选择排序过程见下表。

49 52 53 39 86 97 21 85 64 31 80 65 73 85 42 14	待排序序列
14 52 53 39 86 97 21 85 64 31 80 65 73 85 42 49	49 与14 交换后
14 21 53 39 86 97 52 85 64 31 80 65 73 85 42 49	52 与21 交换后
14 21 31 39 86 97 52 85 64 53 80 65 73 85 42 49	53 与31 交换后
14 21 31 39 86 97 52 85 64 53 80 65 73 85 42 49	39 无需交换
14 21 31 39 42 97 52 85 64 53 80 65 73 85 86 49	86 与42 交换后
14 21 31 39 42 49 52 85 64 53 80 65 73 85 86 97	97 与49 交换后
14 21 31 39 42 49 52 85 64 53 80 65 73 85 86 97	52 无需交换
14 21 31 39 42 49 52 53 64 85 80 65 73 85 86 97	85 与53 交换后
14 21 31 39 42 49 52 53 64 85 80 65 73 85 86 97	64 无需交换
14 21 31 39 42 49 52 53 64 65 80 85 73 85 86 97	85 与65 交换后
14 21 31 39 42 49 52 53 64 65 73 85 80 85 86 97	80 与73 交换后
14 21 31 39 42 49 52 53 64 65 73 80 85 85 86 97	85 与80 交换后
14 21 31 39 42 49 52 53 64 65 73 80 85 85 86 97	85 无需交换
14 21 31 39 42 49 52 53 64 65 73 80 85 85 86 97	85 无需交换
14 21 31 39 42 49 52 53 64 65 73 80 85 85 86 97	86 无需交换
14 21 31 39 42 49 52 53 64 65 73 80 85 85 86 97	排序完毕

1 template <typename ForwardIterator, typename Compare>
2 ForwardIterator selection(ForwardIterator first, ForwardIterator last, Compare cmp)
3 {
4   ForwardIterator next = first;
5   for(++first; first != last; ++first)
6     if(cmp(*first, *next))
7       next = first;
8   return next;
9 }
10
11 template <typename ForwardIterator, typename Compare>
12 void selection_sort(ForwardIterator first, ForwardIterator last, Compare cmp)
13 {
14   if(first == last || first + 1 == last) return;
15   for(ForwardIterator current = first; first != last; ++first, ++current)
16   {
17     ForwardIterator it = selection(first, last, cmp);
18       if(it != current)
19         swap(*current, *it); // 用于交换两个元素的swap函数实现见本主页快排的介绍
20   }
21 }

cottage technology 2011-08-16 13:41 发表评论

冒泡排序

cottage technology — Tue, 16 Aug 2011 05:39:00 GMT

冒泡排序

水底的气泡是逐渐上浮的，而不是一下子就到达水面。冒泡排序与之类似，当用冒泡排序算法对一个无序序列升序排序时，后面较小的元素与前面较大的元素逐个交换位置，直到无元素交换为止，则整个序列成为一个有序序列。

冒泡排序的时间复杂度为O(n²)，空间复杂度为O(1)，当原始序列已经有序，则冒泡排序的时间复杂度为O(n)。当待排序序列基本有序时，使用冒泡排序速度往往比较快。

以一个整数序列的为例，冒泡排序过程见下表。

90 29 11 51 38 38 27 95 18 24 52 35 77 93 40 75	待排序序列
11 90 29 18 51 38 38 27 95 24 35 52 40 77 93 75	1趟后的结果
11 18 90 29 24 51 38 38 27 95 35 40 52 75 77 93	2趟后的结果
11 18 24 90 29 27 51 38 38 35 95 40 52 75 77 93	3 趟后的结果
11 18 24 27 90 29 35 51 38 38 40 95 52 75 77 93	4趟后的结果
11 18 24 27 29 90 35 38 51 38 40 52 95 75 77 93	5趟后的结果
11 18 24 27 29 35 90 38 38 51 40 52 75 95 77 93	6趟后的结果
11 18 24 27 29 35 38 90 38 40 51 52 75 77 95 93	7趟后的结果
11 18 24 27 29 35 38 38 90 40 51 52 75 77 93 95	8趟后的结果
11 18 24 27 29 35 38 38 40 90 51 52 75 77 93 95	9趟后的结果
11 18 24 27 29 35 38 38 40 51 90 52 75 77 93 95	10趟后的结果
11 18 24 27 29 35 38 38 40 51 52 90 75 77 93 95	11趟后的结果
11 18 24 27 29 35 38 38 40 51 52 75 90 77 93 95	12趟后的结果
11 18 24 27 29 35 38 38 40 51 52 75 77 90 93 95	13趟后的结果
11 18 24 27 29 35 38 38 40 51 52 75 77 90 93 95	排序完毕

1 template <typename RandomIterator, typename Compare>
2 void bubble_sort(RandomIterator first, RandomIterator last, Compare cmp)
3 {
4   if(first == last || first + 1 == last) return;
5   for(bool exchanged = true; exchanged && first != last; ++first)
6   {
7     exchanged = false;
8     for(RandomIterator current = last - 1; current != first; --current)
9     {
10       RandomIterator prev = current - 1;
11       if(cmp(*current, *prev))
12       {
13          swap(*current, *prev); // 本主页介绍的快排里有swap实现，用于交换两个元素
14          exchanged = true;
15       }
16     }
17   }
18 }

cottage technology 2011-08-16 13:39 发表评论

基数排序

cottage technology — Tue, 16 Aug 2011 05:31:00 GMT

基数排序有时也被称作卡片排序，也是一种时间复杂度为O(n)的排序。为了给一个序列排序，基数排序需要大约相当的辅助空间(通常使用队列)，可见空间复杂度为O(n)。假设有一个无序序列含有n 个整数，整数的基数是k，最大有d 位(例如：对于十进制整数而言， k = 10，可能的值是 0, 1, 2, ..., 8, 9，在 32 位系统上 d≤10，在64 位系统上 d≤20)，则基数排序的时间复杂度为O(d(n+k)) = O(n)。当对整数排序时，使用10进制虽然比较容易理解，但是速度慢(因为为了得到各位数字需要做除法和取模等操作)，为了尽可能的减小时间开销，通常使用2 的指数次幂进制(例如：2, 4, 8, ..., 2^r，r为2进制的幂)，这样可以借助位移运算减小耗费CPU 指令数，提升运行速度。对于b位(在PC机上， b通常为32或64)的整数而言， d = b/r， k = 2r，于是时间复杂度O(d(n+k)) = O(b/r(n+2r))，理论上，当b/r(n+2r)最小时，速度应该最快。

以一个随机整数序列为例，基数排序的过程见下表。

178 207 982 510 477 295 963 095 274 614 810 579 700 618 301 766	待排序序序列
510 810 700 301 982 963 274 614 295 095 766 207 477 178 618 579	个位排序结果
700 301 207 510 810 614 618 963 766 274 477 178 579 982 295 095	十位排序结果
095 178 207 274 295 301 477 510 579 614 618 700 766 810 963 982	百位排序结果

以上是以基数为10进行排序的例子，实现时应该使用2的指数为基数，从而避免除法和取模而采用位运算来获取较快的处理速度。
以下基数排序使用256个队列，对int类型的序列从小到大排序，但是还是比快排慢一些，其实用多少队列都比不上快排快。即使不用动态队列，都用静态队列，还是比快排慢。根本原因在于这种基数排序的思想跟现代CPU架构背道而驰，非常的不CPU cache friendly.从一个队列换到另一队列，然后再换回来，这种换来换去的机制导致CPU cache line不停的被重新填充，毕竟内存的延迟和访问速度比CPU cache要慢的多，大部分时间都耗费在这里。结果这种看上去很理想的所谓的O(n)算法，只能徒有虚名。相信这些是那些纯搞理论的算法专家和数学家永远都想不明白的！其实还不止基数排序如此，类似行为的计数排序和桶排序也快不起来，尽管它们的时间复杂度都是一色的O(n)。

1 #include <queue> // use standard queue
2 // non-portable implementation for LSD radix sort, for type int, 32 bit system
3 template <typename ForwardIterator>
4 void radix_sort(ForwardIterator first, ForwardIterator last)
5 {
6   // R: radix, K: k base, M: mask, B: ? bit system
7   const unsigned R = 8, K = 1 << R, M = K - 1, B = 32;
8   std::queue<int> q[K];
9   for(unsigned i = 0; i < B; i += R)
10   {
11     for(ForwardIterator dit = first; dit != last; ++dit)
12     q[(*dit >> i) & M].push(*dit);
13     ForwardIterator cit = first;
14     for(unsigned j = 0; j < K; ++j)
15     while(!q[j].empty())
16     {
17       *cit++ = q[j].front();
18       q[j].pop();
19     }
20   }
21 }

cottage technology 2011-08-16 13:31 发表评论

希尔排序

cottage technology — Tue, 16 Aug 2011 05:16:00 GMT

希尔排序，以其发明者Donald Shell的名字来命名，是最早突破时间复杂度屏障O(n²)的算法之一。希尔排序是直接插入排序的变种，它不是一种稳定的排序算法。希尔排序的原理是首先比较远距离的元素，然后递减比较距离，最终比较相邻元素。由于采用这种比较方式来排序，希尔排序有时候也被称为递减增量排序。

增量序列的不同将直接影响希尔排序的速度，因此，不方便给出希尔排序理论上的时间复杂度。 Hibbard采用的增量序列为：1, 3, 7, ..., 2k– 1，(k = 1, 2, ...)，最坏情况下的时间复杂度为O(n^3/2)，Sedgewick 建议了几种增量序列，最坏情况下的时间复杂度为O(n^4/3)，平均时间复杂度O(n^7/6)，Empirical研究发现它们的实际性能要比Hibbard的增量序列好一些，其中最好的是1, 5, 19, 41, 109, . . .，也就是说增量值要么为9*4ⁱ- 9 *2ⁱ + 1 要么为4ⁱ - 3 *2ⁱ + 1，(i = 0, 1, 2, ...)。希尔排序的空间复杂度依赖于具体实现。

以随机整数序列为例，采用Hibbard 增量序列的希尔排序过程如下表。

78 17 98 91 45 95 96 95 74 14 10 79 70 19 30 66	待排序序列
78 17 14 10 45 70 19 30 66 98 91 79 95 96 95 74	增量为7的排序结果
78 10 14 17 19 30 45 70 66 74 91 79 95 96 95 98	增量为2的排序结果
10 14 17 19 30 45 66 70 74 78 79 91 95 95 96 98	增量为1的排序结果

1 template <typename RandomIterator, typename T, typename Compare>
2 inline void shell_linear_insert(RandomIterator first, RandomIterator last,
3                                 int incr, T value, Compare cmp)
4 {
5  for(; first > last; first -= incr)
6    if(cmp(value, *(first - incr)))
7      *first = *(first - incr);
8  else
9    break;
10  *first = value;
11 }
12
13 // for Hibbard sequence： 1, 3, 7, 15, 31, 63, 127,
14 // worst cast time complexity O(n^(3/2))
15 template <typename RandomIterator, typename Compare>
16 inline void shell_sort_H(RandomIterator first, RandomIterator last, Compare cmp)
17 {
18   if(last - first < 2)
19     return;
20   for(int incr = ((last - first) >> 1) - 1; incr > 1; incr = (incr >> 1) - 1)
21     for(RandomIterator i = first + (incr + 1); i < last; ++i)
22       shell_linear_insert(i, first + incr, incr, *i, cmp);
23   final_insertion_sort(first, last, cmp); // the last incremental value must be 1
24 }
25
26 // for Sedgewick and Empirical sequence： 1, 5, 19, 41, 109, 209,
27 // average time complexity O(n^(7/6)), worst case O(n^(4/3))
28 template <typename RandomIterator, typename Compare>
29 inline void shell_sort_S(RandomIterator first, RandomIterator last, Compare cmp)
30 {
31   long len = static_cast<int>(last - first);
32   if(len < 2)
33     return;
34 //  long arr[28];
35 //  for(long i = 0; i < 14; ++i)
36 //  {
37 //    arr[i*2] = 9*((1<<(2*i)) - (1<38 //    arr[i*2 + 1] = ((1<<(2*(i+2))) - 3*(1<<(i+2))) + 1;
39 //  }
40   long arr[28] =
41   { 5, 19, 41, 109, 209, 505, 929, 2161, 3905, 8929, 16001, 36289, 64769,
42     146305, 260609, 587521, 1045505, 2354689, 4188161,  9427969, 16764929,
43     37730305, 67084289, 150958081, 268386305, 603906049, 1073643521 };
44
45   for(long i = 27; 0 < i; --i)
46   {
47     if(len < arr[i])
48       continue;
49     for(RandomIterator it = first + (arr[i] + 1); it < last; ++it)
50       shell_linear_insert(it, first + arr[i], arr[i], *it, cmp);
51   }
52   final_insertion_sort(first, last, cmp); // the last incremental value must be 1
53 }

这里介绍的希尔排序比堆排序的速度要快一些。

cottage technology 2011-08-16 13:16 发表评论

快速排序

cottage technology — Tue, 16 Aug 2011 05:05:00 GMT

摘要: 我觉得在一般场合，单线程下快速排序是最快的，尽管它的时间复杂度为O(nlogn)，它甚至比时间复杂度为O(n)的基数排序、桶排序和计数排序都快一些。如果对字符窜排序，即使快排的仅仅是字符窜的指针(避免拷贝字符窜)，burst sort还是比快速排序快一些。快速排序的版本很多，常见的有C库函数qsort，C++STL中的sort(多个版本)，还是大学书上的臃肿快速排序的实现。这里介绍SGI STL版... 阅读全文

cottage technology 2011-08-16 13:05 发表评论

蜗牛排序--我见过的最慢的排序

cottage technology — Tue, 16 Aug 2011 04:35:00 GMT

鄙人目光短浅，以为见到的这个时间复杂度为O(n!)的排序是最慢的。如果不是，请举出更慢的例子:)

原理是枚举所有排列组合，直到找到一个合适的有序序列，取名蜗牛排序。

使用模板来实现。

1 template <typename T>
2 struct greater
3 {
4   bool operator()(const T& x, const T& y) const { return y < x; }
5 };
6
7 template <typename T>
8 struct less
9 {
10   bool operator()(const T& x, const T& y) const { return x < y; }
11 };
12
13 template <typename T>
14 inline void swap(T& x, T& y)
15 {
16     const T tmp(x);
17     x = y;
18     y = tmp;
19 }
20
21 // reverse a sequence in the range [first, last)
22 template <typename BidirectionalIter>
23 void reverse(BidirectionalIter first, BidirectionalIter last)
24 {
25   while(true)
26     if(first == last || first == --last)
27       return;
28     else
29       swap(*first++, *last);
30 }
31 // find the next possible permutation
32 template <typename BidirectionalIter, typename Compare>
33 bool next_permutation(BidirectionalIter first, BidirectionalIter last,
34                      Compare cmp)
35 {
36   if(first == last)
37     return false;
38   BidirectionalIter i = first;
39   ++i;
40   if(i == last)
41     return false;
42   i = last;
43   --i;
44
45   for(;;)
46   {
47     BidirectionalIter ii = i;
48     --i;
49     if(cmp(*i, *ii))
50     {
51       BidirectionalIter j = last;
52       while(!cmp(*i, *--j));
53       swap(*i, *j);
54       reverse(ii, last);
55       return true;
56     }
57     if(i == first)
58     {
59       reverse(first, last);
60       return false;
61     }
62   }
63 }
64
65 template <typename BidirectionalIterator, typename Compare>
66 void snail_sort(BidirectionalIterator first, BidirectionalIterator last, Compare cmp)
67 {
68   while(next_permutation(first, last, cmp));
69 }
70
71 #include <iostream>
72
73 int main()
74 {
75     const int SZ = 12;
76     int arr[SZ] = { 5, 3, 9, 7, 4, 6, 5, 0, 2, 1, 3, 8 };
77     snail_sort(arr, arr + SZ, greater<int>());
78     for(int i =0 ; i < SZ; ++i)
79         std::cout << arr[i] << ' ';
80 }

cottage technology 2011-08-16 12:35 发表评论

boost下circular_buffer的速度问题

cottage technology — Wed, 14 Jul 2010 06:24:00 GMT

boost::circular_buffer is on the way…
很多时候我们会用到缓冲区或者类似缓冲区的数据结构，如果能事先估计出数据量多大，并尽可能的节约内存，可以使用环形(逻辑上)结构的缓冲区。boost已经有了一个这样的缓冲区,circular_buffer，由Jan Gaspar设计实现，它的数据结构跟传统的静态环形双端队列(很多数据结构书上有相关介绍)一样，速度比传统的静态环形双端队列快得多。只不过我对它的表现还是不太满意，觉得它还不够快。为此，我设计了一个简单的静态环形双端队列，它的数据结构与circular_buffer没什么两样，没有编写迭代器，也没有给出太多公有成员函数，只不过它的速度要快一些。下面先来看看它的逻辑结构和物理结构图。

图(a)是静态环形双端队列的逻辑结构图，图(b)是对应的物理结构图。静态环形双端队列有四个指针，指针start指向分配内存块的起始地址处，finish指向该快内存的末尾，first和last是两个自由指针，可以在[start, finish)区间自由移动，在队头添加一个元素时，first就向左移动一个元素的位置，在队头删除一个元素时，first就向右移动一个元素的位置，在队尾添加一个元素时，last向右移动一个元素的位置，在队尾删除一个元素时，last向左移动一个元素的位置。
开始时，指针first和last都指向同一个位置(我们的设计是指向[start, finish)区间的正中间)，当环形双端队列满时last和first之间还剩一个元素的空位(如果不留空位怎么区分队满还是队空？)。比较难处理的问题是指针first和last移动到队头和队尾怎么办，因为在物理上(在内存中存放元素时)一块存储空间的始末永远都不会构成一个环，环行结构只能在逻辑上出现。
解决此问题的一种方法是取模，例如：first向左移动一个元素的位置：first = (first - 1 + cap) % cap; last向右移动一个元素的位置：last = (last + 1) % cap;其中first和last都是整形变量，cap是所开辟空间的大小，这就能很好的解决了环形移动指针的问题。这种传统的算法形式上虽然比较简洁，但是速度慢，因为取模需要做除法运算，以现在的CPU架构，做一次除法相当于做多次加法。
另外一种解决方案更容易理解，例如：当指针first移动到最左端时就让它指向右端，移动到最右端时就让它指向左端，当指针last移动到最右端时就让它指向左端，移动到最左端时就让它指向右端，这种算法速度快，因为做一次判断需要的指令数跟做一次加法需要的指令数相差不多。
为了能够区分何时队满何时队空，环形队列应该至少富裕一个元素的空间，也就是说我们将用last + 1 == first表示队满，用last == first表示队空。
为了看看环形缓冲区的性能怎样，做了一个简单的测试，测试用系统配置如下。
操作系统: Windows XP Professional(内核版本5.1.2600), 英文版
CPU: Intel(R) PIII 1.13MHz, Moblie
编译器: Code::Blocks(svn5616) + MinGW(g++4.4.0)
测试用数据: 32位的随机数(由boost::mt19937产生)
测试数据量: 1千万，测试时间单位: 毫秒
测试方法: 生成Release版(-O3)，运行5次取平均值，分别测试成员函数push_back+pop_front，push_back+pop_back，push_front+pop_back，push_front+pop_front耗费的时间。
测试结果见下图。

由上图(a)、(b)、(c)、(d)容易看出，boost::circular_buffer比普通的静态双端环形队列快得多，但比静态双端环形队列circular_deque慢很多。
传统的环形队列速度慢的主要原因是移动指针时需要取模，这很糟糕，因为取模需要做除法，计算机做一次乘法或除法运算比做一次加法耗费的CPU周期多很多，由于每移动一次指针都需要做一次取模运算，从而导致整体运行速度大大下降。
boost 1.42中的circular_buffer中成员函数push_front, push_back, pop_front, pop_back不够快的主要原因是有太多的琐碎操作，这些琐碎的操作会消耗很多CPU周期，作者Jan Gaspar为何要这样实现，本人不理解，我觉得没有必要那样做(请参考boost::circular_buffer的源代码)。
如果您想看看各自的实现，circular_deque和circular_deque_traditional的源代码可以从下面地址下载
http://www.cppblog.com/Files/Chipset/circular_deque.zip

cottage technology 2010-07-14 14:24 发表评论

测试CPU品牌和当前工作频率

cottage technology — Fri, 20 Feb 2009 06:58:00 GMT

这里有一段非常简单的代码，取自网络，我稍加修改，贴在这里。用来检查CPU的生产商和品牌，以及当前工作频率，如果是台式机CPU，频率应该恒定，但是移动版本的CPU，频率不停地在变。以下代码用Visual C++编译，因为内嵌一点汇编，造成移植性变差(例如：GCC汇编跟AT&T汇编语法类似，但是MS汇编跟Intel汇编语法类似)，以下代码如果希望在MinGW(GCC)下编译，需要修改那点内嵌的汇编。

#include "stdafx.h"
#ifndef CPUID_HPP_
#define CPUID_HPP_

#include <string>
#include <cstring>
#include <iostream>
#include <windows.h>

typedef unsigned long DWORD;
typedef __int64 LONGLONG;

class CPUID
{
public:
  CPUID() : m_eax(0), m_ebx(0), m_ecx(0), m_edx(0){}
  std::string vendor(); //哪个厂商出的？Intel, AMD, VIA ?
  std::string name();   //这是CPU的整体描述
  LONGLONG frequency(DWORD stime = 1000);//CPU的当前工作频率

private:
  void  Executecpuid(DWORD veax);
  LONGLONG cycles() const
  {
    DWORD h, l;         //不能直接读取，用变量过渡一下
    __asm
    {
      rdtsc             //把当前CPU周期读入寄存器
      mov l, eax
      mov h, edx
    }
    LONGLONG high = h, low = l;
    return high << 32 | low;
  }

  DWORD  m_eax;
  DWORD  m_ebx;
  DWORD  m_ecx;
  DWORD  m_edx;
};

void CPUID::Executecpuid(DWORD veax)
{
  DWORD deax;
  DWORD debx;
  DWORD decx;
  DWORD dedx;

  __asm
  {
    mov eax, veax
    cpuid
    mov deax, eax
    mov debx, ebx
    mov decx, ecx
    mov dedx, edx
  }

  m_eax = deax;
  m_ebx = debx;
  m_ecx = decx;
  m_edx = dedx;
}

std::string CPUID::vendor()
{
  const DWORD S = sizeof(DWORD);
  char cVID[S*3+1];
  std::memset(cVID, 0, sizeof(cVID));
  Executecpuid(0);
  std::memcpy(cVID+S*0, &m_ebx, S);
  std::memcpy(cVID+S*1, &m_edx, S);
  std::memcpy(cVID+S*2, &m_ecx, S);

  return std::string(cVID);
}

std::string CPUID::name()
{
  const DWORD vendorID = 0x80000002;
  const DWORD S = sizeof(DWORD);
  char cvendor[S*4*3+1];
  std::memset(cvendor, 0, sizeof(cvendor));

  for(DWORD i = 0; i < 3; i++)
  {
    Executecpuid(vendorID + i);
    // 每次执行结束后，保存四个寄存器里的ascii码到数组
    std::memcpy(cvendor + i*S*4 + S*0, &m_eax, S);
    std::memcpy(cvendor + i*S*4 + S*1, &m_ebx, S);
    std::memcpy(cvendor + i*S*4 + S*2, &m_ecx, S);
    std::memcpy(cvendor + i*S*4 + S*3, &m_edx, S);
  }
  return std::string(cvendor);
}

LONGLONG CPUID::frequency(DWORD stime)
{
  HANDLE hp = GetCurrentProcess();
  HANDLE ht = GetCurrentThread();

  DWORD pc = GetPriorityClass(hp);
  DWORD tp = GetThreadPriority(ht);

  BOOL flag1 = FALSE, flag2 = FALSE;

  flag1 = SetPriorityClass(hp, REALTIME_PRIORITY_CLASS); //优先级设置最高
  flag2 = SetThreadPriority(ht, THREAD_PRIORITY_HIGHEST);//优先级设置最高

  //由于CPU本身时间波动较大，因此时间从系统读取，这样比较平均
//周期除以时间就是工作频率，即单位时间内的周期
  Sleep(stime);
  LARGE_INTEGER fq, st, ed;
  QueryPerformanceFrequency(&fq);
  QueryPerformanceCounter(&st);
  LONGLONG start = cycles();
  Sleep(stime);
  QueryPerformanceCounter(&ed);
  LONGLONG end = cycles();
  if(flag1)
    SetPriorityClass(hp, pc);
  if(flag2)
    SetThreadPriority(ht, tp);

  CloseHandle(hp);
  CloseHandle(ht);

  return (end - start) * fq.QuadPart / (ed.QuadPart - st.QuadPart);
}

#endif

#include <cstdio>
#include <cstdlib>

int main()
{
  CPUID cpu;
  std::printf("Vendor: %s\n", cpu.vendor().c_str());
  std::printf("Full name: %s\n", cpu.name().c_str());
  const unsigned TIMES = 3;
  std::printf("Frequency(testing %d times): ", TIMES);
  const double UNIT = 1000.0;
  for(unsigned i = 0; i < TIMES; ++i)
  {
    double fre = cpu.frequency() / UNIT; // 假设CPU主频高于1000Hz
    if(fre > UNIT)
      fre /= UNIT;
    std::printf("%f%s ", fre, (fre > 10.0 ? "MHz" : "GHz"));
  }
  printf("\n");
  std::system("PAUSE");
  return 0;
}

cottage technology 2009-02-20 14:58 发表评论

产生伪随机数常用的两种算法

cottage technology — Sat, 07 Feb 2009 13:15:00 GMT

摘要: 我们讲的随机数其实暗指伪随机数。提及随机数，不少朋友可能想到C语言的库函数rand()，rand()随机性太差，速度太慢。古老的LCG(linear congruential generator)代表了最好的伪随机数产生器算法。主要原因是容易理解，容易实现，而且速度快。这种算法数学上基于X(n+1) = (a * X(n) + c) % m这样的公式，其中：模m, m > 0系数a, 0 &... 阅读全文

cottage technology 2009-02-07 21:15 发表评论

大数n的阶乘

cottage technology — Thu, 01 Jan 2009 10:50:00 GMT

1 /***************************************************************************************************/
2 /*  Copyright (C) 2008  Chipset
3 /*
4 /*  This program is free software: you can redistribute it and/or modify
5 /*  it under the terms of the GNU Affero General Public License as
6 /*  published by the Free Software Foundation, either version 3 of the
7 /*  License, or (at your option) any later version.
8 /*
9 /*  but WITHOUT ANY WARRANTY; without even the implied warranty of
10 /*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 /*  GNU Affero General Public License for more details.
12 /*
13 /*  You should have received a copy of the GNU Affero General Public License
14 /*  along with this program. If not, see <http://www.gnu.org/licenses/>.
15 /****************************************************************************************************/
16
17 #include <iostream>
18 #include <vector>
19 void cal_factorial(std::vector<int>& a, int n)
20 {
21   int carry = 0;
22   a.push_back(1);
23   int tmp;
24
25   for(int i = 2; i <= n; ++i)
26   {
27     for(int j = 0; j < a.size(); ++j)
28     {
29       tmp = a[j] * i + carry;
30       a[j] = tmp % 10;
31       carry = tmp / 10;
32     }
33     while(carry)
34     {
35       a.push_back(carry % 10);
36       carry /= 10;
37     }
38   }
39 }
40
41 void show_factorial(const std::vector<int>& v, int n)
42 {
43   for(int i = v.size() - 1; i > -1; --i)
44   std::cout << v[i];
45 }
46
47 //测试
48 #include <windows.h>
49 int main()
50 {
51   int n;
52   do{
53     std::cout << "Input a number(greater than 0) for factorial:\n";
54     std::cin >> n;
55     if(n < 0)
56     std::cout << "Must be greater than 0\n";
57   }while(n < 0);
58   Sleep(1000);
59   std::vector<int> v;
60   DWORD time = GetTickCount();
61   cal_factorial(v, n);
62   time = GetTickCount() - time;
63   std::cout << n << "! is as long as " << v.size() << " bit(s). " << n << "! ==\n" ;
64   show_factorial(v, n);
65   std::cout << "\ncalculating " << n << "! used " << time << " ms, memory used: "
66                 << v.size()* sizeof(int) << " bytes.\n";
67   system("pause");
68   return 0;
69 }
以上算法速度比较慢，仅仅供初学者参考，更快的版本在这里http://www.cppblog.com/Files/Chipset/Factorial.zip

cottage technology 2009-01-01 18:50 发表评论

把10进制整数转换成任意进制

cottage technology — Thu, 01 Jan 2009 10:47:00 GMT

1 /***************************************************************************************************/
2 /*  Copyright (C) 2008  Chipset
3 /*
4 /*  This program is free software: you can redistribute it and/or modify
5 /*  it under the terms of the GNU Affero General Public License as
6 /*  published by the Free Software Foundation, either version 3 of the
7 /*  License, or (at your option) any later version.
8 /*
9 /*  but WITHOUT ANY WARRANTY; without even the implied warranty of
10 /*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 /*  GNU Affero General Public License for more details.
12 /*
13 /*  You should have received a copy of the GNU Affero General Public License
14 /*  along with this program. If not, see <http://www.gnu.org/licenses/>.
15 /****************************************************************************************************/
16
17 //把一个10进制数转换成任意进制的字符窜
18 #include <string>
19 std::string my_itoa(int num, int radix = 10)
20 {
21   if(0 == num)
22     return  std::string("0");
23
24   if(radix > 16 || radix < 2) //2~16进制，否则默认10进制
25     radix = 10;
26
27   std::string str;
28   if(num < 0 && 10 == radix) //转化成十进制字符窜并且<0，需要考虑符号
29   {
30     num = -num;
31     str += '-';
32    }
33
34   const std::string dstr("0123456789abcdef");
35   std::string t;             //t中存放转化成的字符窜，反序
36
37   for(unsigned n = static_cast<unsigned>(num); n; n /= radix)
38     t += dstr[n % radix];    //把最低位转化成字符并附加到字符窜中
39
40   str += std::string(t.rbegin(), t.rend()); //考虑可能是十进制而且有符号，然后正序组合
41   return str;
42 }
43
44 //测试
45 #include <iostream>
46 #include <cstdlib>
47 #include <ctime>
48 int main()
49 {
50   std::srand(std::time(0));
51   const int L = -std::rand(), H = std::rand(); //测试范围，随机数[L, H)
52   const unsigned BIN = 2, HEX = 16 + 1;        //测试不同进制[2, 16]
53   //随机测试不同进制，但2进制必测
54   for(unsigned j = BIN; j < HEX; j += std::rand() % (HEX - BIN))
55   {
56     std::cout << "radix == " << j << ":\n";
57     for(int i = L; i < H; i += std::rand() % (H - L))
58       std::cout << my_itoa(i, j) << "[" << i << ']' << " ";
59     std::cout << "\n\n";
60   }
61
62   std::system("pause");
63 }

cottage technology 2009-01-01 18:47 发表评论

a better random generator

cottage technology — Sat, 20 Dec 2008 09:59:00 GMT

// random.hpp
// Copyright (C) 2008  Chipset
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#ifndef RANDOM_HPP_
#define RANDOM_HPP_
#include <ctime>

class random
{
public:
  explicit random(unsigned long s = 0) : seed(s)
  {
    if (0 == seed) seed = std::time(0);
    randomize();
  }
  void reset(unsigned long s = 0)
  {
    seed = s;
    if (0 == seed) seed = std::time(0);
    randomize();
  }
  unsigned long rand()
  {
  //returns a random integer in the range [0, -1UL)
    randomize();
    return seed;
  }
  double real()
  {
  //returns a random real number in the range [0.0, 1.0)
    randomize();
    return double(seed) / -1UL;
  }
private:
  unsigned long seed;
  void randomize() { seed = 1103515245UL * seed + 12345UL; }
};

class rand_help
{
  static random r;
public:
  rand_help() {}
void operator()(unsigned long s) { r.reset(s); }
unsigned long operator()() const { return r.rand(); }
double operator()(double) { return r.real(); }
};
random rand_help:: r;

extern void srandom(unsigned long ns = 0) { rand_help()(ns); } //reset seed
extern unsigned long irand() { return rand_help()(); }         //negative numbers disallowed
extern double drand() { return rand_help()(1.0); }             //for real numbers

#endif  // RANDOM_HPP_

//以上随机数产生器产生的随机数比rand()产生的随机数更加随机(可以用数学方法检验)，
//范围更大(一目了然)，速度更快(测试一下便知，稍加修改我还可以让它再快一些，如果有必要)。

/*假设随机数均匀分布为理想分布, 粗略估计随机性*/
#include <iostream>
#include <vector>
#include <iomanip>
#include "random.hpp"
int main()
{
  srand(time(0));
  //SZ分别取值2^3, 2^4, , 2^15进行测试
  const size_t SZ = 1 << 15;
  std::vector<unsigned> v1(SZ), v3(SZ);
  std::vector<unsigned> v2(SZ), v4(SZ);
  for(size_t i = 0; i < SZ; ++i)
  {
    ++v1[rand() % SZ];//对应元素计数 ,理论上v1[0] ~ v1[SZ - 1]之间每个都应该是1
    ++v2[irand() % SZ];
  }

  for(size_t i = 0; i < SZ; ++i)
  {
    ++v3[v1[i]]; //统计频度
    ++v4[v2[i]];
  }
  //假设［0, SSZ)之间不存在间断点, (即使有间断点也无所谓，我们只做粗略模糊统计，因为没有必要那么精确)
  //最理想的显示结果应该是0:    0,   1:   SZ,    2:    0,   3:    0,   4:    0,   other:    0
  //0:表示间断，1:表示均匀，2:, 3:, 4:, other: 都表示不同程度的重复
  const size_t SSZ = 5;
  std::cout.fill(' ');
  for(size_t i = 0; i < SSZ; ++i)
    std::cout << i << ": " << std::setw(SSZ) << v3[i] << ",   ";
  std::cout << "other: " << std::setw(SSZ)
            << v3.size() - v3[0] - v3[1] - v3[2] - v3[3] - v3[4] << '\n';
  for(size_t i = 0; i < SSZ; ++i)
    std::cout << i << ": " << std::setw(SSZ) << v4[i] << ",   ";
  std::cout << "other: " << std::setw(SSZ)
            << v4.size() - v4[0] - v4[1] - v4[2] - v4[3] - v4[4] << '\n';
  system("pause");
}

//做速度测试
#include <iostream>
#include <ctime>
#include <cstdlib>
#include <windows.h>
#include "random.hpp"

int main()
{
  const size_t SZ = 1 << 27;
  std::cout << "generating random numbers in progress \n";
  std::cout << SZ << " random numbers generated.\n";
  std::cout << "random used: ";
  Sleep(1000);
  std::clock_t time = clock();
  for(size_t i = 0; i < SZ; ++i)
    irand();
  std::cout << clock() - time << "ms, ";

  std::cout << "rand() used: ";
  Sleep(1000);
  std::srand(std::time(0));
  std::clock_t t = clock();
  for(size_t i = 0; i < SZ; ++i)
    std::rand();
  std::cout << clock() - t << "ms\n";

  std::system("PAUSE");
  return 0;
}

cottage technology 2008-12-20 17:59 发表评论