歌词VSM实现！！！

主体VSM_SetUP.cpp;

 1 /*[ar:歌词作者]
 2 [ti:歌词(歌曲)的标题]
 3 */
 4 //编写程序实现lrc(歌词) 文件的检索，检索模型要求采用向量空间模型。请将源程序和文档压缩后，一并上传。
 5 #include<iostream>
 6 
 7 #include"Document_Index.h"
 8 
 9 using namespace std;
10 void main() {
11     cout << "*****本程序实现一个向量空间模型，对（D:\暂时的）文件夹下的lrc文件进行遍历建立一个对应于歌曲名，作曲者，歌词主体的检索系统，请根据需要进行查询*****" << endl << endl;
12     cout << "*****检索出的文档编号对应的文档名字请在（检索结果.txt）内查找*****" << endl;
13     string query;
14     int select,result;
15     int isornot = 2;
16     Doc_Analysis doc_analysis;
17     doc_analysis.SETUP_Index();
18     ReQuery getResult(&doc_analysis);
19     
20     while (isornot>=1) {
21         cout << "输入查询词项：";
22         if (isornot != 2) {
23             getline(cin, query);
24         }
25         getline(cin, query);
26         
27         cout << "请选择查询模式（1为查歌曲，2为查歌手，3为查歌词主体）：";
28         cin >> select;
29         cout << "请选择返回结果的数量：";
30         cin >> result;
31         getResult.Query(query, result, select);
32         cout << "is or not(1表示继续查询，0表示退出查询) ?    " ;
33         cin >> isornot;
34     }
35 }

类的保存文件内:Document_Index.cpp和Document_Index.h

  1 #pragma once
  2 #include<iostream>
  3 #include<fstream>
  4 #include<vector>
  5 #include<math.h>
  6 #include<string>
  7 #include<iomanip>
  8 #include <stdio.h>
  9 #include<io.h>
 10 #include <windows.h>
 11 using namespace std;
 12 
 13 const static int Maxsize = 10000;
 14 const static int maxsize = 100;//a line and a smalllist
 15 
 16 //得分和相应的文档编号
 17 struct ScoreandDoc {
 18     float score;
 19     int text_number;
 20 };
 21 
 22 //包含词的所在的文档编号,词项在此文档出现的频率tf
 23 struct Word_Doc {
 24     int text_number;
 25     int text_fre;
 26 };
 27 
 28 //设计保存词项倒排记录头部的一个结构
 29 struct Index_List {//存储每个词的头项,包含单词和指向倒排记录的指针,存储df，df是包含词项的文档的数目，同时也是倒排记录的长度。next指向下一个词项
 30     float  df;
 31     string word;
 32     vector<Word_Doc> head_docID;// = nullptr;
 33     Index_List * next = nullptr;
 34 };
 35 
 36 //文档检索类，VSM的主体
 37 class Doc_Analysis {
 38 
 39     string BTEMP[Maxsize];
 40     string TEMP[maxsize];
 41     int arsize;//
 42     int tisize;
 43     Index_List * arofMusic_idList;  //歌曲作者索引的链表头
 44     Index_List * tiofMusic_idList;  //歌曲名字索引的链表头
 45     Index_List * idList;              //主体歌词倒排索引的链表头
 46     int size; //文档的词项的数目,即文档长度
 47     int allsize;//总的词数
 48      int N;                     //歌词主体文档集的大小，共有N篇文档
 49      int sizeofmusicname;          //歌词名字和歌词作者的大小
 50     string Inp_Temp_Lyrics[Maxsize];    //存放歌词主体
 51     string ti_Temp[maxsize/5];//歌曲名称和歌曲作者的暂时存放之地
 52     string ar_Temp[maxsize / 5];//歌曲名称和歌曲作者的暂时存放之地
 53 public:
 54     Doc_Analysis() {
 55         size = 0;
 56         allsize = 0;
 57         arsize = 0;
 58         tisize = 0;
 59         N = 0;
 60         idList = nullptr;
 61         arofMusic_idList = nullptr;
 62         tiofMusic_idList = nullptr;
 63     };
 64     ~Doc_Analysis() {
 65 
 66     };
 67 
 68 
 69     //把从文档中检索的词插入Inp_Temp_Words[Maxsize]，如果不在就直接插入，如果已经存在则加一个
 70 
 71     //打开文件输入歌词，对词项进行分析，把歌曲的作者和歌曲名取出，存入对应的倒排索引，但是这个索引很小，所以可以直接构建倒排索引表。参数分别为：文件名，文档的编号。先对文档内歌词的作者和调用分离出的词项最终存储在Inp_Temp_Words[Maxsize]，返回文档的词数
 72     int Doc_input(string filename, int number);
 73 
 74     //被int Doc_input(string filename, int number);调用，将分离出的词项存储在temp_Words[]中,size表示其大小，j表示其从哪一个数开始放入
 75     int Temp_Insert(string temp_words[],char T[],int &size);
 76 
 77     //对此文档的词项的表进行归并排序（按字典序）
 78     void Doc_mergesort(string *inputWord, string* Temp, int left, int right);
 79 
 80     //将此次输入的文档分词排序后得到的词项表存入最终的倒排索引中
 81     Index_List* insert_IndexList(string *inputWord, int n,int NofDoc, Index_List * idList);
 82 
 83     //歌曲名，作者，歌词主体倒排索引总体构建
 84     void SETUP_Index();// {};
 85 
 86     //返回最终查询的文档集大小
 87     int SizeOfDocSet() {
 88         return N;
 89     }
 90 
 91     //返回最终生成的歌词主体倒排索引表
 92     Index_List* tiIndex_head() {
 93         return tiofMusic_idList;
 94     };
 95 
 96     //返回最终生成的歌ming倒排索引表
 97     Index_List* DocIndex_head() {
 98         return idList;
 99     };
100 
101     //返回最终生成的作者倒排索引表
102     Index_List* arIndex_head() {
103         return arofMusic_idList;
104     };
105 
106     //此函数实现寻找指定文件夹下的指定后缀文件，并且保存其完整的路径
107     void GetAllFormatFiles(string path, vector<string>& files, string format);
108 //
109 };
110 
111 //对输入的查询词项进行分析，返回输入结果
112 class ReQuery {
113     Doc_Analysis* LMA;//歌词倒排索引的链表头
114     float *Scores;//每个查询词项的初始得分
115     float *arLength;//每个文档的长度
116     float *tiLength;
117     float *Length;
118     int N;//文档集大小
119 public:
120     ReQuery(Doc_Analysis* TEMP) {//得到Doc_Analysis返回的文档集长度和链表头
121         N = TEMP->SizeOfDocSet();
122         Scores = new float[N];
123         Length = new float[N];
124         
125         LMA = TEMP;
126         for (int i = 0; i < N; i++) {
127             Scores[i] = 0;
128             Length[i] = 0;
129         }
130     };
131     ~ReQuery() {
132         delete[] Scores;
133         delete[] Length;
134         delete[] arLength;
135         delete[] tiLength;
136     };
137 
138     //查询所有词项，对所有倒排索引表遍历一次，将每个向量的长度计算出来，初始化得分数组
139     void initialLength(Index_List * idList, float *tempLength);
140 
141     //输入查询歌词词项，输出查询结果,返回排名前k的文档编号,select 为选择的查询模式，1为查歌名，2为查歌手，3为查歌词主体
142     bool Query(string query, int k,int select=1);
143 
144     //查询某一个词是否在其中，有则返回其df，无则返回0
145     int isInner(string elem, Index_List idList[],Index_List &nowTemp);
146 
147     //某个词项对于suoyou文档的得分
148     float ScoreofaDoc(Index_List *idList, Index_List* word, int iQ);
149 
150     //进行堆排序，将所有的得分进行排序
151     bool HeapSort(float Scores[], int n,int k);
152 
153 };
154 
155 //堆排序，建立最大堆
156 class Max_Heap {
157     ScoreandDoc *Heap;
158     int size;
159     int n;
160     void siftdown(int elem);
161 public:
162     Max_Heap(int num, int max, ScoreandDoc *temp) {
163         n = num;
164         size = max;
165         Heap = temp;
166         buildHeap();
167     };
168     void buildHeap() {
169         for (int i = n / 2 - 1; i >= 0; i--)
170             siftdown(i);
171     };
172     int heapsize()const {
173         return n;
174     }
175     bool isLeaf(int pos)const {
176         return (pos >= n / 2) && (pos < n);
177     }
178     int leftchild(int pos)const {
179         return 2 * pos + 1;
180     }
181     int rightchild(int pos)const {
182         return 2 * pos + 2;
183     }
184     ScoreandDoc removemax(float it);
185 
186 };

——————————————————————————————————————————————————————————————————————————————————

  1 #pragma once
  2 #include"Document_Index.h"
  3 #include<iostream>
  4 #include<fstream>
  5 #include<vector>
  6 #include<math.h>
  7 #include<string>
  8 #include<iomanip>
  9 #include <stdio.h>
 10 #include<io.h>
 11 #include <windows.h>
 12 using namespace std;
 13 
 14 ///////////类：Doc_Analysis///////////////////////
 15 
 16 //打开文件输入歌词，对词项进行分析，把歌曲的作者和歌曲名取出，存入对应的倒排索引，但是这个索引很小，所以可以直接构建倒排索引表。参数分别为：文件名，文档的编号。调用分离出的词项最终存储在Inp_Temp_Words[Maxsize],返回歌词文档的词数
 17 int Doc_Analysis::Doc_input(string filename, int number) {
 18     ifstream fin(filename);
 19     if (!fin.is_open()) {
 20         exit(0);
 21     }
 22     N++;
 23 //    cout << "此文件夹文档数目:" << N << endl;
 24     char c[maxsize] = { '' };
 25     int ic = 0, i = 2;
 26     int numberofDoc = 0;
 27     string str;
 28     getline(fin, str);
 29 
 30     //分离出作者
 31     for (; str[i] != ']'; i++) {
 32         if (str[i] == ':'&&str[i - 1] == 'r'&&str[i - 2] == 'a') {
 33             for (; str[i] != ']'; i++) {
 34                 if (((int)str[i] >= 65) && ((int)str[i] <= 91))
 35                     c[ic++] = (int)str[i] + 32;
 36                 else
 37                     c[ic++] = str[i];
 38             }
 39             i--;
 40         }
 41     }
 42     Temp_Insert(ar_Temp,c,arsize);
 43     
 44     Doc_mergesort(ar_Temp, TEMP, 0, arsize - 1);
 45     
 46     
 47     //分离出歌名
 48     getline(fin, str);
 49     i = 2;
 50     ic = 0;
 51     for (; str[i] != ']'; i++) {
 52         if (str[i] == ':'&&str[i - 1] == 'i'&&str[i - 2] == 't') {
 53             for (; str[i] != ']'; i++) {
 54                 if (((int)str[i] >= 65) && ((int)str[i] <= 91))
 55                     c[ic++] = (int)str[i] + 32;
 56                 else
 57                     c[ic++] = str[i];
 58             }
 59             i--;
 60         }
 61     }
 62 
 63     //cout << "歌名：" << c << endl;
 64     Temp_Insert(ti_Temp,c, tisize);
 65     
 66     //遍历整个geci文档主体，每次读取一行，然后进行分析
 67     getline(fin, str);
 68     
 69     do {
 70         //cout <<"收到： " <<str << endl;
 71         ic = 0;
 72         for (i = 0; str[i] != ']'; i++);
 73         for (i++; str[i] != '
'&&str[i] != '
'&&str[i] != ''; i++) {
 74 
 75             //去掉引号后面的字符,但是如果是t的话就不去
 76             if ((int)str[i] == 39) {
 77                 while (str[i] != ' '&&str[i] != '
'&&str[i] != '
'&&str[i] != '') {
 78                     i++;
 79                     if (str[i] == 't') {
 80                         i--;
 81                         break;
 82                     }
 83                 }
 84                 if (str[i] == '
' || str[i] == '
' || str[i] == '')
 85                     break;
 86             }
 87 
 88             //除去大小写
 89             if (((int)str[i] >= 65) && ((int)str[i] <= 91))
 90                 c[ic++] = (int)str[i] + 32;
 91             else
 92                 c[ic++] = str[i];
 93         }
 94         c[ic] = '';
 95         
 96         Temp_Insert(Inp_Temp_Lyrics, c, numberofDoc);
 97         getline(fin, str);
 98     } while (!fin.eof());
 99     fin.close();
100     allsize += numberofDoc;
101 
102     //cout << "本文档最终分离出词数:" << size << endl;
103     size = numberofDoc;
104     return numberofDoc;
105 };
106 
107 //被int Doc_input(string filename, int number);调用，将分离出的词项存储在temp_Words[]中,size表示其大小
108 int Doc_Analysis::Temp_Insert(string temp_words[], char T[],int &size) {
109     const char *d = "[] -;,:/?!.()"";//以这些字符为分界符[] -;,:/?!.()"
110     char *p = NULL;
111     char *next_p = NULL;
112     p = strtok_s(T, d, &next_p);
113     while (p)
114     {
115         //cout << p << endl;
116         temp_words[size++] = p;//put the char* into temp table
117         p = strtok_s(NULL, d, &next_p);
118     }
119     
120     return size;
121 };
122 
123 //对此文档的词项的表进行归并排序（按字典序）
124 void Doc_Analysis::Doc_mergesort(string *inputWord, string* Temp, int left, int right) {
125     int i, j, k, mid = (left + right) / 2;
126     if (left == right)
127         return;
128     Doc_mergesort(inputWord, Temp, left, mid);
129     Doc_mergesort(inputWord, Temp, mid + 1, right);
130     for (i = mid; i >= left; i--)
131         Temp[i] = inputWord[i];
132     for (j = 1; j <= right - mid; j++)
133         Temp[right - j + 1] = inputWord[j + mid];
134     for (i = left, j = right, k = left; k <= right; k++)
135         if (Temp[i]<= Temp[j])
136             inputWord[k] = Temp[i++];
137         else
138             inputWord[k] = Temp[j--];
139 };
140 
141 //将此次输入的文档分词排序后得到的词项表存入最终的倒排索引中,numberofDoc为此文档分离出的词的数目，（不是词项）NofDoc为文档的编号
142 Index_List* Doc_Analysis::insert_IndexList(string *inputWord, int numberofDoc,int NofDoc, Index_List * idListx) {
143     int i = 0, j = 0;
144     Index_List* pre_idList = idListx,*idList=idListx, *idListHead = idListx;    
145     //cout << "词数" << numberofDoc << endl;
146     if (i < numberofDoc) {
147         //cout << " 当前文档的词: " << inputWord[i] << endl;
148         while ((idList != nullptr)&&(i<numberofDoc)) {//将整个倒排索引在此遍历完全,在文档也未结束的情况下
149             //1.词项和目前监测的节点值一样,则直接在其后的此词项的后面加上本文档的相关信息即可
150             if (inputWord[i] == idList->word) {
151                 //cout << "此时词项" << inputWord[i] << "已存在索引表中" << endl;
152                 Word_Doc *temp = new Word_Doc;
153                 temp->text_number = NofDoc;//这个词项的文档编号,把所有相同的词项合并在一起
154                 temp->text_fre = 0;//肯定已经在这个文档出现了一次
155                 do {
156                     temp->text_fre++;
157                     i++;
158                     if (i == numberofDoc)
159                         break;
160                 } while (inputWord[i] == idList->word);//只有当文档检测的词项不一样时退出
161 
162                 idList->df++;//出现该词项的文档数增1，应该为df
163 
164                 idList->head_docID.push_back(*temp);
165                 
166                 /*cout << (idList->head_docID)[idList->head_docID.size() - 1].text_number << endl;*/
167                 
168                 pre_idList = idList;//前一个链表值
169 
170                 //print2(idList);//查看这个idList的具体值
171 
172                 idList = idList->next;//索引表下移
173             }
174             //2.当这个词项比当前索引的词项小时，说明词项肯定在倒排索引中排在当前词项的前面，则将其插入在其之前，注意区分第一个和中间的
175             else if (inputWord[i] < idList->word) {
176                 //cout << inputWord[i] << "比索引表的——" << idList->word << " 小" << endl;
177                 Index_List* newidList = new Index_List;
178                 vector<Word_Doc> forID ;//因为是单独建一个词项的索引，故建立存储倒排索引的容器
179                 Word_Doc *temp = new Word_Doc;
180                 temp->text_number = NofDoc;
181                 temp->text_fre = 0;//肯定已经出现过一次,把所有相同的词项合并在一起
182                 if (idList->word==pre_idList->word) {
183                     //cout << "这个词即将插入索引头。" << endl;
184                     idListHead = newidList;
185                 }
186                 else {
187                     pre_idList->next = newidList;
188                 }
189                 do {
190                     temp->text_fre++;
191                     i++;
192                     if (i == numberofDoc)
193                         break;
194                 } while (inputWord[i] == inputWord[i - 1]);//只有当文档检测的词项不一样时退出
195                 
196                 forID.push_back(*temp);
197 
198                 newidList->df = 1;
199                 newidList->next = idList;
200                 
201                 pre_idList = newidList;
202                 newidList->word = inputWord[i-1];
203                 newidList->head_docID = forID;
204 
205 
206             }
207             //3.当目前文档的词比索引的词项大时，倒排索引表向后走
208             else {
209                 //cout << inputWord[i] << "比索引表的——" << idList->word << " 大" << endl;
210 
211                 pre_idList = idList;
212                 //cout << idList->word << endl;
213                 idList = idList->next;
214             }
215         }
216         //idList==nullptr,,,if条件句成立意味着倒排索引表已经到达尾部，接下来的所有词项都大于索引表内任何词项，可以直接插入，注意区分第一个和中间的
217         while (i < numberofDoc) {
218             idList = new Index_List;
219             if (idListHead == nullptr) {//如果是
220                 pre_idList = idList;
221                 idListHead = idList;
222             }
223             else {
224                 pre_idList->next = idList;
225             }
226             
227             vector<Word_Doc> forID;//建立存储这个词项的倒排索引的容器
228             Word_Doc *temp = new Word_Doc;
229             temp->text_number = NofDoc;
230             temp->text_fre = 0;
231             do {
232                 temp->text_fre++;
233                 i++;
234                 if (i == numberofDoc)
235                     break;
236                 
237             } while (inputWord[i] == inputWord[i - 1]);//把所有相同的词项合并在一起,只有词项不一致时才退出
238             forID.push_back(*temp);
239 
240             idList->df = 1;
241             
242             pre_idList = idList;
243             idList->word = inputWord[i-1];
244             idList->head_docID = forID;
245 
246             //print2(idList); 
247             idList = idList->next;
248         }
249     }
250     //print1(idListHead);
251     return idListHead;
252 };
253 
254 //歌曲名，作者，歌词主体倒排索引总体构建
255 void Doc_Analysis::SETUP_Index(){
256     int i;
257     string tx_filePath = "", filePath = "D:\暂时的", distAll = "检索结果.txt", format = ".lrc";
258     vector<string> files;
259 
260     GetAllFormatFiles(filePath, files, format);
261     distAll = filePath + "\" + distAll;
262     ofstream ofn(distAll);
263     int tsize = files.size();
264     cout << "文件夹下的.lrc数目：" << tsize << endl;//查询出文件夹下文档的数目
265     for (i = 0; i < tsize; i++)//一次遍历，每检索一个文档将其存入相应的缓冲区，然后建立倒排索引
266     {
267         ofn <<"文档"<<i<<"： "<< files[i] << endl; // 写入文件  
268         Doc_input(files[i], i);
269         Doc_mergesort(ar_Temp, TEMP, 0, arsize-1);
270         Doc_mergesort(ti_Temp, TEMP, 0, tisize-1);
271         Doc_mergesort(Inp_Temp_Lyrics,BTEMP, 0, size-1);
272     
273         //插入倒排索引
274 
275         arofMusic_idList = insert_IndexList(ar_Temp, arsize, i, arofMusic_idList);
276         tiofMusic_idList = insert_IndexList(ti_Temp, tisize, i, tiofMusic_idList);
277         idList=insert_IndexList(Inp_Temp_Lyrics, size, i, idList);
278     
279 
280         arsize = 0;
281         tisize = 0;
282         size = 0;
283         
284         //cout << "索引链表内容如下：" << endl;
285         //cout << "作者：" << endl;
286         //print1(arofMusic_idList);
287         //cout << "歌名：" << endl;
288         //print1(tiofMusic_idList);
289         //cout << "主体：" << endl;
290         //print1(idList)
291         //insert_IndexList(ti_Temp, arsize, i, tiofMusic_idList);
292         //insert_IndexList(Inp_Temp_Lyrics, arsize, i, idList);
293     }
294     //至此，索引构建完毕
295     /*cout << "主体：" << endl;
296     print1(idList);*/
297     ofn <<endl<< "文件夹下的.lrc数目：" << tsize << endl;
298     cout << endl;
299     ofn << "检索出词数(非词项数)：" << allsize << endl;
300     ofn.close();
301     cout << "一共检索出词数(非词项数)：" << allsize << endl;
302     cout << "歌曲名索引构建完毕！！！" << endl;
303     cout << "作曲者索引构建完毕！！！" << endl;
304     cout << "歌词主体索引构建完毕！！！" << endl;
305     cout << endl;
306 };
307 
308 //此函数实现寻找指定文件夹下的指定后缀文件，并且保存其完整的路径
309 void Doc_Analysis::GetAllFormatFiles(string path, vector<string>& files, string format)
310 {
311     //文件句柄    
312     long   hFile = 0;
313     //文件信息    
314     struct _finddata_t fileinfo;
315     string p;
316     if ((hFile = _findfirst(p.assign(path).append("\*" + format).c_str(), &fileinfo)) != -1)
317     {
318         do
319         {
320             if ((fileinfo.attrib &  _A_SUBDIR))
321             {
322                 if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)
323                 {
324                     files.push_back(p.assign(path).append("\").append(fileinfo.name));
325                     GetAllFormatFiles(p.assign(path).append("\").append(fileinfo.name), files, format);
326                 }
327             }
328             else
329             {
330                 files.push_back(p.assign(path).append("\").append(fileinfo.name));; //将文件路径保存，也可以只保存文件名:    p.assign(fileinfo.name)
331             }
332         } while (_findnext(hFile, &fileinfo) == 0);
333 
334         _findclose(hFile);
335     }
336 };
337 
338 
339 ////////////////////类：ReQuery////////////////////
340 
341 //查询所有词项，对倒排索引表遍历一次，初始化得分数组
342 
343 void ReQuery::initialLength(Index_List * idList, float *tempLength) {
344     float idf;//记录log N/df
345     int size;
346     int i;
347     
348     while (idList != nullptr) {
349         idf = log(N/idList->df) / log(10);
350         size = idList->head_docID.size();
351         i = 0;
352         for (; i < size; i++) {
353             tempLength[idList->head_docID[i].text_number] += (idf*(1 + log(idList->head_docID[i].text_fre) / log(10)))*(idf*(1 + log(idList->head_docID[i].text_fre) / log(10)));
354         }
355         idList = idList->next;
356     }
357     for (i = 0; i < N; i++)
358         tempLength[i] = sqrt(tempLength[i]);
359     /*for (int i = 0; i < LMA->SizeOfDocSet();i++)
360         cout << "文档" << i <<" 长度为 "<< tempLength[i] << endl;*/
361 }
362 
363 //输入查询词项，输出查询结果,返回排名前k的文档编号,select 为选择的查询模式，1为查歌名，2为查歌手，3为查歌词主体
364 bool ReQuery::Query(string query, int k, int select) {
365     Index_List QUERY[10];
366     char aa[50] = { '' };
367     int ia = 0, i = 0, iQ = 0, j = 0;
368     
369     for (; i<query.length(); i++) {
370         while (query[i] != ' '&& i < query.length()) {
371             if (((int)query[i] >= 65) && ((int)query[i] <= 91))
372                 aa[ia++] = query[i++] + 32;
373             else
374                 aa[ia++] = query[i++];
375         }
376             
377         aa[ia] = '';
378         for (; j < iQ; j++) {
379             if (QUERY[j].word == aa) {
380                 QUERY[j].df++;
381                 j = -1;
382                 break;
383             }
384         }
385         if (j != -1) {
386             QUERY[iQ++].word = aa;
387             QUERY[iQ-1].df = 1;
388         }
389         j = 0;
390         ia = 0;
391         //cout << f[ic1 - 1] << endl;
392     }
393 
394     //查歌名
395     if (select == 1) {
396         initialLength(LMA->tiIndex_head(), Length);
397         //计算查询de得分
398         ScoreofaDoc(LMA->tiIndex_head(), QUERY, iQ);
399     }
400     //查作者
401     if (select == 2) {
402         initialLength(LMA->arIndex_head(), Length);
403         //计算查询de得分
404         ScoreofaDoc(LMA->arIndex_head(), QUERY, iQ);
405     }
406     //查歌词主体
407     if (select == 3) {
408         initialLength(LMA->DocIndex_head(), Length);
409         //计算查询de得分
410         ScoreofaDoc(LMA->DocIndex_head(), QUERY, iQ);
411     }
412     /*for (int i = 0; i < N; i++) {
413         cout << Scores[i] << endl;
414     }*/
415     //对得分数组建堆，并且返回前K个
416     HeapSort(Scores, N, k);
417     return true;
418 };
419 
420 //词项对于suoyou文档的得分
421 float ReQuery::ScoreofaDoc(Index_List *idList, Index_List Tword[],int iQ) {
422     int size = 0;
423     int df;
424     float idf;
425     Word_Doc TEMPS;
426     Index_List nowTemp;
427     for (int i = 0; i < iQ;i++) {
428         
429         if ((df = isInner(Tword[i].word,idList,nowTemp)) != 0) {
430             idf = log(N/df) / log(10);
431             size =nowTemp.head_docID.size();
432             for (int j = 0; j < size; j++) {
433                 TEMPS = (nowTemp.head_docID)[j];
434                 Scores[TEMPS.text_number] += ((idf)*Tword[i].df)*(idf*(1 + log(nowTemp.head_docID[j].text_fre) / log(10)));
435             }
436         }
437     }
438     cout <<endl <<"各文档依次得分：" << endl;
439     for (int i = 0; i < N; i++) {
440         if(Scores[i]!=0)
441             Scores[i] = Scores[i]/ Length[i];
442         cout << Scores[i] <<" ";
443     }
444     return 0;
445 }
446 
447 //查询某一个词是否在其中，有则返回其df，无则返回0
448 int ReQuery::isInner(string elem, Index_List idList[], Index_List &nowTemp) {
449     int i = 0;
450     //cout << "查找单词" << elem << endl;
451     while (idList != nullptr) {
452         if (idList[i].word == elem) {
453             //cout << "单词" << elem << "在其中,文档编号"<<idList[i].head_docID[0].text_number<<endl;
454             nowTemp = idList[i];
455             return idList->df;
456         }
457         if (idList->word > elem)
458             return 0;
459         idList = idList->next;
460     };
461     return 0;
462 }
463 
464 //进行堆排序，将所有的得分进行排序,找出前k个,n为数组大小
465 bool ReQuery::HeapSort(float Scores[],int n,int k) {
466     float doc = -1;
467     int i = 0;
468     ScoreandDoc *TScores = new ScoreandDoc[n];
469     for (; i < n; i++) {
470         TScores[i].score = Scores[i];
471         TScores[i].text_number = i;
472     }
473 
474     Max_Heap H(n, n, TScores);
475     i = 0;
476     cout << endl << endl << "---------------------向您推荐如下文档--------------------------------" << endl;
477     for (; i < k; i++) {
478         ScoreandDoc temp= H.removemax(doc);
479         cout << "文档编号：" << temp.text_number << " 得分：" << temp.score << endl;
480     }
481 
482     cout << endl;
483     delete[]TScores;
484     return true;
485 
486 };
487 
488 //////////////////////////////lei Max_Heap///////////////////////////
489 //堆建立
490 
491 //建立整堆
492 void Max_Heap::siftdown(int pos) {
493     while (!isLeaf(pos)) {
494         int j = leftchild(pos);
495         int rc = rightchild(pos);
496         if ((rc < n) && (Heap[j].score < Heap[rc].score)) {
497             j = rc;
498         }
499         if (!(Heap[pos].score < Heap[j].score))
500             return;
501         ScoreandDoc xxx = Heap[pos];
502         Heap[pos] = Heap[j];
503         Heap[j] = xxx;
504         pos = j;
505     }
506 };
507 
508 
509 //每次找出移除最大的
510 ScoreandDoc Max_Heap::removemax(float it) {
511     //if (n == 0)
512     //    return ;
513     ScoreandDoc xxx = Heap[--n];
514     Heap[n] = Heap[0];
515     Heap[0] = xxx;
516     if (n != 0)
517         siftdown(0);
518     //it = Heap[n].score;
519     return Heap[n];
520 }