原文地址：http://blog.aulin.no/compiling-sphinx-110beta-on-windows

下面是引导大家如何在windows上编译sphinx 1.10beta

1. 下载sphinx源码(http://sphinxsearch.com/downloads/sphinx-1.10-beta.tar.gz)
    注：最新版本在：http://sphinxsearch.com/downloads/archive/ 下
 
2. 因为sphinx使用到MySQL, LibExpat and LibIConv,因此在编译之前需要配置这些库：
   下载MySQL的开发环境http://dev.mysql.com/get/Downloads/MySQL-5.1/mysql-5.1.52-win32.msi/from/http://mysql.borsen.dk/，安装开发组件
   下载LibExpat(http://garr.dl.sourceforge.net/project/expat/expat_win32/2.0.1/expat-win32bin-2.0.1.exe)
   下载LibIConv (http://netcologne.dl.sourceforge.net/project/gnuwin32/libiconv/1.9.2-1/libiconv-1.9.2-1.exe)
  
3. 在shpinx.h中可以配置和移除sphinx需要的组件,如可以移除对PostgreSQL 的支持

4. 在visual studiao 08 中打开 Sphinx08.sln

5. 添加mysql 的include路径(C:\Program Files (x86)\MySQL\MySQL Server 5.1\include) to all projects (右击 - Properties - Configuration Properties - C/C++ - General - Additional Include Directories).

6. 添加mysql的lib路径(C:\Program Files (x86)\MySQL\MySQL Server 5.1\lib\opt) to all projects excluding "libsphinx" (右击 - Properties - Configuration Properties - Linker - General - Additional Library Directories)

7. 在除了libsphinx的所有工程中，添加LibExpat的路径(C:\Program Files (x86)\Expat 2.0.1\Bin)(右击 - Properties - Configuration Properties - Linker - General - Additional Library Directories)

8. 在除了libsphinx的所有工程中，添加LibIConv 的路径(C:\Program Files (x86)\GnuWin32\lib)(右击 - Properties - Configuration Properties - Linker - General - Additional Library Directories)

9. 编译Build! (F6)

shuffle算法，我把他叫做洗牌算法，它的目标正好与各种的sort算法相反，即把一个有序(或者无序)的一系列元素打乱，以满足需求。

举个两例子，大家都知道扑克牌，我们每次都需要在摸牌之前把牌洗掉，用来让每个人摸到每张牌的概率尽量相等，增加游戏的随机性和乐趣；还有音频播放器，有一些人不喜欢顺序播放，而喜欢使用随机播放(其实随机播放分为两种,random和shuffle，后文会介绍到)，比如iPod Shuffle的卖点之一就是“你永远不知道你将要听到的下一首歌曲是什么”。至少，如果要模拟扑克牌游戏，或者做音频播放器，都要使用shuffle算法，而二者的shuffle算法却有一些区别，一个是一次性的洗牌，另一个则是每次取一首歌。那么怎么实现他们呢？

扑克牌的shuffle算法：

下面为了方便和容易读懂，我都用扑克牌来作例子：桌上有n张牌，并且对桌子上的牌进行标号，从0直到n-1。我们的目的是洗这些牌。

一个比较容易想到的方法是，桌子上有n张扑克牌，我第i次从桌子上等概率随机取一张扑克牌，作为洗牌后牌堆的第i张扑克牌，那么这个算法实现起来应该是这样的：

伪代码：
for i <- 0 to n - 1
do d <- Random mod (n - i)
   shuffle[i] <- deck[d]
   deck[d] <- deck[n - i]

其中，deck是洗牌前的序列(0~n-1)，shuffle是洗牌后的序列(0~n-1)，第i次(从0开始数)在剩下的n-i张牌里等概率的取一张牌，把它放到shuffle里。而deck[d] = deck[n - i]这句达到的效果是删除取过的牌。

这个方法的时间复杂度是O(n)，已经可以接受了，但这个方法还不够好，因为我们需要两个长度为n数组。其实可以很容易得得到下面的方法，解决空间的问题：
伪代码：
for i <- 0 to n - 1
do d <- Random mod (n - i)
   swap(deck[d], deck[n - i])

这样，这个算法的道理就有些像选择排序了，第i次(从0开始数)确定第n-i个元素的原位置，并且交换两个位置上的元素。它的复杂读仍然是O(n)，而只需要1个额外的空间来储存交换用的临时变量。
这个方法已经是一个比较好的解决方法了(自己认为)，如果你还能写出更好的shuffle算法，请告诉我。

我相信对洗牌这种东西有了解的人都不会用这样的方法来洗牌：另外对每张牌做一个标记，即是否抽过这张牌：然后第i次在n张牌里随机抽一个，如果这张牌曾经被抽过，那么把它放回去，重复抽取，直到抽到一张没被抽过的牌，将这张牌标记为抽取过的牌，然后在纸上的第i个地方记下这张牌。在计算机里这样实现：

伪代码：
for i <- 0 to n - 1
do d <- Random mod n
   while did[d] = 1
   do d = Random mod n
   did[d] <- 1
   shuffle[i] <- deck[d]


看了描述，你一定就会觉得这种方法实在是遭透了，不仅麻烦，而且会有一个陷阱，那就是在某次取牌的时候，也许会运气差永远也取不到没有被取过的那张牌，导致程序运行的不确定性。然而，在初学者当中，却有不少是用这种方法实现的shuffle的。个人认为，在设计算法的时候，越简单、越接近生活的模型，就越容易设计出好的算法，而且算法的描述也更接近实际生活。因此，设计算法的时候，如果能往平时生活的方面想， 总是事半功倍的。

附上我自己实现的一个类qsort的shuffle算法

// element_Size is the size of each element
 
void swap(void const *element1, void const *element2, size_t element_Size)
{
    char *temp = new char,
         *elem1, *elem2;
    elem1 = (char *)element1;
    elem2 = (char *)element2;
    for(int i = 0; i < element_Size; i++, elem1++, elem2++){
        *temp = *elem1;
        *elem1 = *elem2;
        *elem2 = *temp;
    }
    delete temp;
}
 
// array_Size is the size of array,
// element_Size is the size of each element in array
 
void shuffle(void const *array, size_t array_Size, size_t element_Size)
{
    void *element1, *element2;
    srand(time(0));
    for(int i = 0; i < array_Size / element_Size; i++){
        element1 = (char *)array + i * element_Size;
        element2 = (char *)array + rand(i * element_Size,
            array_Size - element_Size, element_Size);
        swap(element1, element2, element_Size);
    }
}

播放器的shuffle算法：

前面说过播放器的随机播放有两种，一种叫Random,一种叫Shuffle(我自己理解的......)，下面解释这两种方法的不同。

学过概率的人都该知道有放回的抽取的概念。袋中有n个不同的小球，每次抽取一个小球，然后放回，每一次取的时候概率都是相同的。这正是播放器random算法的原理，这种算法实现起来很简单，一首歌结束以后，只需要随机选取下一首歌就行了。
但是这样做有一些缺点：1，有一定的概率使得连续选取的两首歌是同一首歌，我相信并不是所有人都希望在shuffle模式下连续听同一首歌吧，当然也有解决办法，那就是增加层循环判断，如果选上同一首歌，则重新选，而这样又会重蹈那个很烂的洗牌算法的覆辙。2，当听完一首歌的时候，觉得还想再听一遍，怎么办？按下“上一首”，你会发现这时听到的歌曲已经不是刚才那一首想听歌曲了，因为这种方法只知道当前的状态，而不知道过去的播放状态。怎么办？一种办法是增加一个队列叫做“刚才播放列表”，把播放过的歌曲按照顺序储存在列表里。3，有一定概率在很长的一段时间内，播放器不停的在重复播放两首歌曲A和B或者类似情况，就像这样：...-A-B-A-B-A-B-...。这种情况也是很讨厌的，可是如何避免呢？我能想到的办法是增加判断，看这首歌是不是在列表的最后几项里，如果在就不选这首......

但是这些概率都小的可怜，对于一个播放器的random函数来说，能够考虑到以上的几点，已经能够做到足够random和人性化了。只要能够合理的选择参数，考虑到一些特殊情况(比如极小的播放列表)，以及考虑用户的心理，就能做出一个比较好的random函数。

下面讲我设计的播放器shuffle算法，shuffle算法能够很大程度上避免random算法的缺陷，在空间时间上都很节约，而且能够达到比较理想的随机化效果。它的大体思路是这样的：

我们使用一个隐含的shuffle播放列表(一个循环队列)来储存歌曲的顺序，并用一个指针表示正在播放的歌曲(记作"^")，比如当前的播放列表是这样的：

ABCDEFGHIJKLMN
             ^

即现在有14首歌，将要播放位置1的歌曲(正在播放位置14的歌曲)，我们认为队列头和尾是相连的，即N后面的元素是A，那么这样够成了一个循环队列。
在播放之前，我们在前7(7=14*0.5，这个比例可以随便选，当然越大随机性越大，但能后退的次数越少)个位置中，随机取一个一首歌，把它和将要播放的那个位置的歌曲交换。假设我们选的是E，则队列变成这样：

EBCDAFGHIJKLMN
^

然后播放E。E播放完了以后(或者选择下一首时)，重复刚才的动作，即在BCDAFGH中随机选一个，交换，比如选到H，则队列变成：
EHCDAFGBIJKLMN
 ^

然后播放H。这样，一个shuffle算法初步完成了。

比如某一时刻播放器的状态是这样：
EHCDAFGBIJKLMN
          ^
则我们在LMNEHCD中选择一个，比如选择到H，那么交换并播放，成为：
ELCDAFGBIJKHMN
           ^
但是如果用户选择上一首怎么办呢?我们可以再记录一个指针指向最新shuffle选择出来的那首歌曲(记作"*")，没有选择过前一首的时候，它与播放指针指向同一个位置。当选择前一首的时候，仅移动指针^，而不移动*，比如上一个例子播放的时候按下前一首以后，成为：

ELCDAFGBIJKHMN
          ^*

这时候播放的K正好是刚才播放的那一首，当然这达到了我的目的，即可以选到刚才播放的曲目，当然如果再一次选择上一首，就会变成：

ELCDAFGBIJKHMN
         ^ *

这时候如果按下一首，应该判断^指向的是不是和*指向的相同，如果相同，就按照最早介绍的shuffle算法进行随机选取，不相同就简单的移动^，即成为：

ELCDAFGBIJKHMN
          ^*

伪代码：
function keypress(key)
   if key = NEXT
      if p1 = p2
      do p1 <- p1 + 1
         p2 <- p2 + 1
         k = Random mod (length / 2)
         swap(p1, (p1 + k) mod length)
         play(p2)
      else
      do p2 <- (p2 + 1) mod length
         play(p2)
   if key = PREV
      do p2 <- (p2 + length - 1) mod length
         play(p2)

这个播放器的shuffle算法比较简单实用，而且节约内存开销(这对mp3 walkman之类的东西是十分重要的)，当然也有个小缺点，就是当^前移多次回到*以后，再按下一首，则会重新开始shuffle，但是歌曲数目很多的情况下，这个缺点并不是那么重要。
这个算法在刚开始听的时候，并不是很随机，可是随着听的次数的增多，队列会越来越乱，达到一个shuffle的效果。
当然，也可以在第一次对这个列表播放之前，使用扑克牌的shuffle算法(见本文第一部分)进行一次shuffle，这样，刚开始播放的时候列表就是随机的。
通过原理我们可以看到，对于刚听过的那首歌来说，不经过length / 2次，是不会再一次听到的，因此很大程度上避免了random算法的缺陷。这个length / 2的参数可以按照具体情况选择，可以是常数，也可以是随机数，也可以是和长度有关的一个数。 

拉普拉斯变换（Laplace Transform)，是工程数学中常用的一种积分变换。
    它是为简化计算而建立的实变量函数和复变量函数间的一种函数变换。对一个实变量函数作拉普拉斯变换，并在复数域中作各种运算，再将运算结果作拉普拉斯反变换来求得实数域中的相应结果，往往比直接在实数域中求出同样的结果在计算上容易得多。拉普拉斯变换的这种运算步骤对于求解线性微分方程尤为有效，它可把微分方程化为容易求解的代数方程来处理，从而使计算简化。在经典控制理论中，对控制系统的分析和综合，都是建立在拉普拉斯变换的基础上的。
    引入拉普拉斯变换的一个主要优点，是可采用传递函数代替微分方程来描述系统的特性。这就为采用直观和简便的图解方法来确定控制系统的整个特性（见信号流程图、动态结构图）、分析控制系统的运动过程（见奈奎斯特稳定判据、根轨迹法），以及综合控制系统的校正装置（见控制系统校正方法）提供了可能性。
    拉普拉斯变换在工程学上的应用：应用拉普拉斯变换解常变量齐次微分方程，可以将微分方程化为代数方程，使问题得以解决。在工程学上，拉普拉斯变换的重大意义在于：将一个信号从时域上，转换为复频域（s域）上来表示；在线性系统，控制自动化上都有广泛的应用。

（阅读本文之前请先了解二叉搜索树）

红黑树（Red-Black Tree）

红黑树（Red-Black Tree）是二叉搜索树（Binary Search Tree）的一种改进。我们知道二叉搜索树在最坏的情况下可能会变成一个链表（当所有节点按从小到大的顺序依次插入后）。而红黑树在每一次插入或删除节点之后都会花O（log N）的时间来对树的结构作修改，以保持树的平衡。也就是说，红黑树的查找方法与二叉搜索树完全一样；插入和删除节点的的方法前半部分节与二叉搜索树完全一样，而后半部分添加了一些修改树的结构的操作。

红黑树的每个节点上的属性除了有一个key、3个指针：parent、lchild、rchild以外，还多了一个属性：color。它只能是两种颜色：红或黑。而红黑树除了具有二叉搜索树的所有性质之外，还具有以下4点性质：（为什么只要这些性质就能解决这个问题，其实还是一个问题）

1. 根节点是黑色的。

2. 空节点是黑色的（红黑树中，根节点的parent以及所有叶节点lchild、rchild都不指向NULL，而是指向一个定义好的空节点）。

3. 红色节点的父、左子、右子节点都是黑色。

4. 在任何一棵子树中，每一条从根节点向下走到空节点的路径上包含的黑色节点数量都相同。
    如下图就是一棵红黑树：

有了这几条规则，就可以保证整棵树的平衡，也就等于保证了搜索的时间为O（log N）。

但是在插入、删除节点后，就有可能破坏了红黑树的性质。所以我们要做一些操作来把整棵树修补好。下面我就来介绍一下。

首先有一个预备知识，那就是节点的Left-Rotate和Right-Rotate操作。所谓Left-Rotate(x)就是把节点x向左下方向移动一格，然后让x原来的右子节点代替它的位置。而Right-Rotate当然就是把Left-Rotate左、右互反一下。如下图：

注意，Left-Rotate(x)后，x的右子树变成了原来y的左子树，Right-Rotate反之。思考一下，这样一次变换后，仍然满足二叉搜索树的性质（中序遍历并没有改变）。在红黑树的插入、删除中，要用到很多Left-Rotate和Right-Rotate操作。

//把一个节点向左下方移一格，并让他原来的右子节点代替它的位置。
   void leftRotate(RBTNode* node)

 {
        RBTNode* right = node->rchild;
        node->rchild = right->lchild;
        node->rcount = right->lcount;
        node->rchild->parent = node;
        right->parent = node->parent;
        if (right->parent == m_null) {
            m_root = right;
        }
        else if (node == node->parent->lchild) {
            node->parent->lchild = right;
        }
        else {
            node->parent->rchild = right;
        }
        right->lchild = node;
        right->lcount += node->lcount + 1;
        node->parent = right;
    }

    //把一个节点向右下方移一格，并让他原来的左子节点代替它的位置。
    inline void rightRotate(RBTNode* node) {
        RBTNode* left = node->lchild;
        node->lchild = left->rchild;
        node->lcount = left->rcount;
        node->lchild->parent = node;
        left->parent = node->parent;
        if (left->parent == m_null) {
            m_root = left;
        }
        else if (node == node->parent->lchild) {
            node->parent->lchild = left;
        }
        else {
            node->parent->rchild = left;
        }
        left->rchild = node;
        left->rcount += node->rcount + 1;
        node->parent = left;
    }

一、 插入

插入首先是按部就班二叉搜索树的插入步骤，把新节点z插入到某一个叶节点的位置上。
    接下来把z的颜色设成红色。为什么？还记得红黑树的性质吗，从根节点向下到空节点的每一条路径上的黑色节点数要相同。如果新插入的是黑色节点，那么它所在的路径上就多出了一个黑色的节点了。所以新插入的节点一定要设成红色。但是这样可能又有一个矛盾，如果z的父节点也是红色，怎么办，前面说过红色节点的子节点必须是黑色。因此我们要执行下面一个迭代的过程，称为Insert-Fixup，来修补这棵红黑树。

在Insert-Fixup中，每一次迭代的开始，指针z一定都指向一个红色的节点。如果z->parent是黑色，那我们就大功告成了；如果z->parent是红色，显然这就违返了红黑的树性质，那么我们要想办法把z或者z->parent变成黑色，但这要建立在不破坏红黑树的其他性质的基础上。

这里再引入两个指针：grandfather，指向z->parent->parent，也就是z的爷爷(显然由于z->parent为红色，grandfather一定是黑色)；uncle，指向grandfather除了z->parent之外的另一个子节点，也就是z的父亲的兄弟，所以叫uncle。

（为了说话方便，我们这里都假设z->parent是grandfather的左子节点，而uncle是grandfather的右子节点。如果遇到的实际情况不是这样，那也只要把所有操作中的左、右互反就可以了。）

在每一次迭代中，我们可能遇到以下三种情况。

Case 1. uncle也是红色。这时只要把z->parent和uncle都设成黑色，并把grandfather设成红色。这样仍然确保了每一条路径上的黑色节点数不变。然后把z指向grandfather，并开始新一轮的迭代。如下图：

注1：我们可以看出左边的图，各条路径包含黑颜色的数目是正确的，只是颜色不对而已，我们把它分成两边来看，即到节点D应该包含N+1个黑色节点，其中这个1是C，而N是C以上的黑色节点个数。同理A也应该是N+1，B也是N+1，调整以后，看看我们确实没有改变到A、B、D的所包含的黑色节点数。下面的情况也可以同样的方法来分析。

Case 2. uncle是黑色，并且z是z->parent的右子节点。这时我们只要把z指向z->parent，然后做一次Left-Rotate(z)。就可以把情况转化成Case 3。

Case 3. uncle是黑色，并且z是z->parent的左子节点。到了这一步，我们就剩最后一步了。只要把z->parent设成黑色，把grandfather设成红色，再做一次Right-Rotate(grandfather)，整棵树就修补完毕了。可以思考一下，这样一次操作之后，确实满足了所有红黑树的性质。Case 2和Case 3如下图：

   反复进行迭代，直到某一次迭代开始时z->parent为黑色而告终，也就是当遇到Case 3后，做完它而告终。

void insertFixup(RBTNode* insertNode) {
        RBTNode* p = insertNode;
        while (p->parent->color == RED) {

//z->parent是grandfather的左子节点,下面是三种情况
            if (p->parent == p->parent->parent->lchild) {
                RBTNode* parentRight = p->parent->parent->rchild;
                if (parentRight->color == RED) {
                    p->parent->color = BLACK;
                    parentRight->color = BLACK;
                    p->parent->parent->color = RED;
                    p = p->parent->parent;
                }
                else {
                    if (p == p->parent->rchild) {
                        p = p->parent;
                        leftRotate(p);
                    }
                    p->parent->color = BLACK;
                    p->parent->parent->color = RED;
                    rightRotate(p->parent->parent);
                }
            }
            else {
                RBTNode* parentLeft = p->parent->parent->lchild;
                if (parentLeft->color == RED) {
                    p->parent->color = BLACK;
                    parentLeft->color = BLACK;
                    p->parent->parent->color = RED;
                    p = p->parent->parent;
                }
                else {
                    if (p == p->parent->lchild) {
                        p = p->parent;
                        rightRotate(p);
                    }
                    p->parent->color = BLACK;
                    p->parent->parent->color = RED;
                    leftRotate(p->parent->parent);
                }
            }
        }
        m_root->color = BLACK;
    }

二、删除

让我们来回顾一下二叉搜索树的删除节点z的过程：如果z没有子节点，那么直接删除即可；如果z只有一个子节点，那么让这个子节点来代替z的位置，然后把z删除即可；如果z有两个子节点，那么找到z在中序遍历中的后继节点s（也就是从z->rchild开始向左下方一直走到底的那一个节点），把s的key赋值给z的key，然后删除s。

红黑树中删除一个节点z的方法也是首先按部就班以上的过程。

按照二叉搜索树的删除方法删除节点，如果删除节点是红色的，那并不会改变红黑树的性质。如果删除的节点是黑色的，那么显然它所在的路径上就少一个黑色节点，那么红黑树的性质就被破坏了。这时我们就要执行一个称为Delete-Fixup的过程，来修补这棵树。下面我就来讲解一下。

一个节点被删除之后，一定有一个它的子节点代替了它的位置（即使是叶节点被删除后，也会有一个空节点来代替它的位置。前面说过，在红黑树中，空节点是一个实际存在的节点。）。我们就设指针x指向这个代替位置的节点。
显然，如果x是红色的，那么我们只要把它设成黑色，它所在的路径上就重新多出了一个黑色节点，那么红黑树的性质就满足了。
    然而，如果x是黑色的，那我们就要假想x上背负了2个单位的黑色。那么红黑树的性质也同样不破坏，但是我们要找到某一个红色的节点，把x上“超载”的这1个单位的黑色丢给它，这样才算完成。Delete-Fixup做的就是这个工作。

注：删除了一个黑色节点以后，遍历到节点一下的叶子节点比遍历其他分支的叶子节点的黑色节点数就少了一个，这就要是找到一个红色，把这个节点换成黑色来拟补这个删除的黑色节点，使得遍历到叶子节点经过黑色节点的数目一样。

Delete-Fixup同样是一个循环迭代的过程。每一次迭代开始时，如果指针x指向一个红色节点，那么大功告成，把它设成黑色即告终。相反如果x黑色，那么我们就会面对以下4种情况。

这里引入另一个指针w，指向x的兄弟。这里我们都默认x是x->parent的左子节点，则w是x->parent的右子节点。（如果实际遇到相反的情况，只要把所有操作中的左、右互反一下就可以了。）

Case 1. w是红色。这时我们根据红黑树的性质可以肯定x->parent是黑色、w->lchild是黑色。我们把x->parent与w的颜色互换，然后做一次Left-Rotate(x->parent)。做完之后x就有了一个新的兄弟：原w->lchild，前面说过它一定是黑色的。那么我们就在不破坏红黑树性质的前提下，把Case 1转换成了Case2、3、4中的一个，也就是w是黑色的情况。思考一下，这样做不会改变每条路径上黑色节点的个数，如下图：

注：可以看出这样变化以后就变成了Case2了。

Case 2. w是黑色，并且w的两个子节点都是黑色。这时我们只要把w设成红色。然后把x移到x->parent，开始下一轮迭代（注意，那“超载”的1单位的黑色始终是跟着指针x走的，直到x走到了一个红色节点上才能把它“卸下”）。思考一下，这一次操作不会破坏红黑树的性质。如下图（图中节点B不一定是红色，也可能是黑色）：

注：这里只要把B变成红色就大功告成了。

Case 3. w是黑色，并且w的两个子节点左红右黑。这时我们把w与w->lchild的颜色互换，然后做Right-Rotate(w)。思考一下，这样做之后不会破坏红黑树的性质。这时x的新的兄弟就是原w->lchild。而Case 3被转化成了Case 4。

Case 4. w是黑色，并且w的右子节点是红色。一但遇到Case 4，就胜利在望了。我看下面一张图。先把w与x->parent的颜色互换，再做Left-Rotate(x->parent)。这时图中节点E（也就是原w->rchild）所在的路径就肯定少了一个黑色，而x所在的路径则多了一个黑色。那么我们就把x上多余的1个单位的黑色丢给E就可以了。至此，Delete-Fixup就顺利完成了。

注：通过注1我们可以看出问题在Case4后已经解决了。

void delFixup(RBTNode* delNode) {

    RBTNode* p = delNode;

    while (p != m_root && p->color == BLACK) {

       if (p == p->parent->lchild) {//左边情况，以下是四种不同的Case

           RBTNode* sibling = p->parent->rchild;

           if (sibling->color == RED) {

              sibling->color = BLACK;

              p->parent->color = RED;

              leftRotate(p->parent);

              sibling = p->parent->rchild;

           }

           if (sibling->lchild->color == BLACK

              && sibling->rchild->color == BLACK

              ) {

              sibling->color = RED;

              p = p->parent;

           }

           else {

              if (sibling->rchild->color == BLACK) {

                  sibling->lchild->color = BLACK;

                  sibling->color = RED;

                  rightRotate(sibling);

                  sibling  = sibling->parent;

              }

              sibling->color = sibling->parent->color;

              sibling->parent->color = BLACK;

              sibling->rchild->color = BLACK;

              leftRotate(sibling->parent);

              p = m_root;

           }

       }

       else {//右边情况

           RBTNode* sibling = p->parent->lchild;

           if (sibling->color == RED) {

              sibling->color = BLACK;

              p->parent->color = RED;

              rightRotate(p->parent);

              sibling = p->parent->lchild;

           }

           if (sibling->lchild->color == BLACK

              && sibling->rchild->color == BLACK

              ) {

              sibling->color = RED;

              p = p->parent;

           }

           else {

              if (sibling->lchild->color == BLACK) {

                  sibling->rchild->color = BLACK;

                  sibling->color = RED;

                  leftRotate(sibling);

                  sibling = sibling->parent;

              }

              sibling->color = sibling->parent->color;

              sibling->parent->color = BLACK;

              sibling->lchild->color = BLACK;

              rightRotate(sibling->parent);

              p = m_root;

           }

       }

    }

    p->color = BLACK;

}

By 刘未鹏(pongba)

C++的罗浮宫(http://blog.csdn.net/pongba)

TopLanguage(http://groups.google.com/group/pongba)

目录

0. 前言

1. 猜数字

2. 称球

3. 排序

    3.1 为什么堆排比快排慢

    3.2 为什么快排其实也不是那么快

    3.3 基排又为什么那么快呢

4. 信息论！信息论？

5. 小结

0. 前言

    知道这个理论是在TopLanguage上的一次讨论，先是g9转了David MacKay的一篇文章，然后引发了牛人们的一场关于信息论的讨论。Anyway，正如g9很久以前在Blog里面所说的：

有时无知是福。俺看到一点新鲜的科普也能觉得造化神奇。刚才读Gerald Jay Sussman（SICP作者）的文章，Building Robust Systems – an essay，竟然心如小鹿乱撞，手心湿润，仿佛第一次握住初恋情人温柔的手。

    而看到MacKay的这篇文章我也有这种感觉——以前模糊的东西忽然有了深刻的解释，一切顿时变得明白无比。原来看问题的角度或层面能够带来这么大的变化。再一次印证了越是深刻的原理往往越是简单和强大。所以说，土鳖也有土鳖的幸福:P

这篇文章相当于MacKay原文的白话文版。MacKay在原文中用到了信息论的知识，后者在我看来并不是必须的，尽管计算的时候方便，但与本质无关。所以我用大白话解释了一通。

1. 猜数字

    我们先来玩一个猜数字游戏：我心里默念一个1~64之间的数，你来猜（你只能问答案是“是”或“否”的问题）。为了保证不论在什么情况下都能以尽量少的次数猜中，你应该采取什么策略呢？很显然，二分。先是猜是不是位于1~32之间，排除掉一半可能性，然后对区间继续二分。这种策略能够保证无论数字怎么跟你捉迷藏，都能在log_2{n}次以内猜中。用算法的术语来说就是它的下界是最好的。

    我们再来回顾一下这个游戏所蕴含的本质：为什么这种策略具有最优下界？答案也很简单，这个策略是平衡的。反之如果策略不是平衡的，比如问是不是在1~10之间，那么一旦发现不是在1~10之间的话就会剩下比N/2更多的可能性需要去考察了。

    徐宥在讨论中提到，这种策略的本质可以概括成“让未知世界无机可乘”。它是没有“弱点的”，答案的任何一个分支都是等概率的。反之，一旦某个分支蕴含的可能性更多，当情况落到那个分支上的时候你就郁闷了。比如猜数字游戏最糟糕的策略就是一个一个的猜：是1吗？是2吗？... 因为这种猜法最差的情况下需要64次才能猜对，下界非常糟糕。二分搜索为什么好，就是因为它每次都将可能性排除一半并且无论如何都能排除一半（它是最糟情况下表现最好的）。

2. 称球

    12个小球，其中有一个是坏球。有一架天平。需要你用最少的称次数来确定哪个小球是坏的并且它到底是轻还是重。

    这个问题是一道流传已久的智力题。网络上也有很多讲解，还有泛化到N个球的情况下的严格证明。也有零星的一些地方提到从信息论的角度来看待最优解法。本来我一直认为这道题目除了试错之外没有其它高妙的思路了，只能一个个方法试，并尽量从结果中寻找信息，然后看看哪种方案最少。

    然而，实际上它的确有其它的思路，一个更本质的思路，而且根本用不着信息论这么拗口的知识。

    我们先回顾一下猜数字游戏。为了保证任何情况下以最少次数猜中，我们的策略是每次都排除恰好一半的可能性。类比到称球问题上：坏球可能是12个球中的任意一个，这就是12种可能性；而其中每种可能性下坏球可能轻也可能重。于是“坏球是哪个球，是轻是重”这个问题的答案就有12×2=24种可能性。现在我们用天平来称球，就等同于对这24种可能性发问，由于天平的输出结果有三种“平衡、左倾、右倾”，这就相当于我们的问题有三个答案，即可以将所有的可能性切成三份，根据猜数字游戏的启发，我们应当尽量让这三个分支概率均等，即平均切分所有的可能性为三等份。如此一来的话一次称量就可以将答案的可能性缩减为原来的1/3，三次就能缩减为1/27。而总共才有24种可能性，所以理论上是完全可以3次称出来的。

    如何称的指导原则有了，构造一个称的策略就不是什么太困难的事情了。首先不妨解释一下为什么最直观的称法不是最优的——6、6称：在6、6称的时候，天平平衡的可能性是0。刚才说了，最优策略应该使得天平三种状态的概率均等，这样才能三等分答案的所有可能性。

   为了更清楚的看待这个问题，我们不妨假设有6个球，来考虑一下3、3称和2、2称的区别：

   在未称之前，一共有12种可能性：1轻、1重、2轻、2重、...、6轻、6重。现在将1、2、3号放在左边，4、5、6放在右边3、3称了之后，不失一般性假设天平左倾，那么小球的可能性就变成了原来的一半（6种）：1重、2重、3重、4轻、5轻、6轻。即这种称法能排除一半可能性。

    现在再来看2、2称法，即1、2放左边，3、4放右边，剩下的5、6不称，放一边。假设结果是天平平衡，那么可能性剩下——4种：5重、5轻、6重、6轻。假设天平左倾，可能性也剩下4种：1重、2重、3轻、4轻。右倾和左倾的情况类似。总之，这种称法，不管天平结果如何，情况都被我们缩小到了原来的三分之一！我们充分利用了“天平的结果状态可能有三种”这个条件来三等分所有可能性，而不是二等分。

    说到这里，剩下的事情就实在很简单了：第二步称法，只要记着这样一个指导思想——你选择的称法必须使得当天平平衡的时候答案剩下的可能性和天平左倾（右倾）的时候答案剩下的可能性一样多。实际上，这等同于你得选择一种称法，使得天平输出三种结果的概率是均等的，因为天平输出某个结果的概率就等同于所有支持这个结果（左倾、右倾、平衡）的答案可能性的和，并且答案的每个可能性都是等概率的。

MacKay在他的书《Information Theory: Inference and Learning Algorithms》（作者开放免费电子书）里面4.1节专门讲了这个称球问题，还画了一张不错的图，我就照抄了：

    图中“1+”是指“1号小球为重”这一可能性。一开始一共有24种可能性。4、4称了之后不管哪种情况（分支），剩下来的可能性总是4种。这是一个完美的三分。然后对每个分支构造第二次称法，这里你只要稍加演算就可以发现，分支1上的第二次称法，即“1、2、6对3、4、5”这种称法，天平输出三种结果的可能性是均等的（严格来说是几乎均等）。这就是为什么这个称法能够在最坏的情况下也能表现最好的原因，没有哪个分支是它的弱点，它必然能将情况缩小到原来的1/3。

3. 排序

    用前面的看问题视角，排序的本质可以这样来表述：一组未排序的N个数字，它们一共有N!种重排，其中只有一种排列是满足题意的（譬如从大到小排列）。换句话说，排序问题的可能性一共有N!种。任何基于比较的排序的基本操作单元都是“比较a和b”，这就相当于猜数字游戏里面的一个问句，显然这个问句的答案只能是“是”或“否”，一个只有两种输出的问题最多只能将可能性空间切成两半，根据上面的思路，最佳切法就是切成1/2和1/2。也就是说，我们希望在比较了a和b的大小关系之后，如果发现a<b的话剩下的排列可能性就变成N!/2，如果发现a>b也是剩下N!/2种可能性。由于假设每种排列的概率是均等的，所以这也就意味着支持a<b的排列一共有N!/2个，支持a>b的也是N!/2个，换言之，a<b的概率等于a>b的概率。

    我们希望每次在比较a和b的时候，a<b和a>b的概率是均等的，这样我们就能保证无论如何都能将可能性缩小为原来的一半了！最优下界。

    一个直接的推论是，如果每次都像上面这样的完美比较，那么N个元素的N!种可能排列只需要log_2{N!}就排查玩了，而log_2{N!}近似于NlogN。这正是快排的复杂度。

    3.1 为什么堆排比快排慢

    回顾一下堆排的过程：

    1. 建立最大堆（堆顶的元素大于其两个儿子，两个儿子又分别大于它们各自下属的两个儿子... 以此类推）

    2. 将堆顶的元素和最后一个元素对调（相当于将堆顶元素（最大值）拿走，然后将堆底的那个元素补上它的空缺），然后让那最后一个元素从顶上往下滑到恰当的位置（重新使堆最大化）。

    3. 重复第2步。

    这里的关键问题就在于第2步，堆底的元素肯定很小，将它拿到堆顶和原本属于最大元素的两个子节点比较，它比它们大的可能性是微乎其微的。实际上它肯定小于其中的一个儿子。而大于另一个儿子的可能性非常小。于是，这一次比较的结果就是概率不均等的，根据前面的分析，概率不均等的比较是不明智的，因为它并不能保证在糟糕情况下也能将问题的可能性削减到原本的1/2。可以想像一种极端情况，如果a肯定小于b，那么比较a和b就会什么信息也得不到——原本剩下多少可能性还是剩下多少可能性。

    在堆排里面有大量这种近乎无效的比较，因为被拿到堆顶的那个元素几乎肯定是很小的，而靠近堆顶的元素又几乎肯定是很大的，将一个很小的数和一个很大的数比较，结果几乎肯定是“小于”的，这就意味着问题的可能性只被排除掉了很小一部分。

    这就是为什么堆排比较慢（堆排虽然和快排一样复杂度都是O(NlogN)但堆排复杂度的常系数更大）。

    MacKay也提供了一个修改版的堆排：每次不是将堆底的元素拿到上面去，而是直接比较堆顶（最大）元素的两个儿子，即选出次大的元素。由于这两个儿子之间的大小关系是很不确定的，两者都很大，说不好哪个更大哪个更小，所以这次比较的两个结果就是概率均等的了。具体参考这里。

3.2 为什么快排其实也不是那么快

    我们考虑快排的过程：随机选择一个元素做“轴元素”，将所有大于轴元素的移到左边，其余移到右边。根据这个过程，快排的第一次比较就是将一个元素和轴元素比较，这个时候显而易见的是，“大于”和“小于”的可能性各占一半。这是一次漂亮的比较。

    然而，快排的第二次比较就不那么高明了：我们不妨令轴元素为pivot，第一次比较结果是a1<pivot，那么可以证明第二次比较a2也小于pivot的可能性是2/3！这容易证明：如果a2>pivot的话，那么a1，a2，pivot这三个元素之间的关系就完全确定了——a1<pivot<a2，剩下来的元素排列的可能性我们不妨记为P（不需要具体算出来）。而如果a2<pivot呢？那么a1和a2的关系就仍然是不确定的，也就是说，这个分支里面含有两种情况：a1<a2<pivot，以及a2<a1<pivot。对于其中任一种情况，剩下的元素排列的可能性都是P，于是这个分支里面剩下的排列可能性就是2P。所以当a2<pivot的时候，还剩下2/3的  可能性需要排查。

    再进一步，如果第二步比较果真发现a2<pivot的话，第三步比较就更不妙了，模仿上面的推理，a3<pivot的概率将会是3/4！

    这就是快排也不那么快的原因，因为它也没有做到每次比较都能将剩下的可能性砍掉一半。

    3.3 鸡排为什么又那么快呢？

    传统的解释是：基排不是基于比较的，所以不具有后者的局限性。话是没错，但其实还可以将它和基于比较的排序做一个类比。

    基排的过程也许是源于我们理顺一副牌的过程：如果你有N（N<=13）张牌，乱序，如何理顺呢？我们假象桌上有十三个位置，然后我们将手里的牌一张一张放出去，如果是3，就放在位置3上，如果是J，就放在位置11上，放完了之后从位置1到位置13收集所有的牌（没有牌的位置上不收集任何牌）。

    我们可以这样来理解基排高效的本质原因：假设前i张牌都已经放到了它们对应的位置上，第i+1张牌放出去的时候，实际上就相当于“一下子”就确立了它和前i张牌的大小关系，用O(1)的操作就将这张牌正确地插入到了前i张牌中的正确位置上，这个效果就相当于插入排序的第i轮原本需要比较O(i)次的，现在只需要O(1)了。

    但是，为什么基排能够达到这个效果呢？上面只是解释了过程，解释了过程不代表解释了本质。

    当i张牌放到位之后，放置第i+1张牌的时候有多少种可能性？大约i+1种，因为前i张牌将13个位置分割成了i+1个区间——第i+1张牌可以落在任意一个区间。所以放置第i+1张牌就好比是询问这样一个问题：“这张牌落在哪个区间呢？”而这个问题的答案有i+1种可能性？所以它就将剩下来的可能性均分成了i+1份（换句话说，砍掉了i/i+1的可能性！）。再看看基于比较的排序吧：由于每次比较只有两种结果，所以最多只能将剩下的可能性砍掉一半。

    这就是为什么基排要快得多。而所有基于比较的排序都逃脱不了NlogN的宿命。

    4. 信息论！信息论？

    本来呢，MacKay写那篇文章是想用信息论来解释为什么堆排慢，以及为什么快排也慢的。MacKay在他的文章中的解释是，只有提出每种答案的概率都均等的问题，才能获得最大信息量。然而，仔细一想，其实这里信息论并不是因，而是果。这里不需要用信息论就完全能够解释，而且更明白。信息论只是对这个解释的一个形式化。当然，信息论在其它地方还是有应用的。但这里其实用不着信息论这么重量级的东西（也许具体计算一些数据的时候是需要的），而是只需要一种看问题的本质视角：将排序问题看成和猜数字一样，是通过问问题来缩小/排除（narrow down）结果的可能性区间，这样一来，就会发现，“最好的问题”就是那些能够均分所有可能性的问题，因为那样的话不管问题的答案如何，都能排除掉k-1/k（k为问题的答案有多少种输出——猜数字里面是2，称球里面是3）种可能性，而不均衡的问题总会有一个或一些答案分支排除掉的可能性要小于k-1/k。于是策略的下界就被拖累了。

    5. 小结

    这的确是“小结”，因为两点：

    1. 这个问题可以有信息论的理论解释，而信息论则是一个相当大的领域了。

    2. 文中提到的这种看问题的视角除了用于排序、称球，还能够运用到哪些问题上（比如搜索）。

Update(06/13/2008) : 徐宥在讨论中继续提到：

    另外，这几天我重新把TAOCP 第三卷(第二版)翻出来看了看 Knuth 怎么说这个问题的, 发现真是牛大了：

    先说性能：

pp148, section 5.2.3 说：

When N = 1000, the approximate average runiing time on MIX are 160000u for heapsort 130000u for shellsort 80000u  for quicksort

    这里,  Knuth 同学发现一般情况下 heapsort 表现很不好. 于是，在下文他就说，习题18 (pp156, 难度21)

(R.W.Floyd) During the selection phase of heapsort, the key K tends to be quite small, so that nearly all the comparisons in step H6 find K<K_j. Show how to modify the algorithm so that K is not compared with K_j in the main loop of the computation, thereby nearly cutting the average number of comparisons in half.

    答案里面的方法和DMK的方法是一样的。(我觉得DMK是看了这个论文或者TAoCP的) 这里说 by half，就正好和快排差不多了。

    再说信息论分析：

    在5.3.1 (pp181) 高爷爷就说, “排序问题可以看成是一个树上的鸟儿排排站的问题. (还特地画了一棵树), 下一段就说, 其实这个也有等价说法, 就是信息论, 我们从称球问题说起...”

   然后后面一直讲信息论和最小比较排序...

   高爷爷真不愧是姓高的，囧rz..

         我个人觉得算法里面极大一部分内容是如何有效地进行搜索，这里的"有效"可以分为：避免不必要的计算（如A*寻路以及所有的启发式剪枝），缓存重复计算（如所有­的动态规划）。当然，知道这些跟具体的设计出一个算法至少还有十万八千里，只能说有了这个大体的思路，就可以从这两个角度去审视手头的问题，往往是会有启发意义­的罢了。如何避免不必要的计算？也有很多 rules of thumb 可以遵循，如启发式剪枝里面就要求去设计一个最优下界，而最一般的思路则是使劲瞅瞅问题里面有什么条件是没有利用的，这些条件组合起来可以得出什么性质，也许某­个性质就能够被利用来减掉一大堆计算，至于如何从题目条件推出有价值的性质，有两个办法，一是试错（想到的结论都给写出来，陶哲轩在 Solving Mathematical Problems 里面就提到过这个办法。）；另一个方向则是脑袋里揣着想要实现的目的往反方向归约。如何缓存重复计算？简单的动态规划问题如fibonacci数列计算，其重复­计算是非常明显的，计算的过程本身就指明了哪些计算是重复的（An 项的计算是重复的）——当然，正如早前邓同学发的一个题目<https://groups.google.com/group/pongba/browse_frm/thread/2ca1f2bda0c8...>里面说的，其实fibonacci数列计算里面的线性变换本身也是有重复计算的——后者便是更隐蔽的重复计算了，一个 non-trivial 的动态规划问题往往涉及到非常隐蔽的重复计算，或者更难的是，你遍历组合空间的方式决定了你所能够缓存的重复计算到底有多少，也许某个遍历方式之下就没有办法去­缓存计算。当然，算法的范畴其实是很大的，算法是一个AI-Complete 的问题，所有的 Problem-Solving 过程都可以叫做算法。只是有很多实际当中的算法会掉入以上两类而已。 

    第二个问题我举一个例子：不像很多牛人在高中和本科就竞赛奖牌一堆，我直到大四的时候还不知道什么是动态规划，因为本科四年我一直只对底层技术感兴趣，最喜欢看 比如 Petzold 的《编码的奥秘》和 Richter 的《.NET 框架程序设计》（事实上这是我看的第一本英文原版书）这类书。研一的时候由于方向是自然语言处理，看的第一篇 paper 是 Rabiner 的  A Tutorial on Hidden Markov Models and Selected Applications in Speech
Recognition 。Paper 的内容倒是完全能够理解，但是理解其实只是第一步，我发现理解了之后很快就忘掉了，这就说明理解得不够深刻。比如里面的 Viterbi 算法，花了时间去理解，但是一转头很快又忘掉了。一年后因为机缘巧合，对算法发生了一段短暂的兴趣，并学习了一些基础的算法，尤其是算法的思想，因为思想是有穷­的，但算法是无穷的，尤其是题目是做不完的。之后一段时间，碰巧又需要翻一翻马可夫模型，搜出吴军的数学之美以及那篇 Paper ，发现 Viterbi 算法其实就是最简单的一类动态规划，由于对于动态规划的理解深刻了很多，所以对于 Viterbi 算法，在脑袋里面记住的不再是什么 Forward Variable/Backward Variable
之类的技术细节，而是它的本质，于是便不再容易忘掉，而即便忘掉，就如庞加莱所说，也可以非常迅速的将算法的细节自行构建出来。

       其实我相信这样的例子是数不胜数的，所以我这个只是算一个 Yet Another Example ，由于对我来说比较特殊，所以印象较为深刻。

        这个例子是关于"理解"的。有时候算法也会非常有用，如有一次写程序时需要用到 LCS 和 Edit-Distance （这样的机会很少，但遇到了时如果不知道有多项式复杂度的算法就很悲惨了），而做机器学习和数据挖掘的更是少不了一坨坨的算法，如果光是理解别人的做法然后实现­出来，那么对算法的思想的把握有助于理解和记忆；如果需要自己设计算法，那就需要算法基础知识的辅助才行了。绝大多数人应该属于前者。

         学习到什么程度？我觉得视人群而定。如果做底层开发、应用开发、系统开发，只要知道一个大概就可以了，知道经典的数据结构和算法没有任何困难，而且反正经典算法­都有现成的库可用。对于有兴趣做一点 research 沾边的事情的人，则需要了解这些算法背后的一般性思路是什么，否则来一个特定的算法你就特定的理解记忆一下，肯定不牢靠，而且浪费大脑资源。对于搞 real deal 的 original research 的那就需要广泛的知识积累了，光知道一般性思路都不够。

        另一方面，我觉得学完了经典算法，深刻理解了算法背后的一般性思路之后，如果再进一步去玩题目，做题库。效益却不是很大的，因为刀磨了是要用的，玩题目做题库就­是进一步磨刀而不用（不去解决实际问题，能够产生影响力的，或生产力的问题）。实际上做了一些题目之后就完全没必要进一步做题目了，因为做来做去，拼的基本也就­是谁的知识积累多（套路多），谁的耐心大（肯使劲去磨一道题目）；实际上谁也不比谁笨，到最后区别就基本上显露在知识积累和耐心上了。所以接着做，刀也不会磨得­更锋利，更何况大好的时光应该去做点有意义的事情（如果是为了 fun 而做题的，那么有意义的事情同样也可以是 extremely fun），比如我觉得最吸引人也最根本的问题就是人工智能问题（想想看，人脑是世界上迄今为止所知最为复杂的结构，这个结构具备了认识自然界"规律"的能力，具­备了认识"自我"的能力，具备了归纳和演绎推理的能力，类比的能力，具备了难以置信的启发式搜索能力，具备完美的模式识别能力，而根据进化论的观点，这样的结构­居然仅仅是通过变异——筛选得来的，如果真有上帝，那么利用上帝赋予我们的大脑去破解上帝这个顶级牛逼程序员写的程序——人脑的秘密，还有比这更带劲儿的事情吗­？），所以我觉得有那么好的基础的牛人，不去直面真正 fundamental 的 problems ，就可惜了，须知题目是永远做不完的，一个公理系统的定理也是永远推导不完的，永远可以设计出题目来给你做，但是真正的问题其实只有一个。如果穷举不了世界上所­有的问题，至少可以举出那些有趣、有意义的问题:)

--
刘未鹏(pongba)
Blog|C++的罗浮宫
http://blog.csdn.net/pongba