位置信息倒排索引K词近邻搜索算法实现

位置信息索引是在倒排索引的基础上实现的，在倒排记录表中添加了词项在文档中的位置信息。位置信息一般以下面的方式存储到倒排记录中：

文档ID：（位置1，位置2，…）

而完整的包含位置信息的倒排记录表如下图所示：



以图中一个倒排记录为例，to是此项，993427为to的文档频率，即在993427篇文档中出现。最外层的括号中，1,2,4,5,7是包含to的文档ID，这里只列出5个，文档ID后是to的词频，即to在文档中出现的次数。最后内层的括号中即to在文档中的位置信息，以对文档开头的偏移量来表示。有了这“强化”过后的倒排索引表，我们可以对倒排索引查询的功能进行扩展。而这次我带来的是基于位置信息的倒排索引K词近邻搜索算法的实现，具体的含义就是对两个词项进行搜索，可规定两个词项在文档中的间隔。

举个例子：某个查询为to be or not to be，我们只看to be，to与be是挨着的，也就是说间隔k为0个词。首先，查找同时包含这两个词项的文档；然后，检查表中的位置看看是否有某个be的前面一个词条位置上正好出现to。下面中给出的倒排记录表中，可能存在的一个匹配为：

to: 〈. . . ; 4: 〈. . . ,429,433〉; . . . 〉
be: 〈. . . ; 4: 〈 . . ,430,434〉; . . . 〉

本文中给出的算法来源于《信息检索导论》一书中，王斌翻译，书中给出了算法伪代码。另外我的算法实现是在课程结束之后完成的，JAVA写的，只是很单纯的实现，代码写得也比较差劲，不值得拿来做研究使用，只是贴出来给大家进行参考。下面给出代码和索引文件。

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

import javax.annotation.PostConstruct;

public class PositionalIndex {

public PositionalIndex() {
// TODO Auto-generated constructor stub
//LTerm = new ArrayList<String>();
//LPostingList = new ArrayList<String>();
}

@SuppressWarnings("resource")
/******************** 按词条搜索出对应的倒排记录******************/
public static String findPostingList(String term)
{
List<String> LTerm = new ArrayList<>();
String szPostingList = "";
File file = new File("bin/Index.txt");				//读出倒排记录表文件
String szTermAndPosting;
String szSub;
//StringTokenizer szToken = null;
BufferedReader br =null;
int iSplitIndex;
try
{
br = new BufferedReader(new FileReader(file));
while((szTermAndPosting = br.readLine())!=null)				//按行读取出一条倒排记录
{
iSplitIndex = szTermAndPosting.indexOf(",");			//按','划分倒排记录
szSub = szTermAndPosting.substring(0, iSplitIndex);		//得到词项
szSub.trim();
if(term.equals(szSub))									//判断搜索词条与词项是否匹配
{
LTerm.add(term);
iSplitIndex = szTermAndPosting.indexOf(":");		//划分文档频率与倒排记录
szSub = szTermAndPosting.substring(iSplitIndex+1);	//得到倒排记录

//szSub = szSub.substring(iSplitIndex+1);
szPostingList += szSub;
break;
}
}
br.close();
}
catch(Exception e){}

return szPostingList;											//返回倒排记录
}

/***********************根据k值来搜索出倒排记录表中间隔小于k的文档列表**************************/
public static List<String> PosIntersect(String termAndpList_1,String termAndpList_2,int k)
{
List<String> LAns = new ArrayList<>();
StringTokenizer strToken;
List<String> szTerm_1 = new ArrayList<>(),szTerm_2 = new ArrayList<>();
List<String> szPList_1 = new ArrayList<>(),szPList_2 = new ArrayList<>();			//倒排记录
int iDocID_1,iDocID_2;
List<String> LtermAndList_1 = new ArrayList<>(),LtermAndList_2 = new ArrayList<>();

strToken = new StringTokenizer(termAndpList_1, ";");								//按';'划分倒排记录
while(strToken.hasMoreTokens())
{
LtermAndList_1.add(strToken.nextToken());										//文档id+位置信息
}

strToken = new StringTokenizer(termAndpList_2, ";");
while(strToken.hasMoreTokens())
{
LtermAndList_2.add(strToken.nextToken());
}

for(int i = 0,j = 0;i<LtermAndList_1.size()&&j<LtermAndList_2.size();)
{
strToken = new StringTokenizer(LtermAndList_1.get(i)," ");						//划分文档id+位置信息
szTerm_1.add(strToken.nextToken());
szPList_1.add(strToken.nextToken());											//位置信息

strToken = new StringTokenizer(LtermAndList_2.get(j), " ");
szTerm_2.add(strToken.nextToken());
szPList_2.add(strToken.nextToken());

int iSplitIndex = szTerm_1.get(i).indexOf(",");
iDocID_1 = Integer.parseInt(szTerm_1.get(i).substring(0, iSplitIndex));			//得到文档id
iSplitIndex = szTerm_2.get(i).indexOf(",");
iDocID_2 = Integer.parseInt(szTerm_2.get(j).substring(0, iSplitIndex));

/******************两个倒排记录根据文档id号进行比较*********************/
if(iDocID_1 == iDocID_2)														//判断倒排记录中相同的文档
{
List<String> Ltemp = new ArrayList<>();
List<String> Lposting_1 = new ArrayList<>();
List<String> Lposting_2 = new ArrayList<>();
StringTokenizer szPostingToken = new StringTokenizer(szPList_1.get(i),",");		//划分位置信息
while(szPostingToken.hasMoreTokens())
{
Lposting_1.add(szPostingToken.nextToken());
}
szPostingToken = new StringTokenizer(szPList_2.get(j),",");
while(szPostingToken.hasMoreTokens())
{
Lposting_2.add(szPostingToken.nextToken());
}
for(int p=0;p<Lposting_1.size();p++)
{
for(int q=0;q<Lposting_2.size();q++)
{
if(Math.abs(Integer.parseInt(Lposting_1.get(p))-Integer.parseInt(Lposting_2.get(q)))<=k)	//计算文档中词项之间的距离与k进行比较
{
Ltemp.add(Lposting_2.get(q));				//将与Lposting_1中位置相比符合条件的Lposting_2的位置信息进行存储
}
else if(Integer.parseInt(Lposting_2.get(q))>Integer.parseInt(Lposting_1.get(p)))
break;
}
/*for(int x=0;x<Ltemp.size()&&Math.abs(Integer.parseInt(Ltemp.get(x))-Integer.parseInt(Lposting_1.get(p)))>k;x++)
{
Ltemp.remove(0);
}*/
for(int x=0;x<Ltemp.size();x++)
{
String ansTemp = Integer.toString(iDocID_1)+","+Lposting_1.get(p)+","+Ltemp.get(x);			//将与Lposting_1比较符合条件的Ltemp中的位置信息组合成字符串进行存储
LAns.add(ansTemp);
}
Ltemp.clear();
}
i++;j++;

}
else if(iDocID_1<iDocID_2)					//iDocID_1<iDocID_2，IDocID_1的序号+1
i++;
else j++;									//同理，IDocID_2的序号+1,返回继续比较
}

return LAns;

}
/**
* @param args
* @throws IOException
*/
public static void main(String[] args){
// TODO Auto-generated method stub
String sztermAndpList_1 ;		//词条与倒排记录
String sztermAndpList_2 ;
String szReadline;
String szTerm_1;				//词条
String szTerm_2;
int k;
BufferedR
4000
eader Stdin = new BufferedReader(new InputStreamReader(System.in));
try
{
while((szReadline = Stdin.readLine())!=null&&!szReadline.equals("exit"))	//控制台输入，exit退出
{
List<String> LAnswer = new ArrayList<>();
StringTokenizer szArgsToken = new StringTokenizer(szReadline," ");		//按空格划分出词条
szTerm_1 = szArgsToken.nextToken();
szTerm_2 = szArgsToken.nextToken();
k = Integer.parseInt(szArgsToken.nextToken());							//划分出k值
sztermAndpList_1 = findPostingList(szTerm_1);							//按词条得出词项倒排记录组
sztermAndpList_2 = findPostingList(szTerm_2);
LAnswer = PosIntersect(sztermAndpList_1, sztermAndpList_2, k);			//存储结果
if(LAnswer.size()==0)													//输出
System.out.println("not found...");
for(int i=0;i<LAnswer.size();i++)
System.out.println(LAnswer.get(i));
}
Stdin.close();
}
catch(IOException e){}
}
}

下面是索引文件Index.txt截图，倒排记录间隔的符号是规定好的，方便程序中对各部分的划分。索引是手动构建的，并非使用程序构建。