字符串相似度计算之LCS（longest common sequence）

作者：finallyly 出处 ：博客园（转载请注明作者和出处）

    衡量字符串的相似度有多种方法，比如：检验两个字符串之间是否具有子串关系；在某个给定操作集合中定义一个串变化到另一个串所经历的操作数（如编辑距离公式）；寻找另一个子串，该子串中的字符在两个待比较的串中都有出现，而且出现的前后顺序相同，另外我们不要求子串中的字符在待比较的串中是连续出现的，这个子串就被定义为common sequence。最长的子串被称作（longest common sequence）。

      最近做的一个项目中需要实现一个基于LCS，以LCS为核心的算法，所以参照了《算法导论》上面的介绍，自己实现了LCS。并在此博文中进行介绍，旨在给后续介绍项目算法做铺垫。

    此处给出全部实现代码和注释，供有计算文本字符串相似度（尤其是汉语字符串相似度）需求的童鞋参考。

此处设计一个类别stringprocess来完成对两个待比较的字符串的LCS的求解.

 

stringprocess.h

#pragma  once
#include  < iostream >
using   namespace  std;

class  stringprocess
{
public :
    
    stringprocess( void );
     ~ stringprocess( void );
     // 计算最大公共子序列的长度，同时填写result表格
     int  CalculateLongestCommonSequenceLen( const  wchar_t *  xpart, const  wchar_t * ypart);
     // void CreateEmptyIndexes(); // 生成一个空的Indexes组
     void  GetIndexesInfo( int *  xpartInfo, int *  ypartInfo ); // 分别返回最长公共子序列在x字符串和字符串中出现的下标。
    wstring GetLongestCommonSequence();



private :
     int   ** indexes; // 声明指向指针的指针，保存两个字符串中的最长公共序列中的字符分别出现的位置。 // 它指向一个二维指针数组，指针数组的每个成员变量都指向一个长度为len(result)整型数组
     char ** resultbuffer; // 此结构用于存放LCS算法运行过程的相关信息
     int  xpart_len; // x串的长度
     int  ypart_len; // y串的长度
    
    
    wstring result; // 最大公共子序列
    
    
 
};

 

 

类的成员函数实现文件：

 

stringprocess.cpp

#include  " StdAfx.h "
#include  " stringprocess.h "

stringprocess::stringprocess( void )
{
    indexes = NULL;
    resultbuffer = NULL;
    
}


stringprocess:: ~ stringprocess( void )
{
     if  (indexes != NULL)
    {
        cout << " indexes指针成员变量已经被分配了堆内存，需要以delete模式释放 " << endl;    
         for  ( int  i = 0 ;i < 2 ;i ++ )
        {
            delete[]indexes[i];
        }
        delete []indexes;

        cout << " indexes释放完毕 " << endl;
        
    }
     else
    {
        cout << " 指针成员变量为被分配堆内存，不需要以delete模式释放 " << endl;
    }
     if  (resultbuffer != NULL)
    {   cout << " resultbuffer指针成员变量已经被分配了堆内存，需要以delete模式释放 " << endl;    
         for  ( int  i = 0 ;i < xpart_len + 2 ;i ++ )
        {
            delete resultbuffer[i];
        }
        delete resultbuffer;
        cout << " resultbuffer释放完毕 " << endl;
    }
     else
    {
        cout << " resultbuffer指针成员变量为被分配堆内存，不需要以delete模式释放 " << endl;

    }

    
    cout << " destructor " << endl;
}
/* ********************************************************************** */
/*  返回最长公共子序列                                                                      */
/* ********************************************************************** */
wstring stringprocess::GetLongestCommonSequence()
{
     return  result;
}
/* ********************************************************************** */
/*  建立下标数组，用于保存最长公共子序列中的元素在原序列中的下标                                                                      */
/* ********************************************************************** */
/* void stringprocess::CreateEmptyIndexes()
{
    if (result.size()>0)
    {    
        //indexes指向一个二维指针数组indexes[0]储存最大公共子序列中元素在xpart中的下标；
        //indexes[1]储存最大公共子序列中元素在ypart中的下标
        indexes=new int*[2];
        for (int i=0;i<2;i++)
        {
            indexes[i]=new int[result.size()];
            memset(indexes[i],0,sizeof(int)*result.size());

        }
    

    }

} */
/* ********************************************************************** */
/*  获取最长公共子序列在原字符串中的位置                                  */
/* ********************************************************************** */
void  stringprocess::GetIndexesInfo( int   * xpartInfo,  int   * ypartInfo)
{
     for  ( int  i = 0 ;i < result.size();i ++ )
    {
        xpartInfo[i] = indexes[ 0 ][i];
        ypartInfo[i] = indexes[ 1 ][i];
    }
    
    

}

/* ********************************************************************** */
/*  求序列x和序列y的最大公共字串                                                                      */
/* ********************************************************************** */
int  stringprocess:: CalculateLongestCommonSequenceLen( const  wchar_t *  x, const  wchar_t *  y)
{     
     int  resultlen = 0 ;
     // 字符数组的实际维度要比字符串的长度多一，最后一位为'\0'元素,所以数组维度应该+1，
    xpart_len = wcslen(x);
    ypart_len = wcslen(y);
     int  lenx = xpart_len + 1 ;
     int  leny = ypart_len + 1 ;
     int  lenxx = lenx + 1 ; // 存储结果的维度把空字符串的位置算上
     int  lenyy = leny + 1 ;
     int ** LCSlen = new   int * [lenxx];
     for  ( int  i = 0 ;i < lenxx;i ++ )
    {
        LCSlen[i] = new   int [lenyy];
        memset(LCSlen[i], 0 ,lenyy * sizeof ( int ));
    }
    resultbuffer = new   char * [lenxx];
     for  ( int  i = 0 ;i < lenxx;i ++ )
    {
        resultbuffer[i] = new   char [lenyy];
        memset(resultbuffer[i], 0 ,lenyy * sizeof ( char ));
    }
     // 填充resultbuffer
     // 注意字符数组的下标最小值为零，临时储存数组的最小下标为1，0位对应为空字串
     for  ( int  i = 0 ;i < lenx;i ++ )
    {
         for  ( int  j = 0 ;j < leny;j ++ )
        {
             if  (x[i] == y[j])
            {
                LCSlen[i + 1 ][j + 1 ] = LCSlen[i][j] + 1 ;
                resultbuffer[i + 1 ][j + 1 ] = ' a ' ;
            }
             else
            {
                 if  (LCSlen[i][j + 1 ] >= LCSlen[i + 1 ][j])
                {
                    LCSlen[i + 1 ][j + 1 ] = LCSlen[i][j + 1 ];
                    resultbuffer[i + 1 ][j + 1 ] = ' b ' ;
                }
                 else
                {

                    LCSlen[i + 1 ][j + 1 ] = LCSlen[i + 1 ][j];
                    resultbuffer[i + 1 ][j + 1 ] = ' c ' ;
                }
            }


        }
    }


   resultlen = LCSlen[lenx][leny] - 1 ;
    
     // 释放对内存
     for  ( int  i = 0 ;i < lenxx;i ++ )
    {
        delete LCSlen[i];
        
    }
     if  (resultlen > 0 ) // 非空字符串
    {
         // indexes指向一个二维指针数组indexes[0]储存最大公共子序列中元素在xpart中的下标；
         // indexes[1]储存最大公共子序列中元素在ypart中的下标
        indexes = new   int * [ 2 ];
         for  ( int  i = 0 ;i < 2 ;i ++ )
        {
            indexes[i] = new   int [resultlen];
            memset(indexes[i], 0 , sizeof ( int ) * resultlen);

        }
        wchar_t  * resultchar = new  wchar_t[resultlen + 1 ]; // 类似一个栈
         int  workindex_i = lenx;
         int  workindex_j = leny;
         int  workindex_rst = resultlen;
         while (workindex_i != 0 && workindex_j != 0 )
        {
             if  (resultbuffer[workindex_i][workindex_j] == ' a ' )
            {

                resultchar[workindex_rst] = x[workindex_i - 1 ];
                 if  (x[workindex_i - 1 ] != 0 )
                {
                    indexes[ 0 ][workindex_rst] = workindex_i - 1 ;
                    indexes[ 1 ][workindex_rst] = workindex_j - 1 ;
                }
                workindex_i -- ;
                workindex_j -- ;
                workindex_rst -- ;

            }
             else
            {
                 if  (resultbuffer[workindex_i][workindex_j] == ' b ' )
                {
                    workindex_i -- ;
                }
                 else
                {
                    workindex_j -- ;
                }

            }


        }
        result.assign(resultchar,resultlen);


    }
    delete LCSlen;



    
     return  resultlen;
    

}

 

 此处需要注意的地方有该类的构造函数和析构函数的写法（该类并不在构造函数中给指针型数据成员动态申请内存）参考资料见《新手初学C++：带有指针型数据成员的类》以及如何申请高维数组的堆空间。参考资料见《c++声明二维变长数组并用memset赋0值》

另外要注意函数：CalculateLongestCommonSequenceLen，该函数计算LCS的长度，求出lcs串，并且保存LCS串中的每个字符在两个父串（待比较的字符串）中的下标。我们要注意到，将一个string转换成char数组的时候，char数组的维度应该为string的长度加1，因为char数组的最后一个元素为'\0'。另外注意到LCSLen和resultbuffer的维度要比char数组多1，这里设置0下标对应于空串。

 下面给出算法运行结果图：

  附： 主函数测试代码见《LCS算法示例的主函数调用 》