歌词VSM实现！！！

主体VSM_SetUP.cpp;

/*[ar:歌词作者]
[ti:歌词(歌曲)的标题]
*/
//编写程序实现lrc(歌词) 文件的检索，检索模型要求采用向量空间模型。请将源程序和文档压缩后，一并上传。
#include<iostream>

#include"Document_Index.h"

using namespace std;
void main() {
    cout << "*****本程序实现一个向量空间模型，对（D:\暂时的）文件夹下的lrc文件进行遍历建立一个对应于歌曲名，作曲者，歌词主体的检索系统，请根据需要进行查询*****" << endl << endl;
    cout << "*****检索出的文档编号对应的文档名字请在（检索结果.txt）内查找*****" << endl;
    string query;
    int select,result;
    int isornot = 2;
    Doc_Analysis doc_analysis;
    doc_analysis.SETUP_Index();
    ReQuery getResult(&doc_analysis);
    
    while (isornot>=1) {
        cout << "输入查询词项：";
        if (isornot != 2) {
            getline(cin, query);
        }
        getline(cin, query);
        
        cout << "请选择查询模式（1为查歌曲，2为查歌手，3为查歌词主体）：";
        cin >> select;
        cout << "请选择返回结果的数量：";
        cin >> result;
        getResult.Query(query, result, select);
        cout << "is or not(1表示继续查询，0表示退出查询) ?    " ;
        cin >> isornot;
    }
}

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

#pragma once
#include<iostream>
#include<fstream>
#include<vector>
#include<math.h>
#include<string>
#include<iomanip>
#include <stdio.h>
#include<io.h>
#include <windows.h>
using namespace std;

const static int Maxsize = 10000;
const static int maxsize = 100;//a line and a smalllist

//得分和相应的文档编号
struct ScoreandDoc {
    float score;
    int text_number;
};

//包含词的所在的文档编号,词项在此文档出现的频率tf
struct Word_Doc {
    int text_number;
    int text_fre;
};

//设计保存词项倒排记录头部的一个结构
struct Index_List {//存储每个词的头项,包含单词和指向倒排记录的指针,存储df，df是包含词项的文档的数目，同时也是倒排记录的长度。next指向下一个词项
    float  df;
    string word;
    vector<Word_Doc> head_docID;// = nullptr;
    Index_List * next = nullptr;
};

//文档检索类，VSM的主体
class Doc_Analysis {

    string BTEMP[Maxsize];
    string TEMP[maxsize];
    int arsize;//
    int tisize;
    Index_List * arofMusic_idList;  //歌曲作者索引的链表头
    Index_List * tiofMusic_idList;  //歌曲名字索引的链表头
    Index_List * idList;              //主体歌词倒排索引的链表头
    int size; //文档的词项的数目,即文档长度
    int allsize;//总的词数
     int N;                     //歌词主体文档集的大小，共有N篇文档
     int sizeofmusicname;          //歌词名字和歌词作者的大小
    string Inp_Temp_Lyrics[Maxsize];    //存放歌词主体
    string ti_Temp[maxsize/5];//歌曲名称和歌曲作者的暂时存放之地
    string ar_Temp[maxsize / 5];//歌曲名称和歌曲作者的暂时存放之地
public:
    Doc_Analysis() {
        size = 0;
        allsize = 0;
        arsize = 0;
        tisize = 0;
        N = 0;
        idList = nullptr;
        arofMusic_idList = nullptr;
        tiofMusic_idList = nullptr;
    };
    ~Doc_Analysis() {

    };


    //把从文档中检索的词插入Inp_Temp_Words[Maxsize]，如果不在就直接插入，如果已经存在则加一个

    //打开文件输入歌词，对词项进行分析，把歌曲的作者和歌曲名取出，存入对应的倒排索引，但是这个索引很小，所以可以直接构建倒排索引表。参数分别为：文件名，文档的编号。先对文档内歌词的作者和调用分离出的词项最终存储在Inp_Temp_Words[Maxsize]，返回文档的词数
    int Doc_input(string filename, int number);

    //被int Doc_input(string filename, int number);调用，将分离出的词项存储在temp_Words[]中,size表示其大小，j表示其从哪一个数开始放入
    int Temp_Insert(string temp_words[],char T[],int &size);

    //对此文档的词项的表进行归并排序（按字典序）
    void Doc_mergesort(string *inputWord, string* Temp, int left, int right);

    //将此次输入的文档分词排序后得到的词项表存入最终的倒排索引中
    Index_List* insert_IndexList(string *inputWord, int n,int NofDoc, Index_List * idList);

    //歌曲名，作者，歌词主体倒排索引总体构建
    void SETUP_Index();// {};

    //返回最终查询的文档集大小
    int SizeOfDocSet() {
        return N;
    }

    //返回最终生成的歌词主体倒排索引表
    Index_List* tiIndex_head() {
        return tiofMusic_idList;
    };

    //返回最终生成的歌ming倒排索引表
    Index_List* DocIndex_head() {
        return idList;
    };

    //返回最终生成的作者倒排索引表
    Index_List* arIndex_head() {
        return arofMusic_idList;
    };

    //此函数实现寻找指定文件夹下的指定后缀文件，并且保存其完整的路径
    void GetAllFormatFiles(string path, vector<string>& files, string format);
//
};

//对输入的查询词项进行分析，返回输入结果
class ReQuery {
    Doc_Analysis* LMA;//歌词倒排索引的链表头
    float *Scores;//每个查询词项的初始得分
    float *arLength;//每个文档的长度
    float *tiLength;
    float *Length;
    int N;//文档集大小
public:
    ReQuery(Doc_Analysis* TEMP) {//得到Doc_Analysis返回的文档集长度和链表头
        N = TEMP->SizeOfDocSet();
        Scores = new float[N];
        Length = new float[N];
        
        LMA = TEMP;
        for (int i = 0; i < N; i++) {
            Scores[i] = 0;
            Length[i] = 0;
        }
    };
    ~ReQuery() {
        delete[] Scores;
        delete[] Length;
        delete[] arLength;
        delete[] tiLength;
    };

    //查询所有词项，对所有倒排索引表遍历一次，将每个向量的长度计算出来，初始化得分数组
    void initialLength(Index_List * idList, float *tempLength);

    //输入查询歌词词项，输出查询结果,返回排名前k的文档编号,select 为选择的查询模式，1为查歌名，2为查歌手，3为查歌词主体
    bool Query(string query, int k,int select=1);

    //查询某一个词是否在其中，有则返回其df，无则返回0
    int isInner(string elem, Index_List idList[],Index_List &nowTemp);

    //某个词项对于suoyou文档的得分
    float ScoreofaDoc(Index_List *idList, Index_List* word, int iQ);

    //进行堆排序，将所有的得分进行排序
    bool HeapSort(float Scores[], int n,int k);

};

//堆排序，建立最大堆
class Max_Heap {
    ScoreandDoc *Heap;
    int size;
    int n;
    void siftdown(int elem);
public:
    Max_Heap(int num, int max, ScoreandDoc *temp) {
        n = num;
        size = max;
        Heap = temp;
        buildHeap();
    };
    void buildHeap() {
        for (int i = n / 2 - 1; i >= 0; i--)
            siftdown(i);
    };
    int heapsize()const {
        return n;
    }
    bool isLeaf(int pos)const {
        return (pos >= n / 2) && (pos < n);
    }
    int leftchild(int pos)const {
        return 2 * pos + 1;
    }
    int rightchild(int pos)const {
        return 2 * pos + 2;
    }
    ScoreandDoc removemax(float it);

};

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

#pragma once
#include"Document_Index.h"
#include<iostream>
#include<fstream>
#include<vector>
#include<math.h>
#include<string>
#include<iomanip>
#include <stdio.h>
#include<io.h>
#include <windows.h>
using namespace std;

///////////类：Doc_Analysis///////////////////////

//打开文件输入歌词，对词项进行分析，把歌曲的作者和歌曲名取出，存入对应的倒排索引，但是这个索引很小，所以可以直接构建倒排索引表。参数分别为：文件名，文档的编号。调用分离出的词项最终存储在Inp_Temp_Words[Maxsize],返回歌词文档的词数
int Doc_Analysis::Doc_input(string filename, int number) {
    ifstream fin(filename);
    if (!fin.is_open()) {
        exit(0);
    }
    N++;
//    cout << "此文件夹文档数目:" << N << endl;
    char c[maxsize] = { '' };
    int ic = 0, i = 2;
    int numberofDoc = 0;
    string str;
    getline(fin, str);

    //分离出作者
    for (; str[i] != ']'; i++) {
        if (str[i] == ':'&&str[i - 1] == 'r'&&str[i - 2] == 'a') {
            for (; str[i] != ']'; i++) {
                if (((int)str[i] >= 65) && ((int)str[i] <= 91))
                    c[ic++] = (int)str[i] + 32;
                else
                    c[ic++] = str[i];
            }
            i--;
        }
    }
    Temp_Insert(ar_Temp,c,arsize);
    
    Doc_mergesort(ar_Temp, TEMP, 0, arsize - 1);
    
    
    //分离出歌名
    getline(fin, str);
    i = 2;
    ic = 0;
    for (; str[i] != ']'; i++) {
        if (str[i] == ':'&&str[i - 1] == 'i'&&str[i - 2] == 't') {
            for (; str[i] != ']'; i++) {
                if (((int)str[i] >= 65) && ((int)str[i] <= 91))
                    c[ic++] = (int)str[i] + 32;
                else
                    c[ic++] = str[i];
            }
            i--;
        }
    }

    //cout << "歌名：" << c << endl;
    Temp_Insert(ti_Temp,c, tisize);
    
    //遍历整个geci文档主体，每次读取一行，然后进行分析
    getline(fin, str);
    
    do {
        //cout <<"收到： " <<str << endl;
        ic = 0;
        for (i = 0; str[i] != ']'; i++);
        for (i++; str[i] != '
'&&str[i] != '
'&&str[i] != ''; i++) {

            //去掉引号后面的字符,但是如果是t的话就不去
            if ((int)str[i] == 39) {
                while (str[i] != ' '&&str[i] != '
'&&str[i] != '
'&&str[i] != '') {
                    i++;
                    if (str[i] == 't') {
                        i--;
                        break;
                    }
                }
                if (str[i] == '
' || str[i] == '
' || str[i] == '')
                    break;
            }

            //除去大小写
            if (((int)str[i] >= 65) && ((int)str[i] <= 91))
                c[ic++] = (int)str[i] + 32;
            else
                c[ic++] = str[i];
        }
        c[ic] = '';
        
        Temp_Insert(Inp_Temp_Lyrics, c, numberofDoc);
        getline(fin, str);
    } while (!fin.eof());
    fin.close();
    allsize += numberofDoc;

    //cout << "本文档最终分离出词数:" << size << endl;
    size = numberofDoc;
    return numberofDoc;
};

//被int Doc_input(string filename, int number);调用，将分离出的词项存储在temp_Words[]中,size表示其大小
int Doc_Analysis::Temp_Insert(string temp_words[], char T[],int &size) {
    const char *d = "[] -;,:/?!.()"";//以这些字符为分界符[] -;,:/?!.()"
    char *p = NULL;
    char *next_p = NULL;
    p = strtok_s(T, d, &next_p);
    while (p)
    {
        //cout << p << endl;
        temp_words[size++] = p;//put the char* into temp table
        p = strtok_s(NULL, d, &next_p);
    }
    
    return size;
};

//对此文档的词项的表进行归并排序（按字典序）
void Doc_Analysis::Doc_mergesort(string *inputWord, string* Temp, int left, int right) {
    int i, j, k, mid = (left + right) / 2;
    if (left == right)
        return;
    Doc_mergesort(inputWord, Temp, left, mid);
    Doc_mergesort(inputWord, Temp, mid + 1, right);
    for (i = mid; i >= left; i--)
        Temp[i] = inputWord[i];
    for (j = 1; j <= right - mid; j++)
        Temp[right - j + 1] = inputWord[j + mid];
    for (i = left, j = right, k = left; k <= right; k++)
        if (Temp[i]<= Temp[j])
            inputWord[k] = Temp[i++];
        else
            inputWord[k] = Temp[j--];
};

//将此次输入的文档分词排序后得到的词项表存入最终的倒排索引中,numberofDoc为此文档分离出的词的数目，（不是词项）NofDoc为文档的编号
Index_List* Doc_Analysis::insert_IndexList(string *inputWord, int numberofDoc,int NofDoc, Index_List * idListx) {
    int i = 0, j = 0;
    Index_List* pre_idList = idListx,*idList=idListx, *idListHead = idListx;    
    //cout << "词数" << numberofDoc << endl;
    if (i < numberofDoc) {
        //cout << " 当前文档的词: " << inputWord[i] << endl;
        while ((idList != nullptr)&&(i<numberofDoc)) {//将整个倒排索引在此遍历完全,在文档也未结束的情况下
            //1.词项和目前监测的节点值一样,则直接在其后的此词项的后面加上本文档的相关信息即可
            if (inputWord[i] == idList->word) {
                //cout << "此时词项" << inputWord[i] << "已存在索引表中" << endl;
                Word_Doc *temp = new Word_Doc;
                temp->text_number = NofDoc;//这个词项的文档编号,把所有相同的词项合并在一起
                temp->text_fre = 0;//肯定已经在这个文档出现了一次
                do {
                    temp->text_fre++;
                    i++;
                    if (i == numberofDoc)
                        break;
                } while (inputWord[i] == idList->word);//只有当文档检测的词项不一样时退出

                idList->df++;//出现该词项的文档数增1，应该为df

                idList->head_docID.push_back(*temp);
                
                /*cout << (idList->head_docID)[idList->head_docID.size() - 1].text_number << endl;*/
                
                pre_idList = idList;//前一个链表值

                //print2(idList);//查看这个idList的具体值

                idList = idList->next;//索引表下移
            }
            //2.当这个词项比当前索引的词项小时，说明词项肯定在倒排索引中排在当前词项的前面，则将其插入在其之前，注意区分第一个和中间的
            else if (inputWord[i] < idList->word) {
                //cout << inputWord[i] << "比索引表的——" << idList->word << " 小" << endl;
                Index_List* newidList = new Index_List;
                vector<Word_Doc> forID ;//因为是单独建一个词项的索引，故建立存储倒排索引的容器
                Word_Doc *temp = new Word_Doc;
                temp->text_number = NofDoc;
                temp->text_fre = 0;//肯定已经出现过一次,把所有相同的词项合并在一起
                if (idList->word==pre_idList->word) {
                    //cout << "这个词即将插入索引头。" << endl;
                    idListHead = newidList;
                }
                else {
                    pre_idList->next = newidList;
                }
                do {
                    temp->text_fre++;
                    i++;
                    if (i == numberofDoc)
                        break;
                } while (inputWord[i] == inputWord[i - 1]);//只有当文档检测的词项不一样时退出
                
                forID.push_back(*temp);

                newidList->df = 1;
                newidList->next = idList;
                
                pre_idList = newidList;
                newidList->word = inputWord[i-1];
                newidList->head_docID = forID;


            }
            //3.当目前文档的词比索引的词项大时，倒排索引表向后走
            else {
                //cout << inputWord[i] << "比索引表的——" << idList->word << " 大" << endl;

                pre_idList = idList;
                //cout << idList->word << endl;
                idList = idList->next;
            }
        }
        //idList==nullptr,,,if条件句成立意味着倒排索引表已经到达尾部，接下来的所有词项都大于索引表内任何词项，可以直接插入，注意区分第一个和中间的
        while (i < numberofDoc) {
            idList = new Index_List;
            if (idListHead == nullptr) {//如果是
                pre_idList = idList;
                idListHead = idList;
            }
            else {
                pre_idList->next = idList;
            }
            
            vector<Word_Doc> forID;//建立存储这个词项的倒排索引的容器
            Word_Doc *temp = new Word_Doc;
            temp->text_number = NofDoc;
            temp->text_fre = 0;
            do {
                temp->text_fre++;
                i++;
                if (i == numberofDoc)
                    break;
                
            } while (inputWord[i] == inputWord[i - 1]);//把所有相同的词项合并在一起,只有词项不一致时才退出
            forID.push_back(*temp);

            idList->df = 1;
            
            pre_idList = idList;
            idList->word = inputWord[i-1];
            idList->head_docID = forID;

            //print2(idList); 
            idList = idList->next;
        }
    }
    //print1(idListHead);
    return idListHead;
};

//歌曲名，作者，歌词主体倒排索引总体构建
void Doc_Analysis::SETUP_Index(){
    int i;
    string tx_filePath = "", filePath = "D:\暂时的", distAll = "检索结果.txt", format = ".lrc";
    vector<string> files;

    GetAllFormatFiles(filePath, files, format);
    distAll = filePath + "\" + distAll;
    ofstream ofn(distAll);
    int tsize = files.size();
    cout << "文件夹下的.lrc数目：" << tsize << endl;//查询出文件夹下文档的数目
    for (i = 0; i < tsize; i++)//一次遍历，每检索一个文档将其存入相应的缓冲区，然后建立倒排索引
    {
        ofn <<"文档"<<i<<"： "<< files[i] << endl; // 写入文件  
        Doc_input(files[i], i);
        Doc_mergesort(ar_Temp, TEMP, 0, arsize-1);
        Doc_mergesort(ti_Temp, TEMP, 0, tisize-1);
        Doc_mergesort(Inp_Temp_Lyrics,BTEMP, 0, size-1);
    
        //插入倒排索引

        arofMusic_idList = insert_IndexList(ar_Temp, arsize, i, arofMusic_idList);
        tiofMusic_idList = insert_IndexList(ti_Temp, tisize, i, tiofMusic_idList);
        idList=insert_IndexList(Inp_Temp_Lyrics, size, i, idList);
    

        arsize = 0;
        tisize = 0;
        size = 0;
        
        //cout << "索引链表内容如下：" << endl;
        //cout << "作者：" << endl;
        //print1(arofMusic_idList);
        //cout << "歌名：" << endl;
        //print1(tiofMusic_idList);
        //cout << "主体：" << endl;
        //print1(idList)
        //insert_IndexList(ti_Temp, arsize, i, tiofMusic_idList);
        //insert_IndexList(Inp_Temp_Lyrics, arsize, i, idList);
    }
    //至此，索引构建完毕
    /*cout << "主体：" << endl;
    print1(idList);*/
    ofn <<endl<< "文件夹下的.lrc数目：" << tsize << endl;
    cout << endl;
    ofn << "检索出词数(非词项数)：" << allsize << endl;
    ofn.close();
    cout << "一共检索出词数(非词项数)：" << allsize << endl;
    cout << "歌曲名索引构建完毕！！！" << endl;
    cout << "作曲者索引构建完毕！！！" << endl;
    cout << "歌词主体索引构建完毕！！！" << endl;
    cout << endl;
};

//此函数实现寻找指定文件夹下的指定后缀文件，并且保存其完整的路径
void Doc_Analysis::GetAllFormatFiles(string path, vector<string>& files, string format)
{
    //文件句柄    
    long   hFile = 0;
    //文件信息    
    struct _finddata_t fileinfo;
    string p;
    if ((hFile = _findfirst(p.assign(path).append("\*" + format).c_str(), &fileinfo)) != -1)
    {
        do
        {
            if ((fileinfo.attrib &  _A_SUBDIR))
            {
                if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)
                {
                    files.push_back(p.assign(path).append("\").append(fileinfo.name));
                    GetAllFormatFiles(p.assign(path).append("\").append(fileinfo.name), files, format);
                }
            }
            else
            {
                files.push_back(p.assign(path).append("\").append(fileinfo.name));; //将文件路径保存，也可以只保存文件名:    p.assign(fileinfo.name)
            }
        } while (_findnext(hFile, &fileinfo) == 0);

        _findclose(hFile);
    }
};


////////////////////类：ReQuery////////////////////

//查询所有词项，对倒排索引表遍历一次，初始化得分数组

void ReQuery::initialLength(Index_List * idList, float *tempLength) {
    float idf;//记录log N/df
    int size;
    int i;
    
    while (idList != nullptr) {
        idf = log(N/idList->df) / log(10);
        size = idList->head_docID.size();
        i = 0;
        for (; i < size; i++) {
            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)));
        }
        idList = idList->next;
    }
    for (i = 0; i < N; i++)
        tempLength[i] = sqrt(tempLength[i]);
    /*for (int i = 0; i < LMA->SizeOfDocSet();i++)
        cout << "文档" << i <<" 长度为 "<< tempLength[i] << endl;*/
}

//输入查询词项，输出查询结果,返回排名前k的文档编号,select 为选择的查询模式，1为查歌名，2为查歌手，3为查歌词主体
bool ReQuery::Query(string query, int k, int select) {
    Index_List QUERY[10];
    char aa[50] = { '' };
    int ia = 0, i = 0, iQ = 0, j = 0;
    
    for (; i<query.length(); i++) {
        while (query[i] != ' '&& i < query.length()) {
            if (((int)query[i] >= 65) && ((int)query[i] <= 91))
                aa[ia++] = query[i++] + 32;
            else
                aa[ia++] = query[i++];
        }
            
        aa[ia] = '';
        for (; j < iQ; j++) {
            if (QUERY[j].word == aa) {
                QUERY[j].df++;
                j = -1;
                break;
            }
        }
        if (j != -1) {
            QUERY[iQ++].word = aa;
            QUERY[iQ-1].df = 1;
        }
        j = 0;
        ia = 0;
        //cout << f[ic1 - 1] << endl;
    }

    //查歌名
    if (select == 1) {
        initialLength(LMA->tiIndex_head(), Length);
        //计算查询de得分
        ScoreofaDoc(LMA->tiIndex_head(), QUERY, iQ);
    }
    //查作者
    if (select == 2) {
        initialLength(LMA->arIndex_head(), Length);
        //计算查询de得分
        ScoreofaDoc(LMA->arIndex_head(), QUERY, iQ);
    }
    //查歌词主体
    if (select == 3) {
        initialLength(LMA->DocIndex_head(), Length);
        //计算查询de得分
        ScoreofaDoc(LMA->DocIndex_head(), QUERY, iQ);
    }
    /*for (int i = 0; i < N; i++) {
        cout << Scores[i] << endl;
    }*/
    //对得分数组建堆，并且返回前K个
    HeapSort(Scores, N, k);
    return true;
};

//词项对于suoyou文档的得分
float ReQuery::ScoreofaDoc(Index_List *idList, Index_List Tword[],int iQ) {
    int size = 0;
    int df;
    float idf;
    Word_Doc TEMPS;
    Index_List nowTemp;
    for (int i = 0; i < iQ;i++) {
        
        if ((df = isInner(Tword[i].word,idList,nowTemp)) != 0) {
            idf = log(N/df) / log(10);
            size =nowTemp.head_docID.size();
            for (int j = 0; j < size; j++) {
                TEMPS = (nowTemp.head_docID)[j];
                Scores[TEMPS.text_number] += ((idf)*Tword[i].df)*(idf*(1 + log(nowTemp.head_docID[j].text_fre) / log(10)));
            }
        }
    }
    cout <<endl <<"各文档依次得分：" << endl;
    for (int i = 0; i < N; i++) {
        if(Scores[i]!=0)
            Scores[i] = Scores[i]/ Length[i];
        cout << Scores[i] <<" ";
    }
    return 0;
}

//查询某一个词是否在其中，有则返回其df，无则返回0
int ReQuery::isInner(string elem, Index_List idList[], Index_List &nowTemp) {
    int i = 0;
    //cout << "查找单词" << elem << endl;
    while (idList != nullptr) {
        if (idList[i].word == elem) {
            //cout << "单词" << elem << "在其中,文档编号"<<idList[i].head_docID[0].text_number<<endl;
            nowTemp = idList[i];
            return idList->df;
        }
        if (idList->word > elem)
            return 0;
        idList = idList->next;
    };
    return 0;
}

//进行堆排序，将所有的得分进行排序,找出前k个,n为数组大小
bool ReQuery::HeapSort(float Scores[],int n,int k) {
    float doc = -1;
    int i = 0;
    ScoreandDoc *TScores = new ScoreandDoc[n];
    for (; i < n; i++) {
        TScores[i].score = Scores[i];
        TScores[i].text_number = i;
    }

    Max_Heap H(n, n, TScores);
    i = 0;
    cout << endl << endl << "---------------------向您推荐如下文档--------------------------------" << endl;
    for (; i < k; i++) {
        ScoreandDoc temp= H.removemax(doc);
        cout << "文档编号：" << temp.text_number << " 得分：" << temp.score << endl;
    }

    cout << endl;
    delete[]TScores;
    return true;

};

//////////////////////////////lei Max_Heap///////////////////////////
//堆建立

//建立整堆
void Max_Heap::siftdown(int pos) {
    while (!isLeaf(pos)) {
        int j = leftchild(pos);
        int rc = rightchild(pos);
        if ((rc < n) && (Heap[j].score < Heap[rc].score)) {
            j = rc;
        }
        if (!(Heap[pos].score < Heap[j].score))
            return;
        ScoreandDoc xxx = Heap[pos];
        Heap[pos] = Heap[j];
        Heap[j] = xxx;
        pos = j;
    }
};


//每次找出移除最大的
ScoreandDoc Max_Heap::removemax(float it) {
    //if (n == 0)
    //    return ;
    ScoreandDoc xxx = Heap[--n];
    Heap[n] = Heap[0];
    Heap[0] = xxx;
    if (n != 0)
        siftdown(0);
    //it = Heap[n].score;
    return Heap[n];
}