import java.util.*; import java.io.*; /** * COMP 2503 Winter 2018 Assignment 2 * * This program reads a text file and compiles a linked list of the * words together with how many each word appears. * * Words from a standard list of stop words are not included. */ public class A2 // MAIN { //private ArrayList words = new ArrayList(); private SinglyLinkedList words = new SinglyLinkedList(); private SinglyLinkedList least = new SinglyLinkedList(); private SinglyLinkedList most = new SinglyLinkedList(); private String[] stopwords = { "a", "about", "all", "am", "an", "and", "any", "are", "as", "at", "be", "been", "but", "by", "can", "cannot", "could", "did", "do", "does", "else", "for", "from", "get", "got", "had", "has", "have", "he", "her", "hers", "him", "his", "how", "i", "if", "in", "into", "is", "it", "its", "like", "more", "me", "my", "no", "now", "not", "of", "on", "one", "or", "our", "out", "said", "say", "says", "she", "so", "some", "than", "that", "the", "their", "them", "then", "there", "these", "they", "this", "to", "too", "us", "upon", "was", "we", "were", "what", "with", "when", "where", "which", "while", "who", "whom", "why", "will", "you", "your"}; private int totalwordcount = 0; private int stopwordcount = 0; private Scanner inp = new Scanner( System.in); public static void main( String[ ] args) { A2 a2 = new A2(); a2.run(); } /** * Check if the word given is in the stopword list. * @param w a word * @return true if w is a stopword, false otherwise */ private boolean stopword( String w) { boolean found = false; int i = 0; while (i < stopwords.length && !found) { if ( w.equals( stopwords[i])) found = true; i++; } return found; } /** List the first n words in the list of words. @param n the number of words to list */ private void printWords( int n) { int i = 0; while ( i < words.size() && i < n) { System.out.println( words.get(i)); i++; } } private void printResults() { System.out.println( "Total Words: " + totalwordcount); System.out.println( "Unique Words: " + words.size()); System.out.println( "Stop Words: " + stopwordcount); System.out.println(); System.out.println( "10 Most Frequent"); //Collections.sort( words, Word.CompFreqDesc); printWords(10); System.out.println(); System.out.println( "10 Least Frequent"); //Collections.sort( words, Word.CompFreqAsc); printWords(10); System.out.println(); System.out.println( "All"); printWords( words.size()); } /** Read the input file and process it. Input is on standard input and is read one word at a time -- separated by whitespace. All non alphabetic characters are stripped out and words are all converted to lower case. Any non-stopword word is stored in the list of words and the number of occurances is tracked. */ private void readFile() { while ( inp.hasNext()) { String word = inp.next().toLowerCase().trim().replaceAll( "[^a-z]",""); if ( word.length() > 0) { totalwordcount++; if ( stopword( word)) { stopwordcount++; } else { Word w = new Word( word); w.incrCount(); if ( words.contains( w)) { words.get( words.indexOf( w)).incrCount(); } else if ( words == null) { words.addToStart(w); } else { words.addInOrder( w); System.out.println (w); } } } } } /** Run the program. Read the file, then print the results. */ public void run() { readFile(); printResults(); } } import java.util.*; //SLL CLASS public class SinglyLinkedList { private Node start; public SinglyLinkedList() { start = null; } public void addToN (type data, int index){ Node nodeToAdd = new Node(data); int length = size(); Node curr = start; if (index <= length && index >=0){ curr = start; for (int count = 0; count < index - 1; count++) curr = curr.getNext(); } nodeToAdd.setNext (curr.getNext()); curr.setNext(nodeToAdd); } public boolean isEmpty(){ return (start == null); } public type removeFromStart() { type data = null; if(start != null) { if(start.getNext() == null) { data = start.getData(); start = null; } else { Node tmp = start; data = start.getData(); start = start.getNext(); tmp.setNext(null); } } return data; } public type get(int index){ type data = null; int length = size(); Node curr = start; if (index <= length && index >=0){ curr = start; for (int count = 0; count < index; count++) curr = curr.getNext(); data = curr.getData(); } return data; } public int size(){ Node curr = start; int length = 0; while(curr != null) { length++; curr = curr.getNext(); } return length; } public void addToEnd(type data) { //without the if and else you will get a null pointer //expection when adding the first element. Node nodeToAdd = new Node(data); if(start != null){ Node curr = start; while(curr.getNext() != null){ curr = curr.getNext(); } curr.setNext(nodeToAdd); } else start = nodeToAdd; } public void addToStart(type data) { Node nodeToAdd = new Node(data); if(isEmpty()) start = nodeToAdd; else { nodeToAdd.setNext(start); start = nodeToAdd; } } public void print() { Node curr = start; System.out.print("Start->"); while(curr != null) { System.out.print("["+curr.getData()+"]->"); curr = curr.getNext(); } System.out.println("null"); } } import java.util.Comparator; //WORD CLASS /** * COMP 2503 Assignment 1 * * A Word object represents a word (string) and how many times it * has occured in a given text. */ public class Word implements Comparable { // The word! private String word; // How many times it has occured private int count; /** Constructor. Set the string and initialize the count to 0. * @param w the string representing this word. */ public Word(String w) { this.word = w; this.count = 0; } /* Comparator to sort from high to low frequency (count). */ public static Comparator CompFreqDesc = new Comparator() { public int compare( Word w1, Word w2) { int f1 = w1.getCount(); int f2 = w2.getCount(); if (f2-f1 == 0) return w1.compareTo( w2); else return f2 - f1; } }; /* Comparator to sort from low to high frequency (count). */ public static Comparator CompFreqAsc = new Comparator() { public int compare( Word w1, Word w2) { int f1 = w1.getCount(); int f2 = w2.getCount(); if (f1 - f2 == 0) return w1.compareTo( w2); else return f1 - f2; } }; public String getWord() { return word; } public int getCount() { return count; } public void incrCount() { count++; } public String toString() { return getWord() + " : " + getCount(); } /** A word is equal to another word if the * string word is equal. */ public boolean equals( Object other) { if ( other == this) return true; if ( other == null) return false; if ( this.getClass() != other.getClass()) return false; Word p = (Word)other; return this.getWord().equals( p.getWord()); } /** Compare two words. This will order * Words alphabetically. */ public int compareTo( Word o) { if ( this.equals( o)) return 0; else return this.getWord().compareTo( o.getWord()); } } public class Node> // NODE CLASS { private type data; private Node next = null; public Node() { } public Node(type data) { this.data=data; } public type getData() { return data; } public void setData(type value) { data = value; } public void setNext(Node other){ next = other; } public Node getNext() { return next; } public int compareTo( Node o) { if ( this.equals( o)) return 0; else return this.getData().compareTo( o.getData()); } }

Linked Lists