數據結構-串操作應用之詞索引表

為書庫創建查詢索引表

建立詞索引表基本步驟：

　　1、從書目文件中讀入一個書目單。

　　2、從書目單中提取所有關鍵字插入詞表。

　　3、對詞表中的每一個關鍵字在索引表中進行查找並作相應的插入操作。

詳細操作：

　　1、為識別從書名串中分離出來的單詞是否是關鍵字，需要一張常用詞表。順序掃描書目單，首先分離單詞，然后查找常用詞表，若不和表中任一詞相等，則為關鍵字，插入臨時存放關鍵字的詞表中。

　　2、在索引表中查詢關鍵字時可能出現兩種情況：其中一種是索引表上已經有此關鍵詞的索引項，只要在該項中插入書號索引即可；其二是需要在索引表中插入此關鍵詞的索引項，插入應按字典有序原則插入。

　　3、首先定義存儲的數據結構：詞表為線性表，只存放一本書的書名中若干個關鍵字，其數量有限，采用順序存儲結構即可，其中每個詞是一個字符串。索引表為有序表，雖是動態生成，在生成過程中需頻繁進行插入操作，但考慮索引表主要為查找用，為了提高查找效率，采用順序存儲結構；表中每隔索引項包含兩個內容：其一是關鍵詞，因索引表為常駐內存，則考慮節省存儲，采用堆分配存儲表示的串類型；其二是書號索引，由於書號索引是在索引表生成過程中逐個插入，且不同關鍵詞的書號索引個數不等，甚至可能相差很多，則宜采用鏈表結構的線性表。

代碼實現部分：

ConcordanceList.cpp

#include "ChainedList.h"
#include "HeapString.h"

#include <conio.h>

#define  MaxBookNum      1000    // 假設只對1000本書建索引表
#define  MaxKeyNum       2500    // 索引表的最大容量
#define  MaxLineLen       500    // 書目串的最大長度
#define  MaxWordNum        10    // 詞表的最大容量
#define  MaxWordLength     30    // 單詞的最大長度

typedef int Boolean;
typedef int Status;

typedef struct {
    char    item[MaxWordNum][MaxWordLength];  // 字符串的數組
    int     last;        // 詞表的長度
} WordListType;          // 詞表類型（順序表）

typedef struct {
    HString   key;       // 關鍵詞
    LinkList bnolist;   // 存放書號索引的鏈表
} IdxTermType;           // 索引項類型

typedef struct {
    IdxTermType  item[MaxKeyNum+1];
    int          last;
} IdxListType;           // 索引表類型（有序表）

//------ 基本操作 ------
void InitIdxList(IdxListType &idxlist);
   // 初始化操作，置索引表idxlist為空表，即idxlist.last=0,
   // 且在idxlist.item[0]設一空串
void GetLine(FILE *f);
   // 從文件f讀入一個書目信息到書目串緩沖區buf
Status ExtractKeyWord(char *Buffer, WordListType &w, int &bno);
   // 從buf中提取書名關鍵詞到詞表wdlist，書號存入bno
Status InsertIdxList(IdxListType &idxlist, ElemType bno);  
   // 將書號為bno的書名關鍵詞按詞典順序插入索引表idxlist
Status PutText(FILE *g, IdxListType idxlist);           
   // 將生成的索引表idxlist輸出到文件g
void PrintFile(FILE *FileName);

Status InsertIdxList(IdxListType &idxlist, int bno);
   // 索引表插入算法
void GetWord(int i, HString &wd);                
   // 用wd返回詞表wdlist中第i個關鍵詞。
int Locate(IdxListType &idxlist, HString wd, Boolean &b);
   // 在索引表idxlist中查詢是否存在與wd相等的關鍵詞。
   // 若存在，則返回其在索引表中的位置，
   // 且b取值TRUE；否則返回插入位置，且b取值FALSE
void InsertNewKey(IdxListType &idxlist, int i, HString wd);
   // 在索引表idxlist的第i項上插入新關鍵詞wd，
   // 並初始化書號索引的鏈表為空表
Status InsertBook(IdxListType &idxlist, int i, int bno);
   // 在索引表idxlist的第i項中插入書號為bno的索引

//------ 主要變量 ------
char          buf[MaxLineLen];   // 書目串緩沖區
WordListType  wdlist;    // 詞表
IdxListType   idxlist;   // 索引表

//------ 主函數 ------
int main(int argc, char* argv[]) { 
  FILE *f,*g;
  int BookNo;
  if ((f = fopen("BookInfo.txt", "r"))==NULL) {
    printf("ERROR in open BookInfo.txt!\n");
    exit(1);
  }
  if ((g = fopen ("BookIdx.txt", "w"))==NULL) {
    printf("ERROR in open BookIdx.txt!\n");
    exit(1);
  }
  printf("書目文件：\n");
  PrintFile(f);
  InitIdxList(idxlist);         // 初始化索引表idxlist為空表
  while (!feof (f)) {
    GetLine (f);                // 從文件f讀入一個書目信息到buf
    ExtractKeyWord(buf,wdlist,BookNo);  
        // 從buf提取關鍵詞到詞表，書號存入BookNo
    InsertIdxList(idxlist, BookNo);  // 書號為BookNo的關鍵詞插入索引表
  }
  PutText(g, idxlist);          // 將生成的索引表idxlist輸出到文件g
  fclose(f);
  fclose(g);
  printf("對書目文件進行處理后的索引文件：\n");
  if ((g = fopen ("Algo0409BookIdx.txt", "r"))==NULL) {
    printf("ERROR in open BookIdx.txt!\n");
    exit(1);
  }
  PrintFile(g);
  fclose(g);
  printf("按任意鍵，結束 ......\n");
  getch();
  return 0;
} // main

Status InsertIdxList(IdxListType &idxlist,  int bno) { 
  int i,j;
  HString wd;
  Boolean b;
  for (i=0;  i<wdlist.last;  i++) {
    GetWord(i, wd);   
    j = Locate(idxlist, wd, b);
    if (!b)
      InsertNewKey(idxlist, j, wd);  //  插入新的索引項
    InsertBook(idxlist, j, bno);     //  插入書號索引
  }
  return OK;
} // InsertIdxList

void GetWord(int i,  HString &wd) {
  char *p;
  p = *(wdlist.item +i);  // 取詞表中第i個字符串
  StrAssign(wd, p);       // 生成關鍵字字符串
} // GetWord

int Locate(IdxListType &idxlist, HString wd, Boolean &b) {
  int i,m;
  for (i = idxlist.last-1; 
       ((m = StrCompare(idxlist.item[i].key, wd)) > 0);  --i);
  if (m==0) { // 找到
    b = TRUE;
    return i;  
  } else {  // 沒找到
    b = FALSE;
    return i+1;
  }         
} // Locate

void InsertNewKey(IdxListType &idxlist, int i, HString wd) {
  int j;
  for (j=idxlist.last-1;  j>=i;  --j)  // 后移索引項
    idxlist.item[j+1] = idxlist.item[j];
  // 插入新的索引項
  StrCopy(idxlist.item[i].key, wd);    // 串賦值
  InitList(idxlist.item[i].bnolist);   // 初始化書號索引表為空表
  ++idxlist.last;
} // InsertNewKey

Status InsertBook(IdxListType &idxlist, int i, int bno) {
  Link p;
  if (!MakeNode (p, bno)) 
    return OVERFLOW;                   // 分配失敗
  Append(idxlist.item[i].bnolist, p);  // 插入新的書號索引
  return OK;
} // InsertBook

//------ 基本操作 -------
void InitIdxList(IdxListType &idxlist) {
  int i;
  idxlist.last= 0;
  for(i=0; i<MaxKeyNum+1; i++)
    InitList(idxlist.item[i].bnolist);
}

Status ExtractKeyWord(char* Buffer,WordListType &w,int &Num) {
  int i=0, j=0, k=0;
  bool Ignore;
  char TempChar[30];
  char IgnoreChar[7][10] = { "to","of","the","and","not","or","if" };
  w.last=0;
  while(*(Buffer+i)!= ' ') { TempChar[i]=*(Buffer+i);  i++; }
  i++;
  TempChar[i]= '\0';
  Num=atoi(TempChar);
  while(*(Buffer+i)!='\n' && *(Buffer+i)!='\0') { 
    // 每個字符串末尾都有作為結束符'\n'
    if(*(Buffer+i)!=' ') { // 若非空字符，則把當前字符加入新的字符串中
      if(*(Buffer+i)>='A' && *(Buffer+i)<='Z')  // 大寫字母轉換為小寫
        *(Buffer+i)-='A'-'a';
      w.item[j][k]=*(Buffer+i);
      k++;  i++;
    } else {               // 如果是空字符，這是則開始另一個字符串
      Ignore=false;
      w.item[j][k++]='\0';
      for (int m=0; m<7; m++)
        if(strcmp(w.item[j],IgnoreChar[m])==0) 
          { Ignore=true;  break; }
      if (!Ignore) { j++;  k=0;  i++;  w.last++; }
      else { k=0;  i++; }
    }
  }
  w.item[j][k++]='\0';     // 把最后一個字符串收尾
  Ignore=false;
  for (int m=0; m<7; m++)
    if (strcmp(w.item[j],IgnoreChar[m])==0) 
      { Ignore=true;  break; }
  if (!Ignore) w.last++;   // 並把最大數加1
  return OK;
}

void GetLine(FILE *f) {
  fgets(buf, MaxLineLen, f);  // buf是全局數組變量
}

Status PutText(FILE *IdxFile, IdxListType MyIdx) { 
  int i,j,k;
  Link p;
  for(i=0; i<MyIdx.last; i++) {
    for(j=0; j<MyIdx.item[i].key.length; j++)
      putc(*(MyIdx.item[i].key.ch+j ),IdxFile);
    putc('\t',IdxFile);
    if (MyIdx.item[i].key.length < 8) putc('\t',IdxFile);
    p = MyIdx.item[i].bnolist.head;
    for (k=0; k<MyIdx.item[i].bnolist.len; k++) {
      p = p->next;
      fprintf(IdxFile,"%03d",p->data);
      putc(' ', IdxFile);
    }
    putc('\n',IdxFile);
  }
  return OK;
}
    
void PrintFile(FILE *FileName) {  // 輔助函數
  char ch;
  rewind(FileName);
  ch=getc(FileName);
  while (ch!=EOF) {
    putchar(ch);
    ch=getc(FileName);
  }
  printf("\n");
  rewind(FileName);
}

HeapString.h

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef int Status;
#define OK 1
#define ERROR 0
#define OVERFLOW -2

typedef struct{
    char *ch;    //若是非空串，則按串長度分配存儲區域，否則ch為NULL
    int length;    //串的長度
}HString;

/*生成一個其值等於等於串常量chars的串T*/
Status StrAssign(HString &T, char *chars){
    if(T.ch)
        free(T.ch);    //若串存儲空間不為NULl 釋放原有空間
    int i = strlen(chars);    //獲取chars長度
    if(!i){
        T.ch = NULL;    //串常量chars長度為0時串為空串長度0存儲區間指向NULL
        T.length = 0;
    }
    else{
        T.ch = (char *)malloc(i * sizeof(char));    //申請空間
        if(!T.ch)
            exit(OVERFLOW);
        for(int j = 0; j < i; j++)
            T.ch[j] = chars[j];        //寫入chars串
        T.length = i;
    }
    return OK;
}

/*由串S復制得到T*/
Status StrCopy(HString &T, HString S){
    if(T.ch)
        free(T.ch);
    T.ch = (char*)malloc(S.length * sizeof(char));
    if(!T.ch)
        exit(OVERFLOW);
    for(int j = 0; j < S.length; j++)
        T.ch[j] = S.ch[j];    
    T.length = S.length;
    return OK;
}
/*若S>T，則返回值>0；若S=T,則返回值=0；若S<T，則返回值<0*/
int StrCompare(HString T, HString S){
    for(int i = 0; i < S.length && i < T.length; i++)
        if(S.ch[i] != T.ch[i])
            return S.ch[i] - T.ch[i];
    return S.length - T.length;
}

ChainedList.h

#include <stdio.h>
#include <stdlib.h>

#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef int ElemType;

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}*Link, *Position;
typedef struct{
    Link head, tail;
    int len;
}LinkList;

Status InitList(LinkList &L){
    L.head = (Link)malloc(sizeof(LNode));
    if(!L.head)
        exit(OVERFLOW);
    L.tail = L.head;
    L.len = 0;
    L.head->next = NULL;
    return 0;
}

Status MakeNode(Link &p,ElemType e){
    p = (Link)malloc(sizeof(LNode));
    if(!p)
        exit(OVERFLOW);
    p->data = e;
    p->next = NULL;
    return OK;
}

Status Append(LinkList &L, Link S){
    Link p;
    L.tail->next = S;
    p = S;
    ++L.len;
    while(p->next){
        p = p->next;
        ++L.len;
    }
    L.tail = p;
    return OK;
}