Question

construct a cross-reference index for a given text file. Such index structures have applications in the design of compilers and databases.

Our task is to write a program that while reading a text file collects all words of the text and retains the numbers of the lines in which each word occurred. When this scan is terminated, a table is printed showing all collected words in alphabetical order with lists of line numbers where they occurred. There would be only one line for each word.

Represent the words encountered in the text by a binary search tree (also called a lex- icographic tree). For example, if there were three words

Answer 1

Ans:- As you have not specifed in which language you want the answer I am providing the solution in java please go through the program and you are free to make changes as per your requirment

1.    import java.util.*;
2.    import java.io.*;
3.    public class Concordance {
4.       static class AlphabeticalOrder implements Comparator {
5. /* Represents a Comparator that can be used for comparing Strings according to alphabetical order. It is an error to apply this Comparator to objects that are non-strings.*/
6.          public int compare(Object obj1, Object obj2) {
7.             String str1 = (String)obj1;      // Type-cast object to Strings.
8.             String str2 = (String)obj2;
9.             str1 = str1.toLowerCase();     // Convert to lower case.
10.             str2 = str2.toLowerCase();
11.             return str1.compareTo(str2); // Compare lower-case Strings.
12.          }
13.       }
14.       static TextReader in;                     // An input stream for reading the input file.
15.       static PrintWriter out;                   // Output stream for writing the output file.
16.       static TreeMap index = new TreeMap(new AlphabeticalOrder());
17. /* This TreeMap holds the concordance. Words from the file are used as keys in the map. The value associated with each word is a set that contains the line numbers on which the word occurs in the file. The set contains values belonging to the wrapper class, Integer.*/
18.       public static void main(String[] args) {
19.          openFiles(args);              // Open input and output files.
20.          int lineNum = 1;             // The number of the line in the input
21.                                        // file that is currently begin processed.
22.          while (true) {
23.             while (in.peek() != '\0' && ! Character.isLetter(in.peek())) {
24. /* Skip over non-letter characters, stopping when end-of-file ('\0') or a letter is seen. If the character is an end-of-line character, add one to lineNum to reflect that fact that we are moving on to the next line in the file.*/
25.                char ch = in.getAnyChar();
26.                if (ch == '\n') {
27.                   lineNum++;                      // Start a new line.
28.                }
29.             }
30.             if (in.eof()) {
31.                                     // The end-of-file has been reached, so exit from the loop.
32.                break;
33.             }
34.             String word = in.getAlpha();                         // The next word from the file.
35.             if (word.length() > 2 && !word.equalsIgnoreCase("the")) {
36. /* Add the reference to word to the concordance, unless the word is "the" or the word has length <= 2. */
37.                addReference(word,lineNum);
38.             }
39.          }
40.         printConcordance();                  // Print the data to the output file.
41.          if (out.checkError()) {
42.                                     // Some error occurred on the output stream.
43.             System.out.println("An error occurred while writing the data.");
44.             System.out.println("Output file might be missing or incomplete.");
45.             System.exit(1);
46.          }
47.          System.out.println(index.size() + " distinct words were found.");
48.       }
49.       static void openFiles(String[] args) {
50. /* Open the global variable "in" as an input file with name args[0]. Open the global variable "out" as an output file with name args[1]. If args.length != 2, or if an error occurs while trying to open the files, then an error message is printed and the program will be terminated.*/
51.          if (args.length != 2) {
52.             System.out.println("Error: Please specify file names on command line.");
53.             System.exit(1);
54.          }
55.          try {
56.             in = new TextReader(new FileReader(args[0]));
57.          }
58.          catch (IOException e) {
59.             System.out.println("Error: Can't open input file " + args[0]);
60.             System.exit(1);
61.          }
62.          try {
63.             out = new PrintWriter(new FileWriter(args[1]));
64.          }
65.          catch (IOException e) {
66.             System.out.println("Error: Can't open output file " + args[1]);
67.             System.exit(1);
68.          }
69.       }                            // end openFiles()
70.       static void addReference(String term, int lineNum) {
71. /* Add a line reference to the concordance. The concordance is stored in the global variable, index. The word term has been found on line number lineNum.*/
72.          TreeSet references;                     // The set of line references that we
73.                                          //have so far for the term.
74.          references = (TreeSet)index.get(term); // Type-cast!
75.          if (references == null){
76. /* This is the first reference that we have found for the term. Make a new set containing the line number and add it to the index, with the term as the key.*/
77.              TreeSet firstRef = new TreeSet();
78.              firstRef.add( new Integer(lineNum) );
79.              index.put(term,firstRef);
80.          }
81.          else {
82. /*references is the set of line references that we have found previously for the term. Add the new line number to that set.*/
83.             references.add( new Integer(lineNum) );
84.          }
85.       }
86.       static void printConcordance() {
87.                                     // Print each entry from the concordance to the output file.
88.          Set entries = index.entrySet();
89. /* The index viewed as a set of entries, where each entry has a key and a value. The objects in this set are of type Map.Entry.*/
90.          Iterator iter = entries.iterator();
91.          while (iter.hasNext()) {
92. /* Get the next entry from the entry set and print the term and list of line references that it contains.*/
93.             Map.Entry entry = (Map.Entry)iter.next();
94.             String term = (String)entry.getKey();
95.             Set lines = (Set)entry.getValue();
96.             out.print(term + " ");
97.             printIntegers(lines);
98.             out.println();
99.          }
100.       }
101.       static void printIntegers( Set integers ) {
102. /* Assume that all the objects in the set are of type Integer. Print the integer values on one line, separated by commas. The commas make this a little tricky, since no comma is printed before the first integer.*/
103.          if (integers.isEmpty()) {
104.               // There is nothing to print if the set is empty.
105.             return;
106.          }
107.          Integer integer;                                      // One of the Integers in the set.
108.          Iterator iter = integers.iterator();            // For traversing the set.
109.          integer = (Integer)iter.next();                 // First item in the set.
110.          out.print(integer.intValue());                 // Print the first item.
111.          while (iter.hasNext()) {
112.                         // Print additional items, if any, with separating commas.
113.             integer = (Integer)iter.next();
114.             out.print(", " + integer.intValue());
115.          }
116.       }
117.    } // end

The answer is provided on the bases of my knowledge and information on the subject hope you had understood.

Thanks.