search花絮之堆合并

大规模词库的词汇检索是一个非常耗时的操作，所以其数据结构一般都是需要经过仔细设计的。单位里原有一个堆结构，最近将它模板化，并在它基础上做模糊查询。但原来没有词库的归并算法，这些日子不得不重新实现一个。算法的难点在于寻找合适的子块进行move操作以及调整该子块的所有相关指针。

下面是测试例子之一：

int _tmain(int argc, _TCHAR* argv[])

{

     CWordIndex<char,string> index1(IC_ASCII),index2(IC_ASCII);

     char* p1 = "lee lieve life and zoe";

     char* p2 = "love book zero a land";

     index1.BuildWordIndexFromMemory(p1,strlen(p1),' ',5);

     index2.BuildWordIndexFromMemory(p2,strlen(p2),' ',5);

 

     cout<<"index1.string:/t"<<p1<<"/n"

         <<"index2.string:/t"<<p2<<"/n"

         <<"index3 = index1 + index2/n";

     cout<<"/n***************index1***************/n";

     index1.PrintWordIndex(cout);

     cout<<"/n***************index2***************/n";

     index2.PrintWordIndex(cout);

 

     cout<<"/n***************index3***************/n";

     if( index1.MergeLib(&index2) )

     {

         index1.PrintWordIndex(cout);

     }

     else

     {

         cout<<"MergeLib(index1,index2) failed./n/n";

     }

 

     return 0;

}

 

下面是该例子的输出：

 

index1.string:  lee lieve life and zoe

index2.string:  love book zero a land

index3 = index1 + index2

 

***************index1***************

 

WordIndex:

a       [0,1)

l       [2,4)

z       [10,11)

 

HeapIndex:

0       n       0       [1,2)

1       d       -1      [0,0)

2       e       0       [4,5)

3       i       0       [5,7)

4       e       -1      [0,0)

5       e       0       [7,8)

6       f        0       [9,10)

7       v       0       [8,9)

8       e       -1      [0,0)

9       e       -1      [0,0)

10      o       0       [11,12)

11      e       -1      [0,0)

 

***************index2***************

 

WordIndex:

a                       1ch_word

b       [0,1)

l       [3,5)

z       [9,10)

 

HeapIndex:

0       o       0       [1,2)

1       o       0       [2,3)

2       k       -1      [0,0)

3       a        0       [5,6)

4       o       0       [7,8)

5       n       0       [6,7)

6       d       -1      [0,0)

7       v       0       [8,9)

8       e       -1      [0,0)

9       e       0       [10,11)

10      r       0       [11,12)

11      o       -1      [0,0)

 

***************index3***************

 

WordIndex:

a       [0,1)           1ch_word

b       [2,3)

l       [5,9)

z       [19,21)

 

HeapIndex:

0       n       0       [1,2)

1       d       -1      [0,0)

2       o       0       [3,4)

3       o       0       [4,5)

4       k       -1      [0,0)

5       a        0       [9,10)

6       e       0       [11,12)

7       i       0       [12,14)

8       o       0       [17,18)

9       n       0       [10,11)

10      d       -1      [0,0)

11      e       -1      [0,0)

12      e       0       [14,15)

13      f        0       [16,17)

14      v       0       [15,16)

15      e       -1      [0,0)

16      e       -1      [0,0)

17      v       0       [18,19)

18      e       -1      [0,0)

19      e       0       [21,22)

20      o       0       [23,24)

21      r       0       [22,23)

22      o       -1      [0,0)

23      e       -1      [0,0)

Press any key to continue

 

    不禁想到SegWord中要做词汇散列的想法。好的散列检索明确的词汇时速度应该比这个堆快，而且归并与插入的代价也远比这个低，但散列中如何进行快速的模糊查询（比如“z+o+”）？