Seperate Chaining

[mwmays]

My code will compile however when i run linux commands on it such as

copperfield.txt is the full txt.


g++ -o hw5.exe hw5.cpp
./hw5.exe < copperfield.txt > words.txt
sort -nr < words.txt > words.sort
head -50 words.sort


it will not print to the output file.

  #include <fstream>
#include <cstdlib>
#include <iostream>
using namespace std;

class LinkedHashEntry {
private:
      string key;
      int value;
      LinkedHashEntry *next;
public:
      LinkedHashEntry(string key, int value) {
            this->key = key;
            this->value = value;
            this->next = NULL;
      }
 
      string getKey() {
            return key;
      }
 
      int getValue() {
            return value;
      }
 
      void setValue(int value) {
            this->value = value;
      }
 
      LinkedHashEntry *getNext() {
            return next;
      }
 
      void setNext(LinkedHashEntry *next) {
            this->next = next;
      }
};
 
int TABLE_SIZE;
 
class HashMap {
private:
      LinkedHashEntry **table;
public:
      HashMap(int size) {
            table = new LinkedHashEntry*[TABLE_SIZE];
            for (int i = 0; i < TABLE_SIZE; i++)
                  table[i] = NULL;
      }
      
      bool Search(string key, int &value)
      {
          int hash = (atoi(key.c_str()) % TABLE_SIZE);
            if (table[hash] == NULL)
                  return false;
          
        LinkedHashEntry *ptr = table[hash];
        while ((ptr != NULL) && (ptr->getKey() != key))
        ptr = ptr->getNext();

        // Return value if key found
        if (ptr != NULL)
        {
                value = ptr->getValue();
                return true;
        }
                value = 0;
        return false;
      }
      
      void Print()
      {
          int size;
          LinkedHashEntry *entry = table[0];
            TABLE_SIZE = size;
            for (int i = 0; i < TABLE_SIZE; i++)
                {
                    while(entry != NULL)
                    {
                        cout << entry->getValue() << " " << entry->getKey() << endl;
                        entry = entry->getNext();
                    }
                }    
      }
      
      int get(string key) {
            int hash = (atoi(key.c_str()) % TABLE_SIZE);
            if (table[hash] == NULL)
                  return -1;
            else {
                  LinkedHashEntry *entry = table[hash];
                  while (entry != NULL && entry->getKey() != key)
                        entry = entry->getNext();
                  if (entry == NULL)
                        return -1;
                  else
                        return entry->getValue();
            }
      }
 
      void put(string key, int value) {
            int hash = (atoi(key.c_str()) % TABLE_SIZE);
            if (table[hash] == NULL)
                  table[hash] = new LinkedHashEntry(key, value);
            else {
                  LinkedHashEntry *entry = table[hash];
                  while (entry->getNext() != NULL)
                        entry = entry->getNext();
                  if (entry->getKey() == key)
                        entry->setValue(value);
                  else
                        entry->setNext(new LinkedHashEntry(key, value));
            }
      }
 
      void remove(string key) {
            int hash = (atoi(key.c_str()) % TABLE_SIZE);
            if (table[hash] != NULL) {
                  LinkedHashEntry *prevEntry = NULL;
                  LinkedHashEntry *entry = table[hash];
                  while (entry->getNext() != NULL && entry->getKey() != key) {
                        prevEntry = entry;
                        entry = entry->getNext();
                  }
                  if (entry->getKey() == key) {
                        if (prevEntry == NULL) {
                             LinkedHashEntry *nextEntry = entry->getNext();
                             delete entry;
                             table[hash] = nextEntry;
                        } else {
                             LinkedHashEntry *next = entry->getNext();
                              delete entry;
                             prevEntry->setNext(next);
                        }
                  }
            }
      }
 
      ~HashMap() {
            for (int i = 0; i < TABLE_SIZE; i++)
                  if (table[i] != NULL) {
                        LinkedHashEntry *prevEntry = NULL;
                        LinkedHashEntry *entry = table[i];
                        while (entry != NULL) {
                             prevEntry = entry;
                             entry = entry->getNext();
                             delete prevEntry;
                        }
                  }
            delete[] table;
      }
};
//------------------------------------------------------------------
// Read a single word from cin
//------------------------------------------------------------------
bool read_word(string & word)
{
   word = "";
   bool done = false;
   while (!cin.eof() && !done)
   {
      char ch;
      cin.get(ch);
      if (ch >= 'a' && ch <= 'z')
	 word = word + ch;
      else if (ch >= 'A' && ch <= 'Z')
	 word = word + char(ch - 'A' + 'a');
      else if (word.length() > 0)
	 done = true;
   }
   return done;
}

//---------------------------------------------------------------------
// Main program to calculate word frequency
//---------------------------------------------------------------------
int main()
{
   // Create hash table for words/counts
    TABLE_SIZE = 1000;
   HashMap ht(25000);
   string word;
   while (read_word(word))
   {
      // Look up word/count in hash table
      int count = 0;
      if(!ht.Search(word, count))
      {
          ht.put(word, count + 1);
      }

      // Increment counter in hash table
      
   }
   ht.Print();
}

[PrivateRyan]

hey this might be better placed on the UNIX/Linux Programming forum. You can edit the post to show on that forum instead.

[keskiverto]

@Ryan: This has nothing UNIX/Linux-specific.

@mwmays: Could you use more of the standard library?

You seem to print only the LinkedHashEntries of table[0].