algo4-01~04.cpp 串 主程序

1.  // algo4-1.cpp 实现算法4.6、4.7、4.8的程序
2.  #include"c1.h"
3.  #include"c4-1.h"
4.  #include"bo4-1.cpp"
6.  void get_next(SString T,int next[])
7.  { // 求模式串T的next函数值并存入数组next。算法4.7
8.    int i=1,j=0;
9.    next[1]=0;
10.    while(i<T[0])
11.      if(j==0||T[i]==T[j])
12.      {
13.        ++i;
14.        ++j;
15.        next[i]=j;
16.      }
17.      else
18.        j=next[j];
19.  }
21.  void get_nextval(SString T,int nextval[])
22.  { // 求模式串T的next函数修正值并存入数组nextval。算法4.8
23.    int i=1,j=0;
24.    nextval[1]=0;
25.    while(i<T[0])
26.      if(j==0||T[i]==T[j])
27.      {
28.        ++i;
29.        ++j;
30.        if(T[i]!=T[j])
31.          nextval[i]=j;
32.        else
33.          nextval[i]=nextval[j];
34.      }
35.      else
36.        j=nextval[j];
37.  }
39.  int Index_KMP(SString S,SString T,int pos,int next[])
40.  { // 利用模式串T的next函数求T在主串S中第pos个字符之后的位置的KMP算法。
41.    // 其中，T非空，1≤pos≤StrLength(S)。算法4.6
42.    int i=pos,j=1;
43.    while(i<=S[0]&&j<=T[0])
44.      if(j==0||S[i]==T[j]) // 继续比较后继字符
45.      {
46.        ++i;
47.        ++j;
48.      }
49.      else // 模式串向右移动
50.        j=next[j];
51.    if(j>T[0]) // 匹配成功
52.      return i-T[0];
53.    else
54.      return 0;
55.  }
57.  void main()
58.  {
59.    int i,*p;
60.    SString s1,s2; // 以教科书算法4.8之上的数据为例
61.    StrAssign(s1,"aaabaaaab");
62.    printf("主串为: ");
63.    StrPrint(s1);
64.    StrAssign(s2,"aaaab");
65.    printf("子串为: ");
66.    StrPrint(s2);
67.    p=(int*)malloc((StrLength(s2)+1)*sizeof(int)); // 生成s2的next数组空间
68.    get_next(s2,p); // 利用算法4.7，求得next数组，存于p中
69.    printf("子串的next数组为: ");
70.    for(i=1;i<=StrLength(s2);i++)
71.      printf("%d ",*(p+i));
72.    printf("/n");
73.    i=Index_KMP(s1,s2,1,p); // 利用算法4.6求得串s2在s1中首次匹配的位置i
74.    if(i)
75.      printf("主串和子串在第%d个字符处首次匹配/n",i);
76.    else
77.      printf("主串和子串匹配不成功/n");
78.    get_nextval(s2,p); // 利用算法4.8，求得next数组，存于p中
79.    printf("子串的nextval数组为: ");
80.    for(i=1;i<=StrLength(s2);i++)
81.      printf("%d ",*(p+i));
82.    printf("/n");
83.    printf("主串和子串在第%d个字符处首次匹配/n",Index_KMP(s1,s2,1,p));
84.  }

 

1.  // algo4-2.cpp 文本行编辑
2.  #include"c1.h"
3.  #include"c4-2.h" // 采用串的堆分配存储结构
4.  #include"bo4-2.cpp" // 串的堆分配基本操作
6.  #define MAX_LEN 25 // 文件最大行数
7.  #define LINE_LEN 75 // 每行字符数最大值+1
8.  #define NAME_LEN 20 // 文件名最大长度(包括盘符、路径)+1
10.  // 全局变量
11.  HString T[MAX_LEN];
12.  char str[LINE_LEN],filename[NAME_LEN]="";
13.  FILE *fp;
14.  int n=0; // 文本行数
16.  void Open()
17.  { // 打开文件(新或旧)
18.    if(filename[0]) // 文件已打开
19.      printf("已存在打开的文件/n");
20.    else
21.    {
22.      printf("请输入文件名(可包括盘符、路径，不超过%d个字符): ",NAME_LEN-1);
23.      scanf("%s",filename);
24.      fp=fopen(filename,"r"); // 以读的方式打开文件
25.      if(fp) // 已存在此文件
26.      {
27.        while(fgets(str,LINE_LEN,fp)) // 由文件读入1行字符成功 
28.        {
29.          str[strlen(str)-1]=0; // 将换行符10强制改为串结束符0
30.          if(n>=MAX_LEN)
31.          {
32.            printf("文件太大/n");
33.            return;
34.          }
35.          StrAssign(T[n],str);
36.          n++;
37.        }
38.        fclose(fp); // 关闭文件
39.      }
40.      else
41.        printf("新文件/n");
42.    }
43.  }
45.  void List()
46.  { // 显示文本内容
47.    int i;
48.    for(i=0;i<n;i++)
49.    {
50.      printf("%d: ",i+1);
51.      StrPrint(T[i]);
52.    }
53.  }
55.  void Insert()
56.  { // 插入行
57.    int i,l,m;
58.    printf("在第l行前插m行,请输入l m: ");
59.    scanf("%d%d%*c",&l,&m);
60.    if(n+m>MAX_LEN)
61.    {
62.      printf("插入行太多/n");
63.      return;
64.    }
65.    if(n>=l-1&&l>0)
66.    {
67.      for(i=n-1;i>=l-1;i--)
68.        T[i+m]=T[i];
69.      n+=m;
70.      printf("请顺序输入待插入内容:/n");
71.      for(i=l-1;i<l-1+m;i++)
72.      {
73.        gets(str);
74.        InitString(T[i]);
75.        StrAssign(T[i],str);
76.      }
77.    }
78.    else
79.      printf("行超出范围/n");
80.  }
82.  void Delete()
83.  { // 删除行
84.    int i,l,m;
85.    printf("从第l行起删除m行,请输入l m: ");
86.    scanf("%d%d",&l,&m);
87.    if(n>=l+m-1&&l>0)
88.    {
89.      for(i=l-1+m;i<n;i++)
90.      {
91.        free(T[i-m].ch);  
92.        T[i-m]=T[i];
93.      }
94.      for(i=n-m;i<n;i++)
95.        InitString(T[i]);
96.      n-=m;
97.    }
98.    else
99.      printf("行超出范围/n");
100.  }
102.  void Copy()
103.  { // 拷贝行
104.    int i,l,m,k;
105.    printf("把第l行开始的m行插在原k行之前,请输入l m k: ");
106.    scanf("%d%d%d",&l,&m,&k);
107.    if(n+m>MAX_LEN)
108.    {
109.      printf("拷贝行太多/n");
110.      return;
111.    }
112.    if(n>=k-1&&n>=l-1+m&&(k>=l+m||k<=l))
113.    {
114.      for(i=n-1;i>=k-1;i--)
115.        T[i+m]=T[i];
116.      n+=m;
117.      if(k<=l)
118.        l+=m;
119.      for(i=l-1;i<l-1+m;i++)
120.      {
121.        InitString(T[i+k-l]);
122.        StrCopy(T[i+k-l],T[i]);
123.      }
124.    }
125.    else
126.      printf("行超出范围/n");
127.  }
129.  void Modify()
130.  { // 修改行
131.    int i;
132.    printf("请输入待修改的行号: ");
133.    scanf("%d%*c",&i);
134.    if(i>0&&i<=n) // 行号合法
135.    {
136.      printf("%d: ",i);
137.      StrPrint(T[i-1]);
138.      printf("请输入新内容: ");
139.      gets(str);
140.      StrAssign(T[i-1],str);
141.    }
142.    else
143.      printf("行号超出范围/n");
144.  }
146.  void Search()
147.  { // 查找字符串
148.    int i,k,f=1; // f为继续查找标志
149.    char b[2];
150.    HString s;
151.    printf("请输入待查找的字符串: ");
152.    scanf("%s%*c",str);
153.    InitString(s);
154.    StrAssign(s,str);
155.    for(i=0;i<n&&f;i++) // 逐行查找
156.    {
157.      k=1; // 由每行第1个字符起查找
158.      while(k)
159.      {
160.        k=Index(T[i],s,k); // 由本行的第k个字符开始查找
161.        if(k) // 找到
162.        {
163.          printf("第%d行: ",i+1);
164.          StrPrint(T[i]);
165.          printf("第%d个字符处找到。继续查找吗(Y/N)? ",k);
166.          gets(b);
167.          if(b[0]!='Y'&&b[0]!='y') // 中断查找
168.          {
169.            f=0;
170.            break;
171.          }
172.          else
173.            k++;
174.        }
175.      }
176.    }
177.    if(f)
178.      printf("没找到/n");
179.  }
181.  void Replace()
182.  { // 替换字符串
183.    int i,k,f=1; // f为继续替换标志
184.    char b[2];
185.    HString s,t;
186.    printf("请输入待替换的字符串: ");
187.    scanf("%s%*c",str);
188.    InitString(s);
189.    StrAssign(s,str);
190.    printf("替换为: ");
191.    scanf("%s%*c",str);
192.    InitString(t);
193.    StrAssign(t,str);
194.    for(i=0;i<n&&f;i++) // 逐行查找、替换
195.    {
196.      k=1; // 由每行第1个字符起查找
197.      while(k)
198.      {
199.        k=Index(T[i],s,k); // 由本行的第k个字符开始查找
200.        if(k) // 找到
201.        {
202.          printf("第%d行: ",i+1);
203.          StrPrint(T[i]);
204.          printf("第%d个字符处找到。是否替换(Y/N)? ",k);
205.          gets(b);
206.          if(b[0]=='Y'||b[0]=='y')
207.          {
208.            StrDelete(T[i],k,StrLength(s));
209.            StrInsert(T[i],k,t);
210.          }
211.          printf("继续替换吗(Y/N)?");
212.          gets(b);
213.          if(b[0]!='Y'&&b[0]!='y') // 中断查找、替换
214.          {
215.            f=0;
216.            break;
217.          }
218.          else
219.            k+=StrLength(t);
220.        }
221.      }
222.    }
223.    if(f)
224.      printf("没找到/n");
225.  }
227.  void Save()
228.  { // 存盘
229.    int i,j;
230.    fp=fopen(filename,"w"); // 以写的方式重新打开文件
231.    if(fp) // 打开文件成功
232.    {
233.      for(i=0;i<n;i++)
234.      { // 依次将每行存入文件
235.        for(j=0;j<T[i].length;j++) // 依次存入每个字符
236.          fputc(T[i].ch[j],fp);
237.        fputc(10,fp); // 存入换行符
238.        ClearString(T[i]); // 释放串空间
239.      }
240.      fclose(fp); // 关闭文件
241.    }
242.    else
243.      printf("存盘失败/n");
244.  }
246.  void main()
247.  {
248.    Status s=TRUE;
249.    int i,k;
250.    for(i=0;i<MAX_LEN;i++) // 初始化串
251.      InitString(T[i]);
252.    while(s)
253.    {
254.      printf("请选择: 1.打开文件(新或旧)  2.显示文件内容/n");
255.      printf("        3.插入行  4.删除行  5.拷贝行  6.修改行/n");
256.      printf("        7.查找字符串        8.替换字符串/n");
257.      printf("        9.存盘退出          0.放弃编辑/n");
258.      scanf("%d",&k);
259.      switch(k)
260.      {
261.        case 1: Open();
262.                break;
263.        case 2: List();
264.                break;
265.        case 3: Insert();
266.                break;
267.        case 4: Delete();
268.                break;
269.        case 5: Copy();
270.                break;
271.        case 6: Modify();
272.                break;
273. 1.  // algo4-3.cpp 根据书目文件bookinfo.txt生成书名关键词索引文件bookidx.txt，
     2.  // 为运行algo4-4.cpp做准备，算法4.9～4.14
     3.  #include"c1.h"
     4.  typedef int ElemType;
     5.  #include"c2-5.h"
     6.  #include"bo2-6.cpp"
     7.  #include"c4-2.h"
     8.  #include"bo4-2.cpp"
     10.  #define MaxKeyNum 25 // 索引表的最大容量(关键词的最大数目)
     11.  #define MaxLineLen 52 // 书目串(书目文件的1行)buf的最大长度
     12.  #define MaxNoIdx 10 // 非索引词(也是一个书目中关键词)的最大数目
     14.  struct WordListType // 一个书目的词表(顺序表)和非索引词表(有序表)共用类型
     15.  {
     16.    char *item[MaxNoIdx]; // 词表(字符串)指针数组
     17.    int last; // 词的数量
     18.  };
     20.  struct IdxTermType // 索引项类型
     21.  {
     22.    HString key; // 关键词(堆分配类型，c4-2.h)
     23.    LinkList bnolist; // 存放书号索引的链表(c2-5.h)
     24.  };
     26.  struct IdxListType // 索引表类型(有序表)
     27.  {
     28.    IdxTermType item[MaxKeyNum+1]; // 索引项数组类型
     29.    int last; // 关键词的个数
     30.  };
     32.  // 全局变量
     33.  char buf[MaxLineLen+1]; // 当前书目串(包括'/0')
     34.  WordListType wdlist,noidx; // 暂存一种书的词表，非索引词表
     36.  void InitIdxList(IdxListType &idxlist)
     37.  { // 初始化操作，置索引表idxlist为空表，且在idxlist.item[0]设一空串
     38.    idxlist.last=0;
     39.    InitString(idxlist.item[0].key); // 初始化[0]单元，函数在bo4-2.cpp中
     40.    InitList(idxlist.item[0].bnolist); // 初始化[0]单元，函数在bo2-6.cpp中
     41.  }
     43.  void ExtractKeyWord(int &BookNo)
     44.  { // 从buf中提取书名关键词到词表wdlist，书号存入BookNo
     45.    int i,l,f=1; // f是字符串buf结束标志 0：结束 1：未结束
     46.    char *s1,*s2;
     47.    for(i=1;i<=wdlist.last;i++)
     48.    { // 释放上一个书目在词表wdlist的存储空间
     49.      free(wdlist.item[i]);
     50.      wdlist.item[i]=NULL;
     51.    }
     52.    wdlist.last=0; // 初始化词表wdlist的词数量
     53.    BookNo=atoi(buf); // 将前几位数字转化为整数，赋给书号BookNo
     54.    s1=&buf[4]; // s1指向书名的首字符
     55.    while(f)
     56.    { // 提取书名关键词到词表wdlist
     57.      s2=strchr(s1,' '); // s2指向s1后的第一个空格，如没有，返回NULL
     58.      if(!s2) // 到串尾(没空格)
     59.      {
     60.        s2=strchr(s1,'/12'); // s2指向buf的最后一个字符(回车符10)
     61.        f=0;
     62.      }
     63.      l=s2-s1; // 单词长度
     64.      if(s1[0]>='A'&&s1[0]<='Z') // 单词首字母为大写
     65.      { // 写入词表
     66.        wdlist.item[wdlist.last]=(char *)malloc((l+1)*sizeof(char)); // 生成串空间(包括'/0')
     67.        for(i=0;i<l;i++)
     68.          wdlist.item[wdlist.last][i]=s1[i]; // 写入词表
     69.        wdlist.item[wdlist.last][l]=0; // 串结束符
     70.        for(i=0;i<noidx.last&&(l=strcmp(wdlist.item[wdlist.last],noidx.item[i]))>0;i++);
     71.        // 查找是否为非索引词
     72.        if(!l) // 是非索引词
     73.        {
     74.          free(wdlist.item[wdlist.last]); // 从词表中删除该词
     75.          wdlist.item[wdlist.last]=NULL;
     76.        }
     77.        else
     78.      wdlist.last++; // 词表长度+1
     79.      }
     80.      s1=s2+1; // s1移动到下一个单词的首字符处
     81.    };
     82.  }
     84.  void GetWord(int i,HString &wd)
     85.  { // 用wd返回词表wdlist中第i个关键词，算法4.11
     86.    StrAssign(wd,wdlist.item[i]); // 生成关键字字符串 bo4-2.cpp
     87.  }
     89.  int Locate(IdxListType &idxlist,HString wd,Status &b)
     90.  { // 在索引表idxlist中查询是否存在与wd相等的关键词。若存在，则返回其
     91.    // 在索引表中的位置，且b取值TRUE；否则返回插入位置，且b取值FALSE，算法4.12
     92.    int i,m;
     93.    for(i=idxlist.last;(m=StrCompare(idxlist.item[i].key,wd))>0;--i); // bo4-2.cpp
     94.    if(m==0) // 找到
     95.    {
     96.      b=TRUE;
     97.      return i;
     98.    }
     99.    else
     100.    {
     101.      b=FALSE;
     102.      return i+1;
     103.    }
     104.  }
     106.  void InsertNewKey(IdxListType &idxlist,int i,HString wd)
     107.  { // 在索引表idxlist的第i项上插入新关键词wd，并初始化书号索引的链表为空表，算法4.13
     108.    int j;
     109.    for(j=idxlist.last;j>=i;--j) // 后移索引项
     110.      idxlist.item[j+1]=idxlist.item[j];
     111.    InitString(idxlist.item[i].key); // bo4-2.cpp
     112.    StrCopy(idxlist.item[i].key,wd); // 串拷贝插入新的索引项 bo4-2.cpp
     113.    InitList(idxlist.item[i].bnolist); // 初始化书号索引表为空表 bo2-6.cpp
     114.    idxlist.last++;
     115.  }
     117.  void InsertBook(IdxListType &idxlist,int i,int bno)
     118.  { // 在索引表idxlist的第i项中插入书号为bno的索引，算法4.14
     119.    Link p;
     120.    MakeNode(p,bno); // 分配结点 bo2-6.cpp
     121.    p->next=NULL;
     122.    Append(idxlist.item[i].bnolist,p); // 插入新的书号索引 bo2-6.cpp
     123.  }
     125.  void InsIdxList(IdxListType &idxlist,int bno)
     126.  { // 将书号为bno的关键词插入索引表，算法4.10
     127.    int i,j;
     128.    Status b;
     129.    HString wd;
     130.    InitString(wd); // bo4-2.cpp
     131.    for(i=0;i<wdlist.last;i++)
     132.    {
     133.      GetWord(i,wd);
     134.      j=Locate(idxlist,wd,b); // 关键词的位置或待插入的位置(当索引表中不存在该词)
     135.      if(!b) // 索引表中不存在关键词wd
     136.        InsertNewKey(idxlist,j,wd); // 在索引表中插入新的索引项
     137.      InsertBook(idxlist,j,bno); // 插入书号索引
     138.    }
     139.  }
     141.  void PutText(FILE *f,IdxListType idxlist)
     142.  { // 将生成的索引表idxlist输出到文件f
     143.    int i,j;
     144.    Link p;
     145.    fprintf(f,"%d/n",idxlist.last);
     146.    for(i=1;i<=idxlist.last;i++)
     147.    {
     148.      for(j=0;j<idxlist.item[i].key.length;j++)
     149.        fprintf(f,"%c",idxlist.item[i].key.ch[j]); // HString类型串尾没有/0，只能逐个字符输出
     150.      fprintf(f,"/n%d/n",idxlist.item[i].bnolist.len);
     151.      p=idxlist.item[i].bnolist.head;
     152.      for(j=1;j<=idxlist.item[i].bnolist.len;j++)
     153.      {
     154.        p=p->next;
     155.        fprintf(f,"%d ",p->data);
     156.      }
     157.      fprintf(f,"/n");
     158.    }
     159.  }
     161.  void main()
     162.  { // 算法4.9
     163.    FILE *f; // 任何时间最多打开一个文件
     164.    IdxListType idxlist; // 索引表
     165.    int BookNo; // 书号变量
     166.    int k;
     167.    if(!(f=fopen("NoIdx.txt","r"))) // 打开非索引词文件
     168.      exit(OVERFLOW);
     169.    fscanf(f,"%d",&noidx.last); // 读取非索引词个数
     170.    for(k=0;k<noidx.last;k++) // 把非索引词文件的内容依次拷到noidx中
     171.    {
     172.      fscanf(f,"%s",buf);
     173.      noidx.item[k]=(char*)malloc((strlen(buf)+1)*sizeof(char));
     174.      strcpy(noidx.item[k],buf);
     175.    }
     176.    fclose(f); // 关闭非索引词文件
     177.    if(!(f=fopen("BookInfo.txt","r"))) // 打开书目文件
     178.      exit(FALSE);
     179.    InitIdxList(idxlist); // 设索引表idxlist为空，并初始化[0]单元
     180.    while(fgets(buf,MaxLineLen,f)) // 由书目文件读取1行信息到buf成功
     181.    {
     182.      ExtractKeyWord(BookNo);//将buf中的书号存入BookNo,关键词提取到词表(当前书目的关键词表)中
     183.      InsIdxList(idxlist,BookNo); // 将书号为BookNo的关键词及书号插入索引表idxlist中
     184.    }
     185.    fclose(f); // 关闭书目文件
     186.    if(!(f=fopen("BookIdx.txt","w"))) // 打开书名关键词索引文件
     187.      exit(INFEASIBLE);
     188.    PutText(f,idxlist); // 将生成的索引表idxlist输出到书名关键词索引文件
     189.    fclose(f); // 关闭书名关键词索引文件
     190.  }
274.                break;
275.        case 8: Replace();
276.                break;
277.        case 9: Save();
278.        case 0: s=FALSE;
279.      }
280.    }
281.  }

1.  // algo4-4.cpp 根据algo4-3.cpp产生的文件,索引查询图书
2.  #include"c1.h"
3.  typedef int ElemType;
4.  #include"c2-5.h"
5.  #include"bo2-6.cpp"
6.  #include"c4-2.h"
7.  #include"bo4-2.cpp"
9.  #define MaxBookNum 10 // 假设只对10个书名建索引表
10.  #define MaxKeyNum 25 // 索引表的最大容量(关键词的最大数目)
11.  #define MaxLineLen 46 // 书名的最大长度
13.  struct IdxTermType // 索引项类型
14.  {
15.    HString key; // 关键词(堆分配类型，c4-2.h)
16.    LinkList bnolist; // 存放书号索引的链表(c2-5.h)
17.  };
19.  struct IdxListType // 索引表类型(有序表)
20.  {
21.    IdxTermType item[MaxKeyNum+1]; // 索引项数组类型
22.    int last; // 关键词的个数
23.  };
25.  struct BookTermType // 书目项类型
26.  {
27.    char bookname[MaxLineLen+1]; // 书名串(包括'/0')
28.    int bookno; // 书号
29.  };
31.  struct BookListType // 书目表类型(有序表)
32.  {
33.    BookTermType item[MaxBookNum]; // 书目项数组类型
34.    int last; // 书目的数量
35.  };
37.  void main()
38.  {
39.    FILE *f; // 任何时间最多打开一个文件
40.    IdxListType idxlist; // 索引表
41.    BookListType booklist; // 书目表
42.    char buf[MaxLineLen+5]; // 当前书目串(包括书号和'/0')
43.    HString ch; // 索引字符串
44.    int BookNo; // 书号
45.    Link p; // 链表指针
46.    int i,j,k,flag=1; // flag是继续查询的标志
47.    InitString(ch); // 初始化HString类型的变量
48.    if(!(f=fopen("BookIdx.txt","r"))) // 打开书名关键词索引表文件
49.      exit(OVERFLOW);
50.    fscanf(f,"%d",&idxlist.last); // 书名关键词个数
51.    for(k=0;k<idxlist.last;k++) // 把关键词文件的内容拷到idxlist中
52.    {
53.      fscanf(f,"%s",buf);
54.      i=0;
55.      while(buf[i])
56.        buf[i++]=tolower(buf[i]); // 字母转为小写
57.      InitString(idxlist.item[k].key);
58.      StrAssign(idxlist.item[k].key,buf);
59.      InitList(idxlist.item[k].bnolist); // 初始化书号链表，bo2-6.cpp
60.      fscanf(f,"%d",&i);
61.      for(j=0;j<i;j++)
62.      {
63.        fscanf(f,"%d",&BookNo);
64.        MakeNode(p,BookNo); // 产生新的书号结点，bo2-6.cpp
65.        p->next=NULL; // 给书号结点的指针域赋值
66.        Append(idxlist.item[k].bnolist,p); // 在表尾插入新的书号结点，bo2-6.cpp
67.      }
68.    }
69.    fclose(f);
70.    if(!(f=fopen("BookInfo.txt","r"))) // 打开书目文件
71.      exit(FALSE);
72.    i=0;
73.    while(fgets(buf,MaxLineLen,f))
74.    { // 把书目文件的内容拷到booklist中
75.      booklist.item[i].bookno=atoi(buf); // 前几位数字为书号
76.      strcpy(booklist.item[i++].bookname,&buf[4]); // 将buf由书名开始的字符串拷贝到booklist中
77.    }
78.    booklist.last=i;
79.    while(flag)
80.    {
81.      printf("请输入书目的关键词(一个)：");
82.      scanf("%s",buf);
83.      i=0;
84.      while(buf[i])
85.        buf[i++]=tolower(buf[i]); // 字母转为小写
86.      StrAssign(ch,buf);
87.      i=0;
88.      do
89.      {
90.        k=StrCompare(ch,idxlist.item[i++].key); // bo4-2.cpp
91.      }while(k&&i<=idxlist.last);
92.      if(!k) // 索引表中有此关键词
93.      {
94.        p=idxlist.item[--i].bnolist.head->next; // p指向索引表中此关键词相应链表的首元结点
95.        while(p)
96.        {
97.          j=0;
98.          while(j<booklist.last&&p->data!=booklist.item[j].bookno) // 在booklist中找相应的书号
99.            j++;
100.          if(j<booklist.last)
101.            printf("%3d %s",booklist.item[j].bookno,booklist.item[j].bookname);
102.          p=p->next; // 继续向后找
103.        }
104.      }
105.      else
106.        printf("没找到/n");
107.      printf("继续查找请输入1，退出查找请输入0：");
108.      scanf("%d",&flag);
109.    }
110.  }