C++博客-每天多学习1个小时-随笔分类-Algorithm

线段树特辑（一，相关理论）

小火球 — Mon, 25 Oct 2010 08:28:00 GMT

摘要: 无意间在网上看到了线段树，并且对此引发的讨论也是络绎不绝呀~所以自己也对这个感兴趣起来。目前对线段树的应用领域，我可以说是完全不理解的，不过相信这个特辑做完了过后，我就能有初步的理解了，特辑包含理论以及一些关于线段树的题。OK，废话不说，先复制个理论上来。其实理论看起来还是蛮好理解的，不过实践才是王道。在一类问题中,我们需要经常处理可以映射在一个坐标轴上的一些固定线段,例如说映射在OX轴上的线... 阅读全文

小火球 2010-10-25 16:28 发表评论

直接插入排序法

小火球 — Sat, 09 Oct 2010 10:20:00 GMT

开始研究算法导论，第一个就是直接排序算法，可是看书太慢了。
所以开始寻找这个的道路。索性找到啦~一边贴上。一边用代码实现，再复制到自己的博客上，学海无涯啊~

插入排序(Insertion Sort)的基本思想是：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子文件中的适当位置，直到全部记录插入完成为止。
直接插入排序基本思想

1、基本思想
    　假设待排序的记录存放在数组R[1..n]中。初始时，R[1]自成1个有序区，无序区为R[2..n]。从i=2起直至i=n为止，依次将R[i]插入当前的有序区R[1..i-1]中，生成含n个记录的有序区。

2、第i-1趟直接插入排序：
    　通常将一个记录R[i](i=2，3，…，n-1)插入到当前的有序区，使得插入后仍保证该区间里的记录是按关键字有序的操作称第i-1趟直接插入排序。
    　排序过程的某一中间时刻，R被划分成两个子区间R[1．．i-1]（已排好序的有序区）和R[i．．n]（当前未排序的部分，可称无序区）。
    　直接插入排序的基本操作是将当前无序区的第1个记录R[i]插人到有序区R[1．．i-1]中适当的位置上，使R[1．．i]变为新的有序区。因为这种方法每次使有序区增加1个记录，通常称增量法。
    　插入排序与打扑克时整理手上的牌非常类似。摸来的第1张牌无须整理，此后每次从桌上的牌(无序区)中摸最上面的1张并插入左手的牌(有序区)中正确的位置上。为了找到这个正确的位置，须自左向右(或自右向左)将摸来的牌与左手中已有的牌逐一比较。
一趟直接插入排序方法

1．简单方法
    　首先在当前有序区R[1..i-1]中查找R[i]的正确插入位置k(1≤k≤i-1)；然后将R[k．．i-1]中的记录均后移一个位置，腾出k位置上的空间插入R[i]。
注意：
    　若R[i]的关键字大于等于R[1．．i-1]中所有记录的关键字，则R[i]就是插入原位置。

2．改进的方法
　　一种查找比较操作和记录移动操作交替地进行的方法。
具体做法：
    　将待插入记录R[i]的关键字从右向左依次与有序区中记录R[j](j=i-1，i-2，…，1)的关键字进行比较：
    　① 若R[j]的关键字大于R[i]的关键字，则将R[j]后移一个位置；
        ②若R[j]的关键字小于或等于R[i]的关键字，则查找过程结束，j+1即为R[i]的插入位置。
    　关键字比R[i]的关键字大的记录均已后移，所以j+1的位置已经腾空，只要将R[i]直接插入此位置即可完成一趟直接插入排序。

直接插入排序算法

1．算法描述（伪代码）

  void lnsertSort(SeqList R)
   { //对顺序表R中的记录R[1..n]按递增序进行插入排序
    int i，j；
    for(i=2;i<=n；i++) //依次插入R[2]，…，R[n]
      if(R[i].key<R[i-1].key){//若R[i].key大于等于有序区中所有的keys，则R[i]
                              //应在原有位置上
        R[0]=R[i];j=i-1; //R[0]是哨兵，且是R[i]的副本
        do{ //从右向左在有序区R[1．．i-1]中查找R[i]的插入位置
         R[j+1]=R[j]； //将关键字大于R[i].key的记录后移
         j-- ；
         }while(R[0].key<R[j].key)； //当R[i].key≥R[j].key时终止
        R[j+1]=R[0]； //R[i]插入到正确的位置上
       }//endif
   }//InsertSort

2．哨兵的作用
    　算法中引进的附加记录R[0]称监视哨或哨兵(Sentinel)。
   　哨兵有两个作用：
　　① 进人查找(插入位置)循环之前，它保存了R[i]的副本，使不致于因记录后移而丢失R[i]的内容；
　　② 它的主要作用是：在查找循环中"监视"下标变量j是否越界。一旦越界(即j=0)，因为R[0].key和自己比较，循环判定条件不成立使得查找循环结束，从而避免了在该循环内的每一次均要检测j是否越界(即省略了循环判定条件"j>=1")。
注意：
　 ① 实际上，一切为简化边界条件而引入的附加结点(元素)均可称为哨兵。
　　【例】单链表中的头结点实际上是一个哨兵
　　② 引入哨兵后使得测试查找循环条件的时间大约减少了一半，所以对于记录数较大的文件节约的时间就相当可观。对于类似于排序这样使用频率非常高的算法，要尽可能地减少其运行时间。所以不能把上述算法中的哨兵视为雕虫小技，而应该深刻理解并掌握这种技巧。

给定输入实例的排序过程

    　设待排序的文件有8个记录，其关键字分别为：49，38，65，97，76，13，27，49。为了区别两个相同的关键字49，后一个49的下方加了一下划线以示区别。其排序过程见【  动画演示 http://student.zjzk.cn/course_ware/data_structure/web/flashhtml/insertsort.htm】

算法分析

1．算法的时间性能分析
    　对于具有n个记录的文件，要进行n-1趟排序。
    各种状态下的时间复杂度：

初始文件状态                 正序                                 反序                           无序(平均)
第i趟的关键                      1                                       i+1                             （i-2）/2
字比较次数
总关键字比较次数          n-1                               (n+2)(n-1)/2                         ≈n²/4
第i趟记录移动次数           0                                     i+2                                （i-2）/2
总的记录移动次数            0                                 (n-1)(n+4)/2                         ≈n²/4
时间复杂度                        0（n）                           O（n²）                           O（n²）

注意：
    　初始文件按关键字递增有序，简称"正序"。
　    初始文件按关键字递减有序，简称"反序"。

2．算法的空间复杂度分析
    　算法所需的辅助空间是一个监视哨，辅助空间复杂度S(n)=O(1)。是一个就地排序。

3．直接插入排序的稳定性
    　直接插入排序是稳定的排序方法。

个人实现的C++代码也贴上：

//假设是降序排列
void InsertSort(int * nArray,int size)
{
    int i = 0;
    int j = 0;
    int nSentinel = 0;                //哨兵,用来保存nArray[i]的副本
    for(i = 1; i < size;++i)
    {
        if(nArray[i] < nArray[i-1])
        {
            nSentinel = nArray[i];
            j = i - 1;
            do
            {
                nArray[j+1] =  nArray[j];
                j--;
            } while (nSentinel < nArray[j] && j >= 0);
            nArray[j+1] = nSentinel;
        }
    }
}
int _tmain(int argc, _TCHAR* argv[])
{
    int temp[] = {15,10,33,25,40,25,11,33,55};
    InsertSort(temp,9);
    for(int i = 0; i < 9;++i)
    {
        cout << temp[i] << " ";
    }
    cout << endl;
    getchar();
    return 0;
}

直接插入排序法，针对少量的数据项排序，速度比较快，数据越大，这中方法的劣势也就越明显了。

小火球 2010-10-09 18:20 发表评论

红黑树研究之二(转C#与数据结构－树论—红黑树)

小火球 — Fri, 08 Oct 2010 05:39:00 GMT

摘要: 红黑树的平衡红黑树首先是一棵二叉查找树，它每个结点都被标上了颜色（红色或黑色），红黑树满足以下5个性质： 1、每个结点的颜色只能是红色或黑色。 2、根结点是黑色的。 3、每个叶子结点都带有两个空的黑色结点（被称为黑哨兵），如果一个结点n的只有一个左孩子，那么n的右孩子是一个黑哨兵；如果结点n只有一个右孩子，那么n的左孩子是一个黑哨兵。 4、如果一个结点是红的，则它的两个儿子都是... 阅读全文

小火球 2010-10-08 13:39 发表评论

红黑树研究之一

小火球 — Fri, 08 Oct 2010 03:12:00 GMT

这几天又开始研究新的排序算法，红黑树。工作需要，那就顺便学习了~

前言：

之所以要写这篇文章，第一个目的是为了各位朋友在查看我写的源代码之前有一个可以理解理论的文章因为红黑树还是有点难的，如果不想搞懂理论，而直接看代码，那绝对是云里雾里，不知所云。
第二个目的是我觉得网上虽然后不少我文章也在讲，但是我就是理解不上有点困难，在我参考了很多文章之后，认真阅读才慢慢摸透了其中的原理，所以我想用自己的方式来表达，希望有助于各位的朋友理解。

红黑树由来：

他是在1972年由Rudolf Bayer发明的，他称之为“对称二叉B树”，它现代的名字是Leo J. Guibas和 Robert Sedgewick 于1978年写的一篇论文中获得的。
它是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的: 它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。

红黑树性质：

1. 每个结点或红或黑。

2. 根结点为黑色。

3. 每个叶结点(实际上就是NULL指针)都是黑色的。

4. 如果一个结点是红色的,那么它的周边3个节点都是黑色的。

5. 对于每个结点,从该结点到其所有子孙叶结点的路径中所包含的黑色结点个数都一样。

讨论的前提：

1，我们只讨论往树的左边和从树的左边删除的情况，与之对称的情况一样。

2，假设我们要删除一个元素的方法都是采取删除后继节点，而非前驱节点。

3，NL或全黑表示黑空节点，也可以不用画出。

4，“=>”这个符号我们用来表示“变成”的意思。

一．插入

当红黑树中没有节点的时候，新节点直接涂黑就可以了。

当树中已有节点，我们就将新节点涂红，并且底下挂两个黑空节点。

1.1 新节点的父亲为黑色

这种情况最简单，只接插入将新节点可以了，不会出现红色警戒。

1.2 新节点的父亲为红色

这种情况出现红色警戒，并且通过红色的父亲，我们可以推出一定有一个黑色的父，并且父亲不可能为树根(树根必须为黑)。

这种情况需要修复。

1.2.1 新节点的叔叔是红色。（红叔）

图1.2.1-1

图1.2.1-2

注解：在这种情况下，我们可以通过这样的方式来修复红黑树的性质。因为遇到红色警戒所以我们首先可以想到的就是将父亲变成黑色，但这样祖父的左子树的黑高就增加了，为了达到祖父的平衡，我们红叔变成黑色，这样祖父就平衡了。但是整个祖父这颗树的高度增高了，所以再此将祖父的颜色变成红色来保持祖父这颗树的高度不变。因为祖父变成了红色，因此往上遍历。

方法：父=>黑；叔=>黑；祖=>红；往上遍历；

1.2.2 新节点的叔叔是黑色（黑叔）

图1.2.2-1

图1.2.2-2

注解：首先可以说明的是，这种情况下我们都可以通过改变颜色和旋转的方式到达平衡，并且不再出现红色警戒，因为无需往上遍历。图1.2.2-1：首先我们将红父变成黑色，祖父变成红色，然后对祖父进行右旋转。这样我们可以看到，整颗树的黑高不变，并且这颗树的左右子树也达到平衡。新的树根为黑色。因此无需往上遍历。

方法：图1.2.2-1 父=>黑；祖=>红；祖父右旋转；

图1.2.2-2 新=>黑；祖=>红；父左旋转；祖右旋转；

插入我们就算做完了，与之对称的右边插入的情况完全一样，请自己下来分析；

一．删除

删除是比较经典但也是最困难的一件事了，所以我们必须一步一步地理解。为了中途思想不混乱，请始终记住一点，下面我们删除的节点都已经表示的是实际要删除的后继节点了。因此可以得出一下结论。

首先，可以肯定的是我们要删除的节点要么是红色，要么是黑色。

其次，既然我们要删除的结点是后继节点，那么要删除的节点的左子树一定为空。所以当删除的节点为黑色时只剩下两种情况。

最后，如果删除的节点为红色，那么它必为叶子节点。(自己好好想象为什么)。

请在看下面的内容前先牢记上面的结论，这样更加方便让你理解下面的知识。

a：当删除的节点为黑色时

删黑a 删黑#p#分页标题#e#b

b：当删除的节点为红色时

上面的几附图都是很简单的。因为你可以将空节点去掉不看。所就形成了要删除的节点要么有一个右孩子，要么为叶子节点。

下面我们就开始真正的删除操作了。

2.1 删除红色节点

注解：这种情况是最简单的，因为根据上面的结论我们可以推出子节点一定为空，也就是说删除的红色节点为叶子节点。只需将这个旧节点的右孩子付给父亲的左孩子就可以了，高度不变。

方法：略

2.2 删除黑色节点

遇到黑色节点情况就将变得复杂起来，因此我们一定要慢慢来，仔细分析。

2.2.1当删除的节点有一个红色子孩子

注解：这种情况其实就是上面我们分析的三种情况之一，如图"删黑b"。这种情况是非常简单的，只需将旧节点的右孩子取代旧节点，并将子孩子的颜色变为黑色，树平衡；

方法：子取代旧；子=>黑；

2.2.2当删除的节点无左右孩子

这种情况其实就是上面我们分析的三种情况之一，如图"删黑a"。我们推出子节点一定为空，请务必记住这点，不然在后面你将很容易被混淆，父亲的颜色我们标记为绿色，是表示，父亲的颜色可为红或黑。黄色的子节点其实就是一个黑空节点，这样方便后面分析。

a：红兄

注解：当我们删除的节点拥有一个红色的兄弟时，这种情况还相对比较简单，因为兄弟为黑色，我们可以推出父亲一定为黑色。因为父节点的左树高度减一，所以我们可以通过左旋转父节点，来将节点1旋转到左边来恢复左边的高度。然后将父变成红，兄变成黑。这样整颗树的高度不变，父节点也平衡记住子节点为空所以可以删除看，这样便于理解。其实我们也可以推出1，2为空，但这里没有必要。

方法：父=>红；兄=>黑；左旋转父节点；

b ：黑兄

遇到黑兄就又麻烦了，我们又必须引入要删除的节点的侄子了。所以我们这里再次细分为b1: 黑兄双黑侄 b2: 黑兄左黑侄右红侄 b3: 黑兄右黑侄左红侄。可能你会问b4呢，双红侄的情况呢？其实双红侄的情况同属于b2,b3的情况，所以可以默认用 b2,b3其中一种情况来处理就可以了。

现在我们开始了

b1黑兄双黑侄

注解：我们首先可以肯定的是父节点的左子树高度减一了，所以我们必须想方设法来弥补这个缺陷。如果我们把父节点的右子树高度也减一（兄变成红色）那么父节点这颗树就可以保持平衡了，但整颗树的高度减一，所以我们可以判断，如果父亲是红色，那么我们可以通过把父亲变成黑色来弥补这一缺陷。但如果父亲是黑色呢，既然遇到到黑色了我们就只好往上遍历了。

方法：兄=>红；子=黑；红父=>黑;

往上遍历(黑父);

补充：其实子节点就是空节点，没有必要变。就算遍历上去，父节点也为黑

b2黑兄左黑侄右红侄

注解：绿色表示，颜色不影响修复的方式。依然我们可以肯定父节点的左子树高度减一，所以我们可以通过将父节点旋转下来并且变为黑色来弥补，但由于兄弟被旋转上去了，又导致右子树高度减一，但我们这有一个红侄，所以可以通过红侄变成黑色来弥补。父亲所在位置的颜色不变；(子为空)
方法：兄=>父色；父=>黑；侄=>黑；(子=>黑)；左旋转父节点；

b3 黑兄左红侄右黑侄

注解：绿色表示，颜色不影响修复的方式。依然我们可以肯定父节点的左子树高度减一,同样我们通过父节点左旋转到左子树来弥补这一缺陷。但如果直接旋转的话，我们可以推出左右子树将不平衡(黑父)，或者两个红色节点相遇(红父)；这样将会更加的复杂，甚至不可行。因此，我们考虑首先将兄弟所在子树右旋转，然后再左旋转父子树。这样我们就可以得到旋转后的树。然后通过修改颜色来使其达到平衡，且高度不变。
方法：侄=>父色；父=>黑;右旋转兄；左旋转父；

总结：

如果我们通过上面的情况画出所有的分支图，我们可以得出如下结论

插入操作：解决的是红-红问题

删除操作：解决的是黑-黑问题

即你可以从分支图中看出，需要往上遍历的情况为红红(插入)；或者为黑黑黑（删除）的情况，，如果你认真分析并总结所有的情况后，并坚持下来，红黑树也就没有想象中的那么恐怖了，并且很美妙；

程序样列：

Þ 通过做某些颜色修改并对p[x]做一次左旋，可以去掉x的额外黑色来把它变成单独黑色，而不破坏红黑性质。将x置为根后，当while循环测试其循环条件时循环结束。

参考文献：
博客园

http://www.cnblogs.com

http://www.cnblogs.com/abatei/archive/2008/12/17/1356565.html

http://www.cnblogs.com/abatei/archive/2008/11/17/1335031.html

小火球 2010-10-08 11:12 发表评论

多串匹配-AC自动机

小火球 — Fri, 08 Oct 2010 02:52:00 GMT

    首先简要介绍一下AC自动机：Aho-Corasick automation，该算法在1975年产生于贝尔实验室，是著名的多模匹配算法之一。一个常见的例子就是给出n个单词，再给出一段包含m个字符的文章，让你找出有多少个单词在文章里出现过。要搞懂AC自动机，先得有模式树（字典树）Trie和KMP模式匹配算法的基础知识。AC自动机算法分为3步：构造一棵Trie树，构造失败指针和模式匹配过程。
    如果你对KMP算法和了解的话，应该知道KMP算法中的next函数（shift函数或者fail函数）是干什么用的。KMP中我们用两个指针i和j分别表示，A[i-j+ 1..i]与B[1..j]完全相等。也就是说，i是不断增加的，随着i的增加j相应地变化，且j满足以A[i]结尾的长度为j的字符串正好匹配B串的前 j个字符，当A[i+1]≠B[j+1]，KMP的策略是调整j的位置（减小j值）使得A[i-j+1..i]与B[1..j]保持匹配且新的B[j+1]恰好与A[i+1]匹配，而next函数恰恰记录了这个j应该调整到的位置。同样AC自动机的失败指针具有同样的功能，也就是说当我们的模式串在Tire上进行匹配时，如果与当前节点的关键字不能继续匹配的时候，就应该去当前节点的失败指针所指向的节点继续进行匹配。
    看下面这个例子：给定5个单词：say she shr he her，然后给定一个字符串yasherhs。问一共有多少单词在这个字符串中出现过。我们先规定一下AC自动机所需要的一些数据结构，方便接下去的编程。

1 const int kind = 26;
2 struct node{
3     node *fail;       //失败指针
4     node *next[kind]; //Tire每个节点的个子节点（最多个字母）
5     int count;        //是否为该单词的最后一个节点
6     node(){           //构造函数初始化
7         fail=NULL;
8         count=0;
9         memset(next,NULL,sizeof(next));
10     }
11 }*q[500001];          //队列，方便用于bfs构造失败指针
12 char keyword[51];     //输入的单词
13 char str[1000001];    //模式串
14 int head,tail;        //队列的头尾指针

有了这些数据结构之后，就可以开始编程了：
首先，将这5个单词构造成一棵Tire，如图-1所示。

1 void insert(char *str,node *root){
2     node *p=root;
3     int i=0,index;
4     while(str[i]){
5         index=str[i]-'a';
6         if(p->next[index]==NULL) p->next[index]=new node();
7         p=p->next[index];
8         i++;
9     }
10     p->count++;     //在单词的最后一个节点count+1，代表一个单词
11 }

在构造完这棵Tire之后，接下去的工作就是构造下失败指针。构造失败指针的过程概括起来就一句话：设这个节点上的字母为C，沿着他父亲的失败指针走，直到走到一个节点，他的儿子中也有字母为C的节点。然后把当前节点的失败指针指向那个字母也为C的儿子。如果一直走到了root都没找到，那就把失败指针指向root。具体操作起来只需要：先把root加入队列(root的失败指针指向自己或者NULL)，这以后我们每处理一个点，就把它的所有儿子加入队列，队列为空。

1 void build_ac_automation(node *root){
2     int i;
3     root->fail=NULL;
4     q[head++]=root;
5     while(head!=tail){
6         node *temp=q[tail++];
7         node *p=NULL;
8         for(i=0;i<26;i++){
9             if(temp->next[i]!=NULL){
10                 if(temp==root) temp->next[i]->fail=root;
11                 else{
12                     p=temp->fail;
13                     while(p!=NULL){
14                         if(p->next[i]!=NULL){
15                             temp->next[i]->fail=p->next[i];
16                             break;
17                         }
18                         p=p->fail;
19                     }
20                     if(p==NULL) temp->next[i]->fail=root;
21                 }
22                 q[head++]=temp->next[i];
23             }
24         }
25     }
26 }

从代码观察下构造失败指针的流程：对照图-2来看，首先root的fail指针指向NULL，然后root入队，进入循环。第1次循环的时候，我们需要处理2个节点：root->next[‘h’-‘a’](节点h) 和 root->next[‘s’-‘a’](节点s)。把这2个节点的失败指针指向root，并且先后进入队列，失败指针的指向对应图-2中的(1)，(2)两条虚线；第2次进入循环后，从队列中先弹出h，接下来p指向h节点的fail指针指向的节点，也就是root；进入第13行的循环后，p=p->fail也就是p=NULL，这时退出循环，并把节点e的fail指针指向root，对应图-2中的(3)，然后节点e进入队列；第3次循环时，弹出的第一个节点a的操作与上一步操作的节点e相同，把a的fail指针指向root，对应图-2中的(4)，并入队；第4次进入循环时，弹出节点h(图中左边那个)，这时操作略有不同。在程序运行到14行时，由于p->next[i]!=NULL(root有h这个儿子节点，图中右边那个)，这样便把左边那个h节点的失败指针指向右边那个root的儿子节点h，对应图-2中的(5)，然后h入队。以此类推：在循环结束后，所有的失败指针就是图-2中的这种形式。

最后，我们便可以在AC自动机上查找模式串中出现过哪些单词了。匹配过程分两种情况：(1)当前字符匹配，表示从当前节点沿着树边有一条路径可以到达目标字符，此时只需沿该路径走向下一个节点继续匹配即可，目标字符串指针移向下个字符继续匹配；(2)当前字符不匹配，则去当前节点失败指针所指向的字符继续匹配，匹配过程随着指针指向root结束。重复这2个过程中的任意一个，直到模式串走到结尾为止。

1 int query(node *root){
2     int i=0,cnt=0,index,len=strlen(str);
3     node *p=root;
4     while(str[i]){
5         index=str[i]-'a';
6         while(p->next[index]==NULL && p!=root) p=p->fail;
7         p=p->next[index];
8         p=(p==NULL)?root:p;
9         node *temp=p;
10         while(temp!=root && temp->count!=-1){
11             cnt+=temp->count;
12             temp->count=-1;
13             temp=temp->fail;
14         }
15         i++;
16     }
17     return cnt;
18 }

对照图-2，看一下模式匹配这个详细的流程，其中模式串为yasherhs。对于i=0,1。Trie中没有对应的路径，故不做任何操作；i=2,3,4时，指针p走到左下节点e。因为节点e的count信息为1，所以cnt+1，并且讲节点e的count值设置为-1，表示改单词已经出现过了，防止重复计数，最后temp指向e节点的失败指针所指向的节点继续查找，以此类推，最后temp指向root，退出while循环，这个过程中count增加了2。表示找到了2个单词she和he。当i=5时，程序进入第5行，p指向其失败指针的节点，也就是右边那个e节点，随后在第6行指向r节点，r节点的count值为1，从而count+1，循环直到temp指向root为止。最后i=6,7时，找不到任何匹配，匹配过程结束。

小火球 2010-10-08 10:52 发表评论

求无符号整数二进制数中1的个数

小火球 — Tue, 07 Sep 2010 08:17:00 GMT

今天公司和公司同事一起讨论五子棋的时候，他给我说了他的算法
这里五子棋的算法就不说啦
不过其实他的本质：
就是计算无符号整数中二进制中1的个数的思想
对此我也记录一下

1 //获取正整数十进制的二进制数表示法
2 int get2(unsigned int n)
3 {
4     int nNum = 0;            //保存最后的数（10进制数，2进制格式）
5     bool bDouble = false;        //是否是双数
6     if(n%2 == 0)
7     {
8         nNum = 1;
9         bDouble = true;
10     }
11     for(; n > 0;n >>= 1)
12     {
13         nNum*=10;
14         nNum+=( n & 1 );
15     }
16     if(bDouble)
17     {
18         nNum -= 1;
19         nNum /= 10;
20     }
21     return nNum;
22 }
23 int main()
24 {
25     cout << get2(257);
26     getchar();
27     return 0;
28 }

就是将十进制的数以二进制的格式保存（强调“格式”两个字！）

1 //求正整数二进制中1的个数
2 int getoneNum(unsigned int n)
3 {
4     int i = 0;
5     for(; n > 0;n >>= 1)
6     {
7         i+=( n & 1 );
8     }
9     return i;
10 }
11 //测试输出
12 int main()
13 {
14     cout << getoneNum(253);
15     getchar();
16     return 0;
17 }

这样的时间复杂度是T(m)=m，取决于二进制数的位数m。如果要求在更短时间内求出，应该如何做呢？
其实大家都喜欢用的方法就是查表法，以空间换取时间。预先把结果存入表中（怎么存就自己写了呗~想一个一个算也是OK的，没有做不到，只有想不到），
然后直接通过下标就可以访问了。

1 static char tOne[256] = {
2                             1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,
3                             3,3,4,3,4,4,5,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,
4                             3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,1,2,2,3,2,3,3,4,2,
5                             3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,2,
6                             3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,
7                             5,5,6,5,6,6,7,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,
8                             3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,2,3,3,4,3,4,4,5,3,
9                             4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,2,
10                             3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,
11                             5,5,6,5,6,6,7,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,
12                             5,5,6,5,6,6,7,5,6,6,7,6,7,7,8,1
13                         };
14 int GetOneByArray(unsigned int n)
15 {
16     n -= 1;
17     int i;
18     for(i = 0;n > 0;n>>=8)
19     {
20         i += tOne[n&255];
21     }
22     return i;
23 }
24 int main()
25 {
26     cout << GetOneByArray(255);
27     getchar();
28     return 0;
29 }

这样的话，就可以直接读取1-256中1的个数了。在速度上达到的优化，通过tOne[x]就可以得到，连判断都可以不用，速度大大提升。
然后一个整型有4个字节，32位。1-256远远不够，难道要用1-2的32次方的表来保存？还是那句话，没有做不到，只有想不到。
OK，算一下如果要保存2的32次方个数的1的个数，那么这个数组的大小
至少2^32/(256/32)=512MB，哈哈，正是一般内存大小，搞定速度优化，应该还需要内存优化吧。空间换取时间也不能这么高的空间代价吧
于是需要再优化：存放1-256每个数中1的个数，然后分段查询。如上面把32位数分为4段，每段一个字节，所以有一个256大小供查询的表，比512M小太多了吧。
这样就能完成每个int数中二进制1的个数的查询了，站在巨人的肩上学习真好。

话说回来，我同事也用了这种有限的查表法来查询五子棋中某个下子点周围40个空格(当然，一般都小于40个）的状态变化，而状态就是一张表，其实也不多，数据量
比这个要大一些，不过写完的状态大概也只有几十K罢了，我还是喜欢先速度优化再内存优化的方式，因为这样可以让我最大限度的找到我个人认为比较综合有效的解决
方案。

小火球 2010-09-07 16:17 发表评论

约瑟夫环的问题

小火球 — Tue, 16 Mar 2010 01:56:00 GMT

摘要: 1/**//* 约瑟夫环问题(Josephus) 2原题： 3 用户输入M,N值，从1至N开始顺序循环数数，每数到M输出该数值，直至全部输出。写出C程序。（约瑟夫环问题 Josephus） 4 5提示： 6 &nb... 阅读全文

小火球 2010-03-16 09:56 发表评论