January 2013 – My Programming Notes

Monthly Archives: January 2013

C++ || Simple Spell Checker Using A Hash Table

January 31, 2013 admin 4 Comments

The following is another programming assignment which was presented in a C++ Data Structures course. This assignment was used to gain more experience using hash tables.

REQUIRED KNOWLEDGE FOR THIS PROGRAM

Hash Table - What Is It? How To Create A Spell Checker How To Read Data From A File Strtok - Split Strings Into Tokens #include 'HashTable.h' The Dictionary File - Download Here

== OVERVIEW ==

This program first reads words from a dictionary file, and inserts them into a hash table.

The dictionary file consists of a list of 62,454 correctly spelled lowercase words, separated by whitespace. The words are inserted into the hash table, with each bucket growing dynamically as necessary to hold all of the incoming data.

After the reading of the dictionary file is complete, the program prompts the user for input. After input is obtained, each word that the user enteres into the program is looked up within the hash table to see if it exists. If the user entered word exists within the hash table, then that word is spelled correctly. If not, a list of possible suggested spelling corrections is displayed to the screen.

== HASH TABLE STATISTICS ==

To better understand how hash tables work, this program reports the following statistics to the screen:

• The total size of the hash table. • The size of the largest hash table bucket. • The size of the smallest hash table bucket. • The total number of buckets used. • The average hash table bucket size.

A timer is used in this program to time (in seconds) how long it takes to read in the dictionary file. The program also saves each hash table bucket into a separate output .txt file. This is used to further visualize how the hash table data is internally being stored within memory.

== SPELL CHECKING ==

The easiest way to generate corrections for a spell checker is via a trial and error method. If we assume that the misspelled word contains only a single error, we can try all possible corrections and look each up in the dictionary.

Example:

wird: bird gird ward word wild wind wire wiry

Traditionally, spell checkers look for four possible errors: a wrong letter (“wird”), also knows as alteration. An inserted letter (“woprd”), a deleted letter (“wrd”), or a pair of adjacent transposed letters (“wrod”).

The easiest of which is checking for a wrong letter. For example, if a word isnt found in the dictionary, all variants of that word can be looked up by changing one letter. Given the user input “wird,” a one letter variant can be “aird”, “bird”, “cird”, etc. through “zird.” Then “ward”, “wbrd”, “wcrd” through “wzrd”, can be checked, and so forth. Whenever a match is found within the dictionary, the spelling correction should be displayed to the screen.

For a detailed analysis how the other methods can be constructed, click here.

===== SIMPLE SPELL CHECKER =====

This program uses a custom template.h class. To obtain the code for that class, click here.





		
		
			Simple Spell Checker Using A Hash Table
			
C++
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jan 31, 2013
//    Taken From: http://programmingnotes.org/
//    File:  SpellCheck.cpp
//    Description: This is a simple spell checker which tests the HashTable.h
//          class. 
// ============================================================================
#include <iostream>
#include <fstream>
#include <cctype>
#include <cstring>
#include <string>
#include <iomanip>
#include <ctime>
#include <limits>
#include "HashTable.h"
using namespace std;

// iterator declaration for hash table
typedef HashTable<string>::Iterator iterDec;
 
// hash table size
const int TABLE_SIZE = 19000;

// strtok delimiters
const char* DELIMITERS = " ,.-\':;?()+*/\\%$#!\"@\^&";

// function prototypes
void PrintTableStats(HashTable<string>& hashTable);
int SpellCheck(HashTable<string>& hashTable, string word);
string ToLowerCase(string word);

int main()
{	
	// declare variables
	int result = 0;
	string userInput;
	string currWord;
	clock_t beg; // used to time the hashtable load
	clock_t end; // used to time the hashtable load
	char response;
	ifstream infile;
	HashTable<string> hashTable(TABLE_SIZE);

	// open the dictionary file
	infile.open("INPUT_Dictionary_programmingnotes_freeweq_com.txt");

	// check if the file exists, EXIT if it doesnt
	if(infile.fail())
	{
		cout<<"\n\n**ERROR - The dictionary file could not be found...\n";
		exit(1);
	}

	cerr<<"\nLoading dictionary....";		
	beg = clock(); // start the timer

	// get data from file and put into hashtable
	while(infile >> currWord)
	{
		// makes sure duplicate words arent inserted into table
		if(!hashTable.Count(currWord))
		{
			hashTable.Insert(currWord);
		}
	}	
	infile.close();
	PrintTableStats(hashTable);	

	end = clock()-beg; // end the timer
	cout<<"\n\nDictionary loaded in "<<
		(double)end / ((double)CLOCKS_PER_SEC)<<" secs!";
	
	// creates a line separator
	cout<<endl;
	cout.fill('-');
	cout<<left<<setw(50)<<""<<endl;	

	do{ // get user input
		cout<<"\n>> Please enter a sentence: ";	
		getline(cin,userInput);
		cout<<endl;

		// split each word from the string into individual words to check if 
		// they are spelled correctly 
		char* splitInput = strtok(const_cast<char*>(userInput.c_str()),DELIMITERS);
		while(splitInput!=NULL)
		{		
			currWord = splitInput;
			currWord = ToLowerCase(currWord);
			result += SpellCheck(hashTable,currWord);
			splitInput = strtok(NULL,DELIMITERS);
		}

		// display results		
		if(result > 0)
		{
			cout<<"Number of words spelled incorrectly: "<<result<<endl;
			result = 0;
		}

		// ask for more data
		cout<<"\nDo you want to enter another sentence? (y/n): ";
		cin >> response;
		cin.ignore(numeric_limits<streamsize>::max(),'\n'); // clear the cin buffer
	}while(toupper(response)=='Y');

	cout<<"\nBYE!!\n";

	return 0;
}// end of main

void PrintTableStats(HashTable<string>& hashTable)
{
	int largestBucket = -9999999;
	int largestIndex = 0;
	int smallestBucket = 9999999;
	int smallestIndex = 0;
	double numBuckestUsed = 0;
	ofstream outfile("OUTPUT_HashTable_Stats_programmingnotes_freeweq_com.txt");
	
	for(int x=0; x < hashTable.TableSize(); ++x)
	{
		// iterator is used to traverse each hashtable bucket
		iterDec it = hashTable.begin(x);
		if(!hashTable.IsEmpty(x))
		{
			if(smallestBucket > hashTable.BucketSize(x))
			{
				smallestBucket = hashTable.BucketSize(x);
				smallestIndex = x;
			}
			if(largestBucket < hashTable.BucketSize(x))
			{
				largestBucket = hashTable.BucketSize(x);
				largestIndex = x;
			}
			++numBuckestUsed;
			outfile<<"\nBucket #"<<x<<":\n";
			for(int y = 0; y < hashTable.BucketSize(x); ++y)
			{
				outfile <<"\t"<< it[y] << endl;
			}
		}
	}
	cout<<"Complete!\n";

	// creates a line separator
	cout<<endl;
	cout.fill('-');
	cout<<left<<setw(50)<<""<<endl;

	cout<<"Total dictionary words = "<<hashTable.TotalElems()<<endl
		<<"Hash table size = "<<hashTable.TableSize()<<endl
		<<"Largest bucket size = "<<largestBucket<< " items at index #"<<largestIndex<<endl
		<<"Smallest bucket size = "<<smallestBucket<< " items at index #"<<smallestIndex<<endl
		<<"Total buckets used = "<<numBuckestUsed<<endl
		<<"Total percent of hash table used = "<<(numBuckestUsed/hashTable.TableSize())*100<<"%"<<endl
		<<"Average bucket size = "<<(hashTable.TotalElems()/numBuckestUsed)<<" items";
}// end of PrintTableStats

int SpellCheck(HashTable<string>& hashTable, string word)
{	
	int result = 0;
	int suggestion = 0;
	string remove[256];
	int numRemove=0;

	if(!hashTable.Count(word))
	{
		++result;
		cout<<"** "<<word<<": ";			
		// alteration & insertion
		for(unsigned x = 0; x < word.length(); ++x)
		{		
			string alteration = word;
			for(char c = 'a'; c <= 'z'; ++c)
			{
				//alteration
				alteration[x] = c;
				if(hashTable.Count(alteration))
				{
					cout<<alteration<<", ";
					remove[numRemove++] = alteration;
					++suggestion;
					// remove the entry so it isnt displayed multiple times
					hashTable.Remove(alteration);
				}
				//insertion
				string insertion = word.substr(0, x) + c + word.substr(x);
				if(hashTable.Count(insertion))
				{
					cout<<insertion<<", ";	
					remove[numRemove++] = insertion;
					++suggestion;
					// remove the entry so it isnt displayed multiple times
					hashTable.Remove(insertion);
				}
			}
		}
		// transposition & deletion	
		for(unsigned x = 0; x < word.length()-1;++x) 
		{
			// transposition 
			string transposition = word.substr(0,x) + word[x+1] + word[x] + word.substr(x+2);
			if(hashTable.Count(transposition))
			{
				cout<<transposition<<", ";
				remove[numRemove++] = transposition;
				++suggestion;
				// remove the entry so it isnt displayed multiple times
				hashTable.Remove(transposition);

			}
			// deletion
			string deletion = word.substr(0, x)+ word.substr(x + 1);
			if(hashTable.Count(deletion))
			{
				cout<<deletion<<", ";
				remove[numRemove++] = deletion;
				++suggestion;
				// remove the entry so it isnt displayed multiple times
				hashTable.Remove(deletion);
			}
		}		
		// place the removed items back inside the hash table
		while(numRemove>=0)
		{
			hashTable.Insert(remove[numRemove--]);
		}
		if(suggestion < 1)
		{
			cout<<"No spelling suggestion found...";
		}
		cout<<endl<<endl;
	}
	return result;
}// end of SpellCheck

string ToLowerCase(string word)
{
	for(unsigned x = 0; x < word.length(); ++x)
	{
		word[x] = tolower(word[x]);
	}
	return word;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jan 31, 2013
//    Taken From: http://programmingnotes.org/
//    File:  SpellCheck.cpp
//    Description: This is a simple spell checker which tests the HashTable.h
//          class. 
// ============================================================================
#include <iostream>
#include <fstream>
#include <cctype>
#include <cstring>
#include <string>
#include <iomanip>
#include <ctime>
#include <limits>
#include "HashTable.h"
using namespace std;
 
// iterator declaration for hash table
typedef HashTable<string>::Iterator iterDec;
 
// hash table size
const int TABLE_SIZE = 19000;
 
// strtok delimiters
const char* DELIMITERS = " ,.-\':;?()+*/\\%$#!\"@\^&";
 
// function prototypes
void PrintTableStats(HashTable<string>& hashTable);
int SpellCheck(HashTable<string>& hashTable, string word);
string ToLowerCase(string word);
 
int main()
{	
	// declare variables
	int result = 0;
	string userInput;
	string currWord;
	clock_t beg; // used to time the hashtable load
	clock_t end; // used to time the hashtable load
	char response;
	ifstream infile;
	HashTable<string> hashTable(TABLE_SIZE);
 
	// open the dictionary file
	infile.open("INPUT_Dictionary_programmingnotes_freeweq_com.txt");
 
	// check if the file exists, EXIT if it doesnt
	if(infile.fail())
	{
		cout<<"\n\n**ERROR - The dictionary file could not be found...\n";
		exit(1);
	}
 
	cerr<<"\nLoading dictionary....";		
	beg = clock(); // start the timer
 
	// get data from file and put into hashtable
	while(infile >> currWord)
	{
		// makes sure duplicate words arent inserted into table
		if(!hashTable.Count(currWord))
		{
			hashTable.Insert(currWord);
		}
	}	
	infile.close();
	PrintTableStats(hashTable);	
 
	end = clock()-beg; // end the timer
	cout<<"\n\nDictionary loaded in "<<
		(double)end / ((double)CLOCKS_PER_SEC)<<" secs!";
	
	// creates a line separator
	cout<<endl;
	cout.fill('-');
	cout<<left<<setw(50)<<""<<endl;	
 
	do{ // get user input
		cout<<"\n>> Please enter a sentence: ";	
		getline(cin,userInput);
		cout<<endl;
 
		// split each word from the string into individual words to check if 
		// they are spelled correctly 
		char* splitInput = strtok(const_cast<char*>(userInput.c_str()),DELIMITERS);
		while(splitInput!=NULL)
		{		
			currWord = splitInput;
			currWord = ToLowerCase(currWord);
			result += SpellCheck(hashTable,currWord);
			splitInput = strtok(NULL,DELIMITERS);
		}
 
		// display results		
		if(result > 0)
		{
			cout<<"Number of words spelled incorrectly: "<<result<<endl;
			result = 0;
		}
 
		// ask for more data
		cout<<"\nDo you want to enter another sentence? (y/n): ";
		cin >> response;
		cin.ignore(numeric_limits<streamsize>::max(),'\n'); // clear the cin buffer
	}while(toupper(response)=='Y');
 
	cout<<"\nBYE!!\n";
 
	return 0;
}// end of main
 
void PrintTableStats(HashTable<string>& hashTable)
{
	int largestBucket = -9999999;
	int largestIndex = 0;
	int smallestBucket = 9999999;
	int smallestIndex = 0;
	double numBuckestUsed = 0;
	ofstream outfile("OUTPUT_HashTable_Stats_programmingnotes_freeweq_com.txt");
	
	for(int x=0; x < hashTable.TableSize(); ++x)
	{
		// iterator is used to traverse each hashtable bucket
		iterDec it = hashTable.begin(x);
		if(!hashTable.IsEmpty(x))
		{
			if(smallestBucket > hashTable.BucketSize(x))
			{
				smallestBucket = hashTable.BucketSize(x);
				smallestIndex = x;
			}
			if(largestBucket < hashTable.BucketSize(x))
			{
				largestBucket = hashTable.BucketSize(x);
				largestIndex = x;
			}
			++numBuckestUsed;
			outfile<<"\nBucket #"<<x<<":\n";
			for(int y = 0; y < hashTable.BucketSize(x); ++y)
			{
				outfile <<"\t"<< it[y] << endl;
			}
		}
	}
	cout<<"Complete!\n";
 
	// creates a line separator
	cout<<endl;
	cout.fill('-');
	cout<<left<<setw(50)<<""<<endl;
 
	cout<<"Total dictionary words = "<<hashTable.TotalElems()<<endl
		<<"Hash table size = "<<hashTable.TableSize()<<endl
		<<"Largest bucket size = "<<largestBucket<< " items at index #"<<largestIndex<<endl
		<<"Smallest bucket size = "<<smallestBucket<< " items at index #"<<smallestIndex<<endl
		<<"Total buckets used = "<<numBuckestUsed<<endl
		<<"Total percent of hash table used = "<<(numBuckestUsed/hashTable.TableSize())*100<<"%"<<endl
		<<"Average bucket size = "<<(hashTable.TotalElems()/numBuckestUsed)<<" items";
}// end of PrintTableStats
 
int SpellCheck(HashTable<string>& hashTable, string word)
{	
	int result = 0;
	int suggestion = 0;
	string remove[256];
	int numRemove=0;
 
	if(!hashTable.Count(word))
	{
		++result;
		cout<<"** "<<word<<": ";			
		// alteration & insertion
		for(unsigned x = 0; x < word.length(); ++x)
		{		
			string alteration = word;
			for(char c = 'a'; c <= 'z'; ++c)
			{
				//alteration
				alteration[x] = c;
				if(hashTable.Count(alteration))
				{
					cout<<alteration<<", ";
					remove[numRemove++] = alteration;
					++suggestion;
					// remove the entry so it isnt displayed multiple times
					hashTable.Remove(alteration);
				}
				//insertion
				string insertion = word.substr(0, x) + c + word.substr(x);
				if(hashTable.Count(insertion))
				{
					cout<<insertion<<", ";	
					remove[numRemove++] = insertion;
					++suggestion;
					// remove the entry so it isnt displayed multiple times
					hashTable.Remove(insertion);
				}
			}
		}
		// transposition & deletion	
		for(unsigned x = 0; x < word.length()-1;++x) 
		{
			// transposition 
			string transposition = word.substr(0,x) + word[x+1] + word[x] + word.substr(x+2);
			if(hashTable.Count(transposition))
			{
				cout<<transposition<<", ";
				remove[numRemove++] = transposition;
				++suggestion;
				// remove the entry so it isnt displayed multiple times
				hashTable.Remove(transposition);
 
			}
			// deletion
			string deletion = word.substr(0, x)+ word.substr(x + 1);
			if(hashTable.Count(deletion))
			{
				cout<<deletion<<", ";
				remove[numRemove++] = deletion;
				++suggestion;
				// remove the entry so it isnt displayed multiple times
				hashTable.Remove(deletion);
			}
		}		
		// place the removed items back inside the hash table
		while(numRemove>=0)
		{
			hashTable.Insert(remove[numRemove--]);
		}
		if(suggestion < 1)
		{
			cout<<"No spelling suggestion found...";
		}
		cout<<endl<<endl;
	}
	return result;
}// end of SpellCheck
 
string ToLowerCase(string word)
{
	for(unsigned x = 0; x < word.length(); ++x)
	{
		word[x] = tolower(word[x]);
	}
	return word;
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Remember to include the data file.

Once compiled, you should get this as your output

Loading dictionary....Complete!
-------------------------------------------------- Total dictionary words = 61286 Hash table size = 19000 Largest bucket size = 13 items at index #1551 Smallest bucket size = 1 items at index #11 Total buckets used = 18217 Total percent of hash table used = 95.8789% Average bucket size = 3.36422 items Dictionary loaded in 1.861 secs! -------------------------------------------------- >> Please enter a sentence: wird ** wird: bird, gird, ward, weird, word, wild, wind, wire, wired, wiry, Number of words spelled incorrectly: 1 Do you want to enter another sentence? (y/n): y -------------------------------------------------- >> Please enter a sentence: woprd ** woprd: word, Number of words spelled incorrectly: 1 Do you want to enter another sentence? (y/n): y -------------------------------------------------- >> Please enter a sentence: wrd ** wrd: ard, ord, ward, wed, word, Number of words spelled incorrectly: 1 Do you want to enter another sentence? (y/n): y -------------------------------------------------- >> Please enter a sentence: wrod ** wrod: brod, trod, wood, rod, word, Number of words spelled incorrectly: 1 Do you want to enter another sentence? (y/n): y -------------------------------------------------- >> Please enter a sentence: New! Safe and efective ** efective: defective, effective, elective, Number of words spelled incorrectly: 1 Do you want to enter another sentence? (y/n): y -------------------------------------------------- >> Please enter a sentence: This is a sentance with no corections gygyuigigigiug ** sentance: sentence, ** corections: corrections, ** gygyuigigigiug: No spelling suggestion found... Number of words spelled incorrectly: 3 Do you want to enter another sentence? (y/n): n
BYE!!

C++ || Custom Template Hash Table With Iterator Using Separate Chaining

January 18, 2013 admin No comments

Looking for sample code for a Hash Map? Click here!

Before we get into the code, what is a Hash Table? Simply put, a Hash Table is a data structure used to implement an associative array; one that can map unique “keys” to specific values. While a standard array requires that indice subscripts be integers, a hash table can use a floating point value, a string, another array, or even a structure as the index. That index is called the “key,” and the contents within the array at that specific index location is called the value. A hash table uses a hash function to generate an index into the table, creating buckets or slots, from which the correct value can be found.

To illustrate, compare a standard array full of data (100 elements). If the position was known for the specific item that we wanted to access within the array, we could quickly access it. For example, if we wanted to access the data located at index #5 in the array, we could access it by doing:

array[5]; // do something with the data

Here, we dont have to search through each element in the array to find what we need, we just access it at index #5. The question is, how do we know that index #5 stores the data that we are looking for? If we have a large set of data, doing a sequential search over each item within the array can be very inefficient. That is where hashing comes in handy. Given a “key,” we can apply a hash function to a unique index or bucket to find the data that we wish to access.

So in essence, a hash table is a data structure that stores key/value pairs, and is typically used because they are ideal for doing a quick search of items.

Though hashing is ideal, it isnt perfect. It is possible for multiple items to be hashed into the same location. Hash “collisions” are practically unavoidable when hashing large data sets. The code demonstrated on this page handles collisions via separate chaining, utilizing an array of linked list head nodes to store multiple values within one bucket – should any collisions occur.

An iterator was also implemented, making data access that much more simple within the hash table class. Click here for an overview demonstrating how custom iterators can be built.

Looking for sample code for a Hash Map? Click here!

=== CUSTOM TEMPLATE HASH TABLE WITH ITERATOR ===





		
		
			#include 'HashTable.h' - Hash Table With Iterator
			
C++
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jan 18, 2013
//    Taken From: http://programmingnotes.org/
//    File:  HashTable.h
//    Description: This is a class which implements various functions which
//          demonstrates the use of a Hash Table.
// ============================================================================
#ifndef TEMPLATE_HASH_TABLE
#define TEMPLATE_HASH_TABLE
#include <iostream>
#include <string>
#include <sstream>
#include <cstdlib>

// if user doesnt define, this is the
// default hash table size
const int HASH_SIZE = 100;

template <class ItemType>
class HashTable
{
public:
    HashTable(int hashSze = HASH_SIZE);
        /*   Function: Constructor initializes hash table
            Precondition: None
            Postcondition: Defines private variables */
    bool IsEmpty(int key);
        /*   Function: Determines whether hash table is empty at the given key
            Precondition: Hash table has been created
            Postcondition: The function = true if the hash table is empty and the
                             function = false if hash table is not empty */
    bool  IsFull();
        /*   Function: Determines whether hash table is full
            Precondition: Hash table has been created
            Postcondition: The function = true if the hash table is full and the
                             function = false if hash table is not full */
    int Hash(ItemType newItem);
        /*   Function: Computes and returns a unique hash key for a given item
                        The returned key is the given cell where the item resides
            Precondition:  Hash table has been created and is not full
            Postcondition: The hash key is returned */
    void Insert(ItemType newItem);
        /*   Function: Adds newItem to the back of the list at a given key in the hash table
                         A unique hash key is automatically generated for each newItem
            Precondition:  Hash table has been created and is not full
            Postcondition: Item is in the hash table */
    void Append(int key, ItemType newItem);
        /*   Function: Adds new item to the end of the list at a given
                         key in the hash table
            Precondition:  Hash table has been created and is not full
            Postcondition: Item is in the hash table */
    bool Remove(ItemType deleteItem, int key = -1);
        /*   Function: Removes the first instance from the table whose value is "deleteItem"
                      Optional second parameter indicates the key where deleteItem is located
            Precondition:  Hash table has been created and is not empty
            Postcondition: The function = true if deleteItem is found and the
                             function = false if deleteItem is not found */
    void Sort(int key);
        /*   Function: Sort the items in the table at the given key
            Precondition: Hash table has been initialized
            Postcondition: The hash table is sorted */
    int TableSize();
        /*   Function: Return the size of the hash table
            Precondition: Hash table has been initialized
            Postcondition: The size of the hash table is returned */
    int TotalElems();
        /*   Function: Return the total number of elements contained in the hash table
            Precondition: Hash table has been initialized
            Postcondition: The size of the hash table is returned */
    int BucketSize(int key);
        /*   Function: Return the number of items contained in the hash table
                        cell at the given key
            Precondition: Hash table has been initialized
            Postcondition: The size of the given key cell is returned */
    int Count(ItemType searchItem);
        /*   Function: Return the number of times searchItem appears in the table.
                        Only works on items located in their correctly hashed cells
            Precondition: Hash table has been initialized
            Postcondition: The number of times searchItem appears in the table is returned */
    void MakeEmpty();
        /*   Function: Initializes hash table to an empty state
            Precondition: Hash table has been created
            Postcondition: Hash table no longer exists */
    ~HashTable();
        /*   Function: Removes the hash table
            Precondition: Hash table has been declared
            Postcondition: Hash table no longer exists */

    //  -- ITERATOR CLASS --
    class Iterator;
        /*   Function: Class declaration to the iterator
            Precondition: Hash table has been declared
            Postcondition: Hash Iterator has been declared */

    Iterator begin(int key){return(!IsEmpty(key)) ? head[key]:NULL;}
        /*   Function: Returns the beginning of the current hash cell list
            Precondition: Hash table has been declared
            Postcondition: Hash cell has been returned to the Iterator */

    Iterator end(int key=0){return NULL;}
        /*   Function: Returns the end of the current hash cell list
            Precondition: Hash table has been declared
            Postcondition: Hash cell has been returned to the Iterator */

private:
    struct node
    {
        ItemType currentItem;
        node* next;
    };
    node** head; // array of linked list declaration - front of each hash table cell
    int hashSize; // the size of the hash table (how many cells it has)
    int totElems; // holds the total number of elements in the entire table
    int* bucketSize; // holds the total number of elems in each specific hash table cell
};

//=========================  Implementation  ================================//

template<class ItemType>
HashTable<ItemType>::HashTable(int hashSze)
{
    hashSize = hashSze;
    head = new node*[hashSize];
    bucketSize = new int[hashSize];
    for(int x=0; x < hashSize; ++x)
    {
        head[x] = NULL;
        bucketSize[x] = 0;
    }
    totElems = 0;
}/* End of HashTable */

template<class ItemType>
bool HashTable<ItemType>::IsEmpty(int key)
{
    if(key >=0 && key < hashSize)
    {
        return head[key] == NULL;
    }
    return true;
}/* End of IsEmpty */

template<class ItemType>
bool HashTable<ItemType>::IsFull()
{
    try
    {
        node* location = new node;
        delete location;
        return false;
    }
    catch(std::bad_alloc&)
    {
        return true;
    }
}/* End of IsFull */

template<class ItemType>
int HashTable<ItemType>::Hash(ItemType newItem)
{
    long h = 19937;
    std::stringstream convert;

    // convert the parameter to a string using "stringstream" which is done
    // so we can hash multiple datatypes using only one function
    convert << newItem;
    std::string temp = convert.str();

    for(unsigned x=0; x < temp.length(); ++x)
    {
        h = (h << 6) ^ (h >> 26) ^ temp[x];
    }
    return abs(h % hashSize);
} /* End of Hash */

template<class ItemType>
void HashTable<ItemType>::Insert(ItemType newItem)
{
    if(IsFull())
    {
        //std::cout<<"nINSERT ERROR - HASH TABLE FULLn";
    }
    else
    {
        int key = Hash(newItem);
        Append(key,newItem);
    }
}/* End of Insert */

template<class ItemType>
void HashTable<ItemType>::Append(int key, ItemType newItem)
{
    if(IsFull())
    {
        //std::cout<<"nAPPEND ERROR - HASH TABLE FULLn";
    }
    else
    {
        node* newNode = new node;  // adds new node
        newNode-> currentItem = newItem;
        newNode-> next = NULL;

        if(IsEmpty(key))
        {
            head[key] = newNode;
        }
        else
        {
            node* tempPtr = head[key];
            while(tempPtr-> next != NULL)
            {
                tempPtr = tempPtr-> next;
            }
            tempPtr-> next = newNode;
        }
        ++bucketSize[key];
        ++totElems;
    }
}/* End of Append */

template<class ItemType>
bool HashTable<ItemType>::Remove(ItemType deleteItem, int key)
{
    bool isFound = false;
    node* tempPtr;
    if(key == -1)
    {
        key = Hash(deleteItem);
    }

    if(IsEmpty(key))
    {
        //std::cout<<"nREMOVE ERROR - HASH TABLE EMPTYn";
    }
    else if(head[key]->currentItem == deleteItem)
    {
        tempPtr = head[key];
        head[key] = head[key]-> next;
        delete tempPtr;
        --totElems;
        --bucketSize[key];
        isFound = true;
    }
    else
    {
        for(tempPtr = head[key];tempPtr->next!=NULL;tempPtr=tempPtr->next)
        {
            if(tempPtr->next->currentItem == deleteItem)
            {
                node* deleteNode = tempPtr->next;
                tempPtr-> next = tempPtr-> next-> next;
                delete deleteNode;
                isFound = true;
                --totElems;
                --bucketSize[key];
                break;
            }
        }
    }
    return isFound;
}/* End of Remove */

template<class ItemType>
void HashTable<ItemType>::Sort(int key)
{
    if(IsEmpty(key))
    {
        //std::cout<<"nSORT ERROR - HASH TABLE EMPTYn";
    }
    else
    {
        int listSize = BucketSize(key);
        bool sorted = false;

        do{
            sorted = true;
            int x = 0;
            for(node* tempPtr = head[key];
                tempPtr->next!=NULL && x < listSize-1;
                tempPtr=tempPtr->next,++x)
            {
                if(tempPtr-> currentItem > tempPtr->next->currentItem)
                {
                    ItemType temp = tempPtr-> currentItem;
                    tempPtr-> currentItem = tempPtr->next->currentItem;
                    tempPtr->next->currentItem = temp;
                    sorted = false;
                }
            }
            --listSize;
        }while(!sorted);
    }
}/* End of Sort */

template<class ItemType>
int HashTable<ItemType>::TableSize()
{
    return hashSize;
}/* End of TableSize */

template<class ItemType>
int HashTable<ItemType>::TotalElems()
{
    return totElems;
}/* End of TotalElems */

template<class ItemType>
int HashTable<ItemType>::BucketSize(int key)
{
    return(!IsEmpty(key)) ? bucketSize[key]:0;
}/* End of BucketSize */

template<class ItemType>
int HashTable<ItemType>::Count(ItemType searchItem)
{
    int key = Hash(searchItem);
    int search = 0;

    if(IsEmpty(key))
    {
        //std::cout<<"nCOUNT ERROR - HASH TABLE EMPTYn";
    }
    else
    {
        for(node* tempPtr = head[key];tempPtr!=NULL;tempPtr=tempPtr->next)
        {
            if(tempPtr->currentItem == searchItem)
            {
                ++search;
            }
        }
    }
    return search;
}/* End of Count */

template<class ItemType>
void HashTable<ItemType>::MakeEmpty()
{
    totElems = 0;
    for(int x=0; x < hashSize; ++x)
    {
        if(!IsEmpty(x))
        {
            //std::cout << "Destroying nodes ...n";
            while(!IsEmpty(x))
            {
                node* temp = head[x];
                //std::cout << temp-> currentItem <<std::endl;
                head[x] = head[x]-> next;
                delete temp;
            }
        }
        bucketSize[x] = 0;
    }
}/* End of MakeEmpty */

template<class ItemType>
HashTable<ItemType>::~HashTable()
{
    MakeEmpty();
    delete[] head;
    delete[] bucketSize;
}/* End of ~HashTable */

//   END OF THE HASH TABLE CLASS
// -----------------------------------------------------------
//   START OF THE HASH TABLE ITERATOR CLASS

template <class ItemType>
class HashTable<ItemType>::Iterator :
        public std::iterator<std::forward_iterator_tag,ItemType>,
        public HashTable<ItemType>
    {
public:
    // Iterator constructor
    Iterator(node* otherIter = NULL)
    {
        itHead = otherIter;
    }
    ~Iterator() {}
    // The assignment and relational operators are straightforward
    Iterator& operator=(const Iterator& other)
    {
        itHead = other.itHead;
        return(*this);
    }
    bool operator==(const Iterator& other)const
    {
        return itHead == other.itHead;
    }
    bool operator!=(const Iterator& other)const
    {
        return itHead != other.itHead;
    }
    bool operator<(const Iterator& other)const
    {
        return itHead < other.itHead;
    }
    bool operator>(const Iterator& other)const
    {
        return other.itHead < itHead;
    }
    bool operator<=(const Iterator& other)const
    {
        return (!(other.itHead < itHead));
    }
    bool operator>=(const Iterator& other)const
    {
        return (!(itHead < other.itHead));
    }
    // Update my state such that I refer to the next element in the
    // HashTable.
    Iterator operator+(int incr)
    {
        node* temp = itHead;
        for(int x=0; x < incr && temp!= NULL; ++x)
        {
            temp = temp->next;
        }
        return temp;
    }
    Iterator operator+=(int incr)
    {
        for(int x=0; x < incr && itHead!= NULL; ++x)
        {
            itHead = itHead->next;
        }
        return itHead;
    }
    Iterator& operator++() // pre increment
    {
        if(itHead != NULL)
        {
            itHead = itHead->next;
        }
        return(*this);
    }
    Iterator operator++(int) // post increment
    {
        node* temp = itHead;
        this->operator++();
        return temp;
    }
    ItemType& operator[](int incr)
    {
        // Return "junk" data
        // to prevent the program from crashing
        if(itHead == NULL || (*this + incr) == NULL)
        {
            return junk;
        }
        return(*(*this + incr));
    }
    // Return a reference to the value in the node.  I do this instead
    // of returning by value so a caller can update the value in the
    // node directly.
    ItemType& operator*()
    {
        // Return "junk" data
        // to prevent the program from crashing
        if(itHead == NULL)
        {
            return junk;
        }
        return itHead->currentItem;
    }
    ItemType* operator->()
    {
        return(&**this);
    }
private:
    node* itHead;
    ItemType junk;
};
#endif // http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jan 18, 2013
//    Taken From: http://programmingnotes.org/
//    File:  HashTable.h
//    Description: This is a class which implements various functions which
//          demonstrates the use of a Hash Table.
// ============================================================================
#ifndef TEMPLATE_HASH_TABLE
#define TEMPLATE_HASH_TABLE
#include <iostream>
#include <string>
#include <sstream>
#include <cstdlib>
 
// if user doesnt define, this is the
// default hash table size
const int HASH_SIZE = 100;
 
template <class ItemType>
class HashTable
{
public:
    HashTable(int hashSze = HASH_SIZE);
        /*   Function: Constructor initializes hash table
            Precondition: None
            Postcondition: Defines private variables */
    bool IsEmpty(int key);
        /*   Function: Determines whether hash table is empty at the given key
            Precondition: Hash table has been created
            Postcondition: The function = true if the hash table is empty and the
                             function = false if hash table is not empty */
    bool  IsFull();
        /*   Function: Determines whether hash table is full
            Precondition: Hash table has been created
            Postcondition: The function = true if the hash table is full and the
                             function = false if hash table is not full */
    int Hash(ItemType newItem);
        /*   Function: Computes and returns a unique hash key for a given item
                        The returned key is the given cell where the item resides
            Precondition:  Hash table has been created and is not full
            Postcondition: The hash key is returned */
    void Insert(ItemType newItem);
        /*   Function: Adds newItem to the back of the list at a given key in the hash table
                         A unique hash key is automatically generated for each newItem
            Precondition:  Hash table has been created and is not full
            Postcondition: Item is in the hash table */
    void Append(int key, ItemType newItem);
        /*   Function: Adds new item to the end of the list at a given
                         key in the hash table
            Precondition:  Hash table has been created and is not full
            Postcondition: Item is in the hash table */
    bool Remove(ItemType deleteItem, int key = -1);
        /*   Function: Removes the first instance from the table whose value is "deleteItem"
                      Optional second parameter indicates the key where deleteItem is located
            Precondition:  Hash table has been created and is not empty
            Postcondition: The function = true if deleteItem is found and the
                             function = false if deleteItem is not found */
    void Sort(int key);
        /*   Function: Sort the items in the table at the given key
            Precondition: Hash table has been initialized
            Postcondition: The hash table is sorted */
    int TableSize();
        /*   Function: Return the size of the hash table
            Precondition: Hash table has been initialized
            Postcondition: The size of the hash table is returned */
    int TotalElems();
        /*   Function: Return the total number of elements contained in the hash table
            Precondition: Hash table has been initialized
            Postcondition: The size of the hash table is returned */
    int BucketSize(int key);
        /*   Function: Return the number of items contained in the hash table
                        cell at the given key
            Precondition: Hash table has been initialized
            Postcondition: The size of the given key cell is returned */
    int Count(ItemType searchItem);
        /*   Function: Return the number of times searchItem appears in the table.
                        Only works on items located in their correctly hashed cells
            Precondition: Hash table has been initialized
            Postcondition: The number of times searchItem appears in the table is returned */
    void MakeEmpty();
        /*   Function: Initializes hash table to an empty state
            Precondition: Hash table has been created
            Postcondition: Hash table no longer exists */
    ~HashTable();
        /*   Function: Removes the hash table
            Precondition: Hash table has been declared
            Postcondition: Hash table no longer exists */
 
    //  -- ITERATOR CLASS --
    class Iterator;
        /*   Function: Class declaration to the iterator
            Precondition: Hash table has been declared
            Postcondition: Hash Iterator has been declared */
 
    Iterator begin(int key){return(!IsEmpty(key)) ? head[key]:NULL;}
        /*   Function: Returns the beginning of the current hash cell list
            Precondition: Hash table has been declared
            Postcondition: Hash cell has been returned to the Iterator */
 
    Iterator end(int key=0){return NULL;}
        /*   Function: Returns the end of the current hash cell list
            Precondition: Hash table has been declared
            Postcondition: Hash cell has been returned to the Iterator */
 
private:
    struct node
    {
        ItemType currentItem;
        node* next;
    };
    node** head; // array of linked list declaration - front of each hash table cell
    int hashSize; // the size of the hash table (how many cells it has)
    int totElems; // holds the total number of elements in the entire table
    int* bucketSize; // holds the total number of elems in each specific hash table cell
};
 
//=========================  Implementation  ================================//
 
template<class ItemType>
HashTable<ItemType>::HashTable(int hashSze)
{
    hashSize = hashSze;
    head = new node*[hashSize];
    bucketSize = new int[hashSize];
    for(int x=0; x < hashSize; ++x)
    {
        head[x] = NULL;
        bucketSize[x] = 0;
    }
    totElems = 0;
}/* End of HashTable */
 
template<class ItemType>
bool HashTable<ItemType>::IsEmpty(int key)
{
    if(key >=0 && key < hashSize)
    {
        return head[key] == NULL;
    }
    return true;
}/* End of IsEmpty */
 
template<class ItemType>
bool HashTable<ItemType>::IsFull()
{
    try
    {
        node* location = new node;
        delete location;
        return false;
    }
    catch(std::bad_alloc&)
    {
        return true;
    }
}/* End of IsFull */
 
template<class ItemType>
int HashTable<ItemType>::Hash(ItemType newItem)
{
    long h = 19937;
    std::stringstream convert;
 
    // convert the parameter to a string using "stringstream" which is done
    // so we can hash multiple datatypes using only one function
    convert << newItem;
    std::string temp = convert.str();
 
    for(unsigned x=0; x < temp.length(); ++x)
    {
        h = (h << 6) ^ (h >> 26) ^ temp[x];
    }
    return abs(h % hashSize);
} /* End of Hash */
 
template<class ItemType>
void HashTable<ItemType>::Insert(ItemType newItem)
{
    if(IsFull())
    {
        //std::cout<<"nINSERT ERROR - HASH TABLE FULLn";
    }
    else
    {
        int key = Hash(newItem);
        Append(key,newItem);
    }
}/* End of Insert */
 
template<class ItemType>
void HashTable<ItemType>::Append(int key, ItemType newItem)
{
    if(IsFull())
    {
        //std::cout<<"nAPPEND ERROR - HASH TABLE FULLn";
    }
    else
    {
        node* newNode = new node;  // adds new node
        newNode-> currentItem = newItem;
        newNode-> next = NULL;
 
        if(IsEmpty(key))
        {
            head[key] = newNode;
        }
        else
        {
            node* tempPtr = head[key];
            while(tempPtr-> next != NULL)
            {
                tempPtr = tempPtr-> next;
            }
            tempPtr-> next = newNode;
        }
        ++bucketSize[key];
        ++totElems;
    }
}/* End of Append */
 
template<class ItemType>
bool HashTable<ItemType>::Remove(ItemType deleteItem, int key)
{
    bool isFound = false;
    node* tempPtr;
    if(key == -1)
    {
        key = Hash(deleteItem);
    }
 
    if(IsEmpty(key))
    {
        //std::cout<<"nREMOVE ERROR - HASH TABLE EMPTYn";
    }
    else if(head[key]->currentItem == deleteItem)
    {
        tempPtr = head[key];
        head[key] = head[key]-> next;
        delete tempPtr;
        --totElems;
        --bucketSize[key];
        isFound = true;
    }
    else
    {
        for(tempPtr = head[key];tempPtr->next!=NULL;tempPtr=tempPtr->next)
        {
            if(tempPtr->next->currentItem == deleteItem)
            {
                node* deleteNode = tempPtr->next;
                tempPtr-> next = tempPtr-> next-> next;
                delete deleteNode;
                isFound = true;
                --totElems;
                --bucketSize[key];
                break;
            }
        }
    }
    return isFound;
}/* End of Remove */
 
template<class ItemType>
void HashTable<ItemType>::Sort(int key)
{
    if(IsEmpty(key))
    {
        //std::cout<<"nSORT ERROR - HASH TABLE EMPTYn";
    }
    else
    {
        int listSize = BucketSize(key);
        bool sorted = false;
 
        do{
            sorted = true;
            int x = 0;
            for(node* tempPtr = head[key];
                tempPtr->next!=NULL && x < listSize-1;
                tempPtr=tempPtr->next,++x)
            {
                if(tempPtr-> currentItem > tempPtr->next->currentItem)
                {
                    ItemType temp = tempPtr-> currentItem;
                    tempPtr-> currentItem = tempPtr->next->currentItem;
                    tempPtr->next->currentItem = temp;
                    sorted = false;
                }
            }
            --listSize;
        }while(!sorted);
    }
}/* End of Sort */
 
template<class ItemType>
int HashTable<ItemType>::TableSize()
{
    return hashSize;
}/* End of TableSize */
 
template<class ItemType>
int HashTable<ItemType>::TotalElems()
{
    return totElems;
}/* End of TotalElems */
 
template<class ItemType>
int HashTable<ItemType>::BucketSize(int key)
{
    return(!IsEmpty(key)) ? bucketSize[key]:0;
}/* End of BucketSize */
 
template<class ItemType>
int HashTable<ItemType>::Count(ItemType searchItem)
{
    int key = Hash(searchItem);
    int search = 0;
 
    if(IsEmpty(key))
    {
        //std::cout<<"nCOUNT ERROR - HASH TABLE EMPTYn";
    }
    else
    {
        for(node* tempPtr = head[key];tempPtr!=NULL;tempPtr=tempPtr->next)
        {
            if(tempPtr->currentItem == searchItem)
            {
                ++search;
            }
        }
    }
    return search;
}/* End of Count */
 
template<class ItemType>
void HashTable<ItemType>::MakeEmpty()
{
    totElems = 0;
    for(int x=0; x < hashSize; ++x)
    {
        if(!IsEmpty(x))
        {
            //std::cout << "Destroying nodes ...n";
            while(!IsEmpty(x))
            {
                node* temp = head[x];
                //std::cout << temp-> currentItem <<std::endl;
                head[x] = head[x]-> next;
                delete temp;
            }
        }
        bucketSize[x] = 0;
    }
}/* End of MakeEmpty */
 
template<class ItemType>
HashTable<ItemType>::~HashTable()
{
    MakeEmpty();
    delete[] head;
    delete[] bucketSize;
}/* End of ~HashTable */
 
//   END OF THE HASH TABLE CLASS
// -----------------------------------------------------------
//   START OF THE HASH TABLE ITERATOR CLASS
 
template <class ItemType>
class HashTable<ItemType>::Iterator :
        public std::iterator<std::forward_iterator_tag,ItemType>,
        public HashTable<ItemType>
    {
public:
    // Iterator constructor
    Iterator(node* otherIter = NULL)
    {
        itHead = otherIter;
    }
    ~Iterator() {}
    // The assignment and relational operators are straightforward
    Iterator& operator=(const Iterator& other)
    {
        itHead = other.itHead;
        return(*this);
    }
    bool operator==(const Iterator& other)const
    {
        return itHead == other.itHead;
    }
    bool operator!=(const Iterator& other)const
    {
        return itHead != other.itHead;
    }
    bool operator<(const Iterator& other)const
    {
        return itHead < other.itHead;
    }
    bool operator>(const Iterator& other)const
    {
        return other.itHead < itHead;
    }
    bool operator<=(const Iterator& other)const
    {
        return (!(other.itHead < itHead));
    }
    bool operator>=(const Iterator& other)const
    {
        return (!(itHead < other.itHead));
    }
    // Update my state such that I refer to the next element in the
    // HashTable.
    Iterator operator+(int incr)
    {
        node* temp = itHead;
        for(int x=0; x < incr && temp!= NULL; ++x)
        {
            temp = temp->next;
        }
        return temp;
    }
    Iterator operator+=(int incr)
    {
        for(int x=0; x < incr && itHead!= NULL; ++x)
        {
            itHead = itHead->next;
        }
        return itHead;
    }
    Iterator& operator++() // pre increment
    {
        if(itHead != NULL)
        {
            itHead = itHead->next;
        }
        return(*this);
    }
    Iterator operator++(int) // post increment
    {
        node* temp = itHead;
        this->operator++();
        return temp;
    }
    ItemType& operator[](int incr)
    {
        // Return "junk" data
        // to prevent the program from crashing
        if(itHead == NULL || (*this + incr) == NULL)
        {
            return junk;
        }
        return(*(*this + incr));
    }
    // Return a reference to the value in the node.  I do this instead
    // of returning by value so a caller can update the value in the
    // node directly.
    ItemType& operator*()
    {
        // Return "junk" data
        // to prevent the program from crashing
        if(itHead == NULL)
        {
            return junk;
        }
        return itHead->currentItem;
    }
    ItemType* operator->()
    {
        return(&**this);
    }
private:
    node* itHead;
    ItemType junk;
};
#endif // http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The iterator class starts on line #368, and is built to support most of the standard relational operators, as well as arithmetic operators such as ‘+,+=,++’ (pre/post increment). The * (star), bracket [] and -> arrow operators are also supported. Click here for an overview demonstrating how custom iterators can be built.

The rest of the code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Looking for sample code for a Hash Map? Click here!

===== DEMONSTRATION HOW TO USE =====

Use of the above template class is the same as many of its STL template class counterparts. Here are sample programs demonstrating its use.





		
		
			#1 - Demonstrate Basic Use
			
C++
			
			// DEMONSTRATE USE OF THE REMOVE AND SORT FUNCTIONS
#include <iostream>
#include <ctime>
#include <string>
#include <cstdlib>
#include <iomanip>
#include "HashTable.h"
using namespace std;

// iterator declarations
typedef HashTable<string>::Iterator strIterDec;

// hash table size
const int TABLE_SIZE = 5;

int main()
{
	// delcare variables
	srand(time(NULL));
	const string names[]={"Alva","Edda","Hiram","Lemuel","Della","Roseann","Sang",
        "Evelia","Claire","Marylou","Magda","Irvin","Reagan","Deb","Hillary",
        "Tuyetm","Cherilyn","Amina","Justin","Neville","Jessica","Demi",
        "Graham","Cinderella","Freddy","Vivan","Marjorie","Krystal","Liza",
        "Spencer","Jordon","Bernie","Geraldine","Kati","Jetta","Carmella",
        "Chery","Earlene","Gene","Lorri","Albertina","Ula","Karena","Johanna",
        "Alex","Tobias","Lashawna","Domitila","Chantel","Deneen","Nigel",
        "Lashanda","Donn","Theda","Many","Jeramy","Jodee","Tamra","Dessie",
        "Lawrence","Jaime","Basil","Roger","Cythia","Homer","Lilliam","Victoria",
        "Tod","Harley","Meghann","Jacquelyne","Arie","Rosemarie","Lyndon","Blanch",
        "Kenneth","Perkins","Kaleena"};

	int nameLen = sizeof(names)/sizeof(names[0]); 

	// Hash table class declarations
	HashTable<string> strHash(TABLE_SIZE);

	// insert 10 items into each hash table
	for(int x=0; x < (TABLE_SIZE*2); ++x)
	{
		// place all data in bucket 0
		// NOTE: you dont want to place all data into one
		// bucket, this is done for demo purposes only
		// Normally use the "Insert" function instead
		strHash.Append(0,names[rand()%(nameLen-1)]);
	}

	// assign the iterator to bucket 0
	strIterDec it = strHash.begin(0);

	// display bucket size
	cout<<"Bucket #0 has "<<strHash.BucketSize(0)<<" items"<<endl;

	// display the first item
	cout<<"The first element in bucket #0 is "<< it[0] <<endl;	

	// remove the first item in bucket 0
	// NOTE: the second parameter is optional
	// but since we know we want bucket 0, we use it here
	strHash.Remove(it[0],0);

	// update the iterator to the new table state
	it = strHash.begin(0);

	// display the new first item	
	cout<<"nNow bucket #0 has "<<strHash.BucketSize(0)<<" items"<<endl;
	cout<<"The first element in bucket #0 is "<< it[0] <<endl;

	// display all the items within the "strHash" table
	cout<<"nThe unsorted items in strHash bucket #0:n";
	for(int x=0; x < strHash.BucketSize(0); ++x)
	{		
		cout << "it[] = " << it[x] << endl;
	}

	// sort the items in bucket 0
	strHash.Sort(0);

	// display all the items within the "strHash" table
	cout<<"nThe sorted items in strHash bucket #0:n";
	for(int x=0; x < strHash.BucketSize(0); ++x)
	{		
		cout << "it[] = " << it[x] << endl;
	}

	return 0;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
				
						// DEMONSTRATE USE OF THE REMOVE AND SORT FUNCTIONS
#include <iostream>
#include <ctime>
#include <string>
#include <cstdlib>
#include <iomanip>
#include "HashTable.h"
using namespace std;
 
// iterator declarations
typedef HashTable<string>::Iterator strIterDec;
 
// hash table size
const int TABLE_SIZE = 5;
 
int main()
{
	// delcare variables
	srand(time(NULL));
	const string names[]={"Alva","Edda","Hiram","Lemuel","Della","Roseann","Sang",
        "Evelia","Claire","Marylou","Magda","Irvin","Reagan","Deb","Hillary",
        "Tuyetm","Cherilyn","Amina","Justin","Neville","Jessica","Demi",
        "Graham","Cinderella","Freddy","Vivan","Marjorie","Krystal","Liza",
        "Spencer","Jordon","Bernie","Geraldine","Kati","Jetta","Carmella",
        "Chery","Earlene","Gene","Lorri","Albertina","Ula","Karena","Johanna",
        "Alex","Tobias","Lashawna","Domitila","Chantel","Deneen","Nigel",
        "Lashanda","Donn","Theda","Many","Jeramy","Jodee","Tamra","Dessie",
        "Lawrence","Jaime","Basil","Roger","Cythia","Homer","Lilliam","Victoria",
        "Tod","Harley","Meghann","Jacquelyne","Arie","Rosemarie","Lyndon","Blanch",
        "Kenneth","Perkins","Kaleena"};
 
	int nameLen = sizeof(names)/sizeof(names[0]); 
 
	// Hash table class declarations
	HashTable<string> strHash(TABLE_SIZE);
 
	// insert 10 items into each hash table
	for(int x=0; x < (TABLE_SIZE*2); ++x)
	{
		// place all data in bucket 0
		// NOTE: you dont want to place all data into one
		// bucket, this is done for demo purposes only
		// Normally use the "Insert" function instead
		strHash.Append(0,names[rand()%(nameLen-1)]);
	}
 
	// assign the iterator to bucket 0
	strIterDec it = strHash.begin(0);
 
	// display bucket size
	cout<<"Bucket #0 has "<<strHash.BucketSize(0)<<" items"<<endl;
 
	// display the first item
	cout<<"The first element in bucket #0 is "<< it[0] <<endl;	
 
	// remove the first item in bucket 0
	// NOTE: the second parameter is optional
	// but since we know we want bucket 0, we use it here
	strHash.Remove(it[0],0);
 
	// update the iterator to the new table state
	it = strHash.begin(0);
 
	// display the new first item	
	cout<<"nNow bucket #0 has "<<strHash.BucketSize(0)<<" items"<<endl;
	cout<<"The first element in bucket #0 is "<< it[0] <<endl;
 
	// display all the items within the "strHash" table
	cout<<"nThe unsorted items in strHash bucket #0:n";
	for(int x=0; x < strHash.BucketSize(0); ++x)
	{		
		cout << "it[] = " << it[x] << endl;
	}
 
	// sort the items in bucket 0
	strHash.Sort(0);
 
	// display all the items within the "strHash" table
	cout<<"nThe sorted items in strHash bucket #0:n";
	for(int x=0; x < strHash.BucketSize(0); ++x)
	{		
		cout << "it[] = " << it[x] << endl;
	}
 
	return 0;
}// http://programmingnotes.org/

SAMPLE OUTPUT:

Bucket #0 has 10 items The first element in bucket #0 is Homer
Now bucket #0 has 9 items The first element in bucket #0 is Tamra The unsorted items in strHash bucket #0: it[] = Tamra it[] = Lyndon it[] = Johanna it[] = Perkins it[] = Alva it[] = Jordon it[] = Neville it[] = Lawrence it[] = Jetta
The sorted items in strHash bucket #0: it[] = Alva it[] = Jetta it[] = Johanna it[] = Jordon it[] = Lawrence it[] = Lyndon it[] = Neville it[] = Perkins it[] = Tamra





		
		
			#2 - Display Items
			
C++
			
			// DISPLAY ALL DATA INSIDE TABLE USING STD::STRING / INT / STRUCT
#include <iostream>
#include <ctime>
#include <string>
#include <cstdlib>
#include <iomanip>
#include "HashTable.h"
using namespace std;

// sample struct demo
struct MyStruct
{
	string name;
};

// iterator declarations
typedef HashTable<string>::Iterator strIterDec;
typedef HashTable<int>::Iterator intIterDec;
typedef HashTable<MyStruct>::Iterator strctIterDec;

// hash table size
const int TABLE_SIZE = 10;

int main()
{
	// delcare variables
	srand(time(NULL));
	const string names[]={"Alva","Edda","Hiram","Lemuel","Della","Roseann","Sang",
        "Evelia","Claire","Marylou","Magda","Irvin","Reagan","Deb","Hillary",
        "Tuyetm","Cherilyn","Amina","Justin","Neville","Jessica","Demi",
        "Graham","Cinderella","Freddy","Vivan","Marjorie","Krystal","Liza",
        "Spencer","Jordon","Bernie","Geraldine","Kati","Jetta","Carmella",
        "Chery","Earlene","Gene","Lorri","Albertina","Ula","Karena","Johanna",
        "Alex","Tobias","Lashawna","Domitila","Chantel","Deneen","Nigel",
        "Lashanda","Donn","Theda","Many","Jeramy","Jodee","Tamra","Dessie",
        "Lawrence","Jaime","Basil","Roger","Cythia","Homer","Lilliam","Victoria",
        "Tod","Harley","Meghann","Jacquelyne","Arie","Rosemarie","Lyndon","Blanch",
        "Kenneth","Perkins","Kaleena"};
     
	int nameLen = sizeof(names)/sizeof(names[0]); 

	// Hash table class declarations
	HashTable<string> strHash(TABLE_SIZE);
	HashTable<int> intHash = TABLE_SIZE; 
	HashTable<MyStruct> strctHash = TABLE_SIZE;

	// access struct element
	MyStruct strctAccess;	

	// insert 20 items into each hash table
	for(int x=0; x < (TABLE_SIZE*2); ++x)
	{
		// Use the "insert" function to place data into the hash table
		// this function automatically hashes the basic datatypes
		// i.e: int, double, char, char*, string
		strHash.Insert(names[rand()%(nameLen-1)]);
		intHash.Insert(rand()%10000);

		// The "insert" function cant be used on a struct, so we
		// use the "append" function for the struct declaration.
		// We use the "strHash" class declaration to use its
		// hash function, then place the struct in an appropriate 
		// hashed bucket
		strctAccess.name = names[rand()%(nameLen-1)];
		int strctHashKey = strHash.Hash(strctAccess.name);		
		strctHash.Append(strctHashKey,strctAccess);
	}

	// display all the items within the "strHash" table
	for(int x=0; x < strHash.TableSize(); ++x)
	{
		if(!strHash.IsEmpty(x))
		{
			cout<<"nstrHash Bucket #"<<x<<":n";
			for(strIterDec it = strHash.begin(x); it != strHash.end(x); it+=1) 
			{
				// access elements using the * (star) operator
				cout << "*it = " << *it << endl;
			}
		}
	}
	// creates a line seperator
	cout<<endl;
	cout.fill('-');
	cout<<left<<setw(80)<<""<<endl;

	// display all the items within the "intHash" table
	for(int x=0; x < intHash.TableSize(); ++x)
	{		
		intIterDec it = intHash.begin(x);
		if(!intHash.IsEmpty(x))
		{
			cout<<"nintHash Bucket #"<<x<<":n";
			for(int y = 0; y < intHash.BucketSize(x); ++y) 
			{
				// access elements using the [] operator
				cout << "it[] = " << it[y] << endl;
			}
		}
	}

	// creates a line seperator
	cout<<endl;
	cout.fill('-');
	cout<<left<<setw(80)<<""<<endl;

	// display all the items within the "strctHash" table
	for(int x=0; x < strctHash.TableSize(); ++x)
	{				
		if(!strctHash.IsEmpty(x))
		{
			cout<<"nstrctHash Bucket #"<<x<<":n";
			for(strctIterDec it = strctHash.begin(x); it!=strctHash.end(x); it=it+1) 
			{
				// access struct/class elements using the -> operator
				cout << "it-> = " << it->name << endl;
			}
		}
	}

	return 0;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
				
						// DISPLAY ALL DATA INSIDE TABLE USING STD::STRING / INT / STRUCT
#include <iostream>
#include <ctime>
#include <string>
#include <cstdlib>
#include <iomanip>
#include "HashTable.h"
using namespace std;
 
// sample struct demo
struct MyStruct
{
	string name;
};
 
// iterator declarations
typedef HashTable<string>::Iterator strIterDec;
typedef HashTable<int>::Iterator intIterDec;
typedef HashTable<MyStruct>::Iterator strctIterDec;
 
// hash table size
const int TABLE_SIZE = 10;
 
int main()
{
	// delcare variables
	srand(time(NULL));
	const string names[]={"Alva","Edda","Hiram","Lemuel","Della","Roseann","Sang",
        "Evelia","Claire","Marylou","Magda","Irvin","Reagan","Deb","Hillary",
        "Tuyetm","Cherilyn","Amina","Justin","Neville","Jessica","Demi",
        "Graham","Cinderella","Freddy","Vivan","Marjorie","Krystal","Liza",
        "Spencer","Jordon","Bernie","Geraldine","Kati","Jetta","Carmella",
        "Chery","Earlene","Gene","Lorri","Albertina","Ula","Karena","Johanna",
        "Alex","Tobias","Lashawna","Domitila","Chantel","Deneen","Nigel",
        "Lashanda","Donn","Theda","Many","Jeramy","Jodee","Tamra","Dessie",
        "Lawrence","Jaime","Basil","Roger","Cythia","Homer","Lilliam","Victoria",
        "Tod","Harley","Meghann","Jacquelyne","Arie","Rosemarie","Lyndon","Blanch",
        "Kenneth","Perkins","Kaleena"};
     
	int nameLen = sizeof(names)/sizeof(names[0]); 
 
	// Hash table class declarations
	HashTable<string> strHash(TABLE_SIZE);
	HashTable<int> intHash = TABLE_SIZE; 
	HashTable<MyStruct> strctHash = TABLE_SIZE;
 
	// access struct element
	MyStruct strctAccess;	
 
	// insert 20 items into each hash table
	for(int x=0; x < (TABLE_SIZE*2); ++x)
	{
		// Use the "insert" function to place data into the hash table
		// this function automatically hashes the basic datatypes
		// i.e: int, double, char, char*, string
		strHash.Insert(names[rand()%(nameLen-1)]);
		intHash.Insert(rand()%10000);
 
		// The "insert" function cant be used on a struct, so we
		// use the "append" function for the struct declaration.
		// We use the "strHash" class declaration to use its
		// hash function, then place the struct in an appropriate 
		// hashed bucket
		strctAccess.name = names[rand()%(nameLen-1)];
		int strctHashKey = strHash.Hash(strctAccess.name);		
		strctHash.Append(strctHashKey,strctAccess);
	}
 
	// display all the items within the "strHash" table
	for(int x=0; x < strHash.TableSize(); ++x)
	{
		if(!strHash.IsEmpty(x))
		{
			cout<<"nstrHash Bucket #"<<x<<":n";
			for(strIterDec it = strHash.begin(x); it != strHash.end(x); it+=1) 
			{
				// access elements using the * (star) operator
				cout << "*it = " << *it << endl;
			}
		}
	}
	// creates a line seperator
	cout<<endl;
	cout.fill('-');
	cout<<left<<setw(80)<<""<<endl;
 
	// display all the items within the "intHash" table
	for(int x=0; x < intHash.TableSize(); ++x)
	{		
		intIterDec it = intHash.begin(x);
		if(!intHash.IsEmpty(x))
		{
			cout<<"nintHash Bucket #"<<x<<":n";
			for(int y = 0; y < intHash.BucketSize(x); ++y) 
			{
				// access elements using the [] operator
				cout << "it[] = " << it[y] << endl;
			}
		}
	}
 
	// creates a line seperator
	cout<<endl;
	cout.fill('-');
	cout<<left<<setw(80)<<""<<endl;
 
	// display all the items within the "strctHash" table
	for(int x=0; x < strctHash.TableSize(); ++x)
	{				
		if(!strctHash.IsEmpty(x))
		{
			cout<<"nstrctHash Bucket #"<<x<<":n";
			for(strctIterDec it = strctHash.begin(x); it!=strctHash.end(x); it=it+1) 
			{
				// access struct/class elements using the -> operator
				cout << "it-> = " << it->name << endl;
			}
		}
	}
 
	return 0;
}// http://programmingnotes.org/

SAMPLE OUTPUT:

strHash Bucket #0: *it = Cinderella *it = Perkins *it = Krystal *it = Roger *it = Roger
strHash Bucket #1: *it = Lilliam *it = Lilliam *it = Theda strHash Bucket #2: *it = Arie strHash Bucket #3: *it = Magda strHash Bucket #6: *it = Edda *it = Irvin *it = Kati *it = Lyndon strHash Bucket #7: *it = Deb *it = Jaime strHash Bucket #8: *it = Neville *it = Victoria strHash Bucket #9: *it = Chery *it = Evelia -------------------------------------------- intHash Bucket #0: it[] = 2449 it[] = 6135 intHash Bucket #1: it[] = 1120 it[] = 852 intHash Bucket #2: it[] = 5727 intHash Bucket #3: it[] = 1174 intHash Bucket #4: it[] = 2775 it[] = 3525 it[] = 8375 intHash Bucket #5: it[] = 4322 it[] = 8722 it[] = 5016 intHash Bucket #6: it[] = 5053 it[] = 7231 it[] = 1571 intHash Bucket #7: it[] = 1666 it[] = 4510 it[] = 1548 it[] = 3646 intHash Bucket #9: it[] = 2756 -------------------------------------------- strctHash Bucket #0: it-> = Cherilyn it-> = Roger strctHash Bucket #1: it-> = Tamra it-> = Alex it-> = Theda strctHash Bucket #2: it-> = Nigel it-> = Alva it-> = Arie strctHash Bucket #4: it-> = Basil strctHash Bucket #5: it-> = Tod strctHash Bucket #6: it-> = Irvin it-> = Lyndon strctHash Bucket #7: it-> = Amina it-> = Hillary it-> = Kenneth it-> = Amina strctHash Bucket #8: it-> = Gene it-> = Lemuel it-> = Gene
strctHash Bucket #9: it-> = Albertina

Java || Snippet – How To Do Simple Math Using Integer Arrays

January 07, 2013 admin No comments

This page will consist of simple programs which demonstrate the process of doing simple math with numbers that are stored in an integer array.

REQUIRED KNOWLEDGE FOR THIS SNIPPET

Integer Arrays The "Random" Class For Loops Assignment Operators - Simple Math Operations Custom Setw/Setfill In Java

Note: In all of the examples on this page, a random number generator was used to place numbers into the array. If you do not know how to obtain data from the user, or if you do not know how to insert data into an array, click here for a demonstration.

===== ADDITION =====

The first code snippet will demonstrate how to add numbers together which are stored in an integer array. This example uses the “+=” assignment operator.





		
		
			#1 - Addition Using An Int Array
			
Java
			
			import java.util.Random;

public class Addition
{
	// global variable declaration
	static Random rand = new Random();		
	static final int NUM_INTS = 12; // const int allocating space for the array
	
	public static void main(String[] args)
	{
		// declare & initialize variables
		int[] arry = new int[NUM_INTS]; // array is initialized using a const variable
		int totalSum = 0;		
		
		System.out.println("Welcome to My Programming Notes' Java Program.n");
		
		// place random numbers into the array
		for(int x = 0; x < NUM_INTS; ++x)
		{
			arry[x] = rand.nextInt(100)+1;
		} 
		
		System.out.println("Original array values:");
		// Display the original array values
		for(int x = 0; x < NUM_INTS; ++x)
		{
			System.out.print(arry[x]+"  ");
		}	
		
		// creates a line seperator if user wants to enter new data
		System.out.println("");
		setwRF("", 50, '-');
		
		System.out.print("nThe sum of the items in the array is: ");
		// Find the sum of the values in the array
		for(int x = 0; x < NUM_INTS; ++x)
		{
			// the code below literally means
			// totalSum = totalSum + arry[x]
			totalSum += arry[x];
		}
		// after the calculations are complete, display the total to the user
		System.out.println(totalSum);									
	}// end of main	
	
	public static void setwRF(String str, int width, char fill)
	{
		System.out.print(str);
		for (int x = str.length(); x < width; ++x)
		{
			System.out.print(fill);     
		}
	}// end of setwRF	
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
				
						import java.util.Random;
 
public class Addition
{
	// global variable declaration
	static Random rand = new Random();		
	static final int NUM_INTS = 12; // const int allocating space for the array
	
	public static void main(String[] args)
	{
		// declare & initialize variables
		int[] arry = new int[NUM_INTS]; // array is initialized using a const variable
		int totalSum = 0;		
		
		System.out.println("Welcome to My Programming Notes' Java Program.n");
		
		// place random numbers into the array
		for(int x = 0; x < NUM_INTS; ++x)
		{
			arry[x] = rand.nextInt(100)+1;
		} 
		
		System.out.println("Original array values:");
		// Display the original array values
		for(int x = 0; x < NUM_INTS; ++x)
		{
			System.out.print(arry[x]+"  ");
		}	
		
		// creates a line seperator if user wants to enter new data
		System.out.println("");
		setwRF("", 50, '-');
		
		System.out.print("nThe sum of the items in the array is: ");
		// Find the sum of the values in the array
		for(int x = 0; x < NUM_INTS; ++x)
		{
			// the code below literally means
			// totalSum = totalSum + arry[x]
			totalSum += arry[x];
		}
		// after the calculations are complete, display the total to the user
		System.out.println(totalSum);									
	}// end of main	
	
	public static void setwRF(String str, int width, char fill)
	{
		System.out.print(str);
		for (int x = str.length(); x < width; ++x)
		{
			System.out.print(fill);     
		}
	}// end of setwRF	
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

SAMPLE OUTPUT

Welcome to My Programming Notes' Java Program.
Original array values: 22 26 41 89 35 90 15 99 85 5 95 86 -------------------------------------------------- The sum of the items in the array is: 688

===== SUBTRACTION =====

The second code snippet will demonstrate how to subtract numbers which are stored in an integer array. This example uses the “-=” assignment operator.





		
		
			#2 - Subtraction Using An Int Array
			
Java
			
			import java.util.Random;

public class Subtraction
{
	// global variable declaration
	static Random rand = new Random();		
	static final int NUM_INTS = 12;	// const int allocating space for the array
	
	public static void main(String[] args)
	{
		// declare & initialize variables
		int[] arry = new int[NUM_INTS]; // array is initialized using a const variable
		int totalSum = 0;		
		
		System.out.println("Welcome to My Programming Notes' Java Program.n");
		
		// place random numbers into the array
		for(int x = 0; x < NUM_INTS; ++x)
		{
			arry[x] = rand.nextInt(100)+1;
		} 
		
		System.out.println("Original array values:");
		// Display the original array values
		for(int x = 0; x < NUM_INTS; ++x)
		{
			System.out.print(arry[x]+"  ");
		}	
		
		// creates a line seperator if user wants to enter new data
		System.out.println("");
		setwRF("", 50, '-');
		
		System.out.print("nThe difference of the items in the array is: ");
		// Find the sum of the values in the array
		for(int x = 0; x < NUM_INTS; ++x)
		{
			// the code below literally means
			// totalSum = totalSum - arry[x]
			totalSum -= arry[x];
		}
		// after the calculations are complete, display the total to the user
		System.out.println(totalSum);									
	}// end of main	
	
	public static void setwRF(String str, int width, char fill)
	{
		System.out.print(str);
		for (int x = str.length(); x < width; ++x)
		{
			System.out.print(fill);     
		}
	}// end of setwRF	
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
				
						import java.util.Random;
 
public class Subtraction
{
	// global variable declaration
	static Random rand = new Random();		
	static final int NUM_INTS = 12;	// const int allocating space for the array
	
	public static void main(String[] args)
	{
		// declare & initialize variables
		int[] arry = new int[NUM_INTS]; // array is initialized using a const variable
		int totalSum = 0;		
		
		System.out.println("Welcome to My Programming Notes' Java Program.n");
		
		// place random numbers into the array
		for(int x = 0; x < NUM_INTS; ++x)
		{
			arry[x] = rand.nextInt(100)+1;
		} 
		
		System.out.println("Original array values:");
		// Display the original array values
		for(int x = 0; x < NUM_INTS; ++x)
		{
			System.out.print(arry[x]+"  ");
		}	
		
		// creates a line seperator if user wants to enter new data
		System.out.println("");
		setwRF("", 50, '-');
		
		System.out.print("nThe difference of the items in the array is: ");
		// Find the sum of the values in the array
		for(int x = 0; x < NUM_INTS; ++x)
		{
			// the code below literally means
			// totalSum = totalSum - arry[x]
			totalSum -= arry[x];
		}
		// after the calculations are complete, display the total to the user
		System.out.println(totalSum);									
	}// end of main	
	
	public static void setwRF(String str, int width, char fill)
	{
		System.out.print(str);
		for (int x = str.length(); x < width; ++x)
		{
			System.out.print(fill);     
		}
	}// end of setwRF	
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

SAMPLE OUTPUT

Welcome to My Programming Notes' Java Program.
Original array values: 99 92 91 26 1 52 98 62 51 22 64 65 -------------------------------------------------- The difference of the items in the array is: -723

===== MULTIPLICATION =====

The third code snippet will demonstrate how to multiply numbers which are stored in an integer array. This example uses the “*=” assignment operator.





		
		
			#3 - Multiplication Using An Int Array
			
Java
			
			import java.util.Random;

public class Multiplication
{
	// global variable declaration
	static Random rand = new Random();		
	static final int NUM_INTS = 12;	// const int allocating space for the array
	
	public static void main(String[] args)
	{
		// declare & initialize variables
		int[] arry = new int[NUM_INTS]; // array is initialized using a const variable
		int totalSum = 1;		
		
		System.out.println("Welcome to My Programming Notes' Java Program.n");
		
		// place random numbers into the array
		for(int x = 0; x < NUM_INTS; ++x)
		{
			arry[x] = rand.nextInt(100)+1;
		} 
		
		System.out.println("Original array values:");
		// Display the original array values
		for(int x = 0; x < NUM_INTS; ++x)
		{
			System.out.print(arry[x]+"  ");
		}	
		
		// creates a line seperator if user wants to enter new data
		System.out.println("");
		setwRF("", 50, '-');
		
		System.out.print("nThe product of the items in the array is: ");
		// Find the sum of the values in the array
		for(int x = 0; x < NUM_INTS; ++x)
		{
			// the code below literally means
			// totalSum = totalSum * arry[x]
			totalSum *= arry[x];
		}
		// after the calculations are complete, display the total to the user
		System.out.println(totalSum);									
	}// end of main	
	
	public static void setwRF(String str, int width, char fill)
	{
		System.out.print(str);
		for (int x = str.length(); x < width; ++x)
		{
			System.out.print(fill);     
		}
	}// end of setwRF	
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
				
						import java.util.Random;
 
public class Multiplication
{
	// global variable declaration
	static Random rand = new Random();		
	static final int NUM_INTS = 12;	// const int allocating space for the array
	
	public static void main(String[] args)
	{
		// declare & initialize variables
		int[] arry = new int[NUM_INTS]; // array is initialized using a const variable
		int totalSum = 1;		
		
		System.out.println("Welcome to My Programming Notes' Java Program.n");
		
		// place random numbers into the array
		for(int x = 0; x < NUM_INTS; ++x)
		{
			arry[x] = rand.nextInt(100)+1;
		} 
		
		System.out.println("Original array values:");
		// Display the original array values
		for(int x = 0; x < NUM_INTS; ++x)
		{
			System.out.print(arry[x]+"  ");
		}	
		
		// creates a line seperator if user wants to enter new data
		System.out.println("");
		setwRF("", 50, '-');
		
		System.out.print("nThe product of the items in the array is: ");
		// Find the sum of the values in the array
		for(int x = 0; x < NUM_INTS; ++x)
		{
			// the code below literally means
			// totalSum = totalSum * arry[x]
			totalSum *= arry[x];
		}
		// after the calculations are complete, display the total to the user
		System.out.println(totalSum);									
	}// end of main	
	
	public static void setwRF(String str, int width, char fill)
	{
		System.out.print(str);
		for (int x = str.length(); x < width; ++x)
		{
			System.out.print(fill);     
		}
	}// end of setwRF	
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

SAMPLE OUTPUT

Welcome to My Programming Notes' Java Program.
Original array values: 95 63 32 19 93 83 71 35 32 37 66 95 -------------------------------------------------- The product of the items in the array is: 494770176

===== DIVISION =====

The fourth code snippet will demonstrate how to divide numbers which are stored in an integer array. This example uses the “/=” assignment operator.





		
		
			#4 - Division Using An Int Array
			
Java
			
			import java.util.Random;

public class Division
{
	// global variable declaration
	static Random rand = new Random();		
	static final int NUM_INTS = 12;	// const int allocating space for the array
	
	public static void main(String[] args)
	{
		// declare & initialize variables
		int[] arry = new int[NUM_INTS]; // array is initialized using a const variable
		double totalSum = 1;		
		
		System.out.println("Welcome to My Programming Notes' Java Program.n");
		
		// place random numbers into the array
		for(int x = 0; x < NUM_INTS; ++x)
		{
			arry[x] = rand.nextInt(100)+1;
		} 
		
		System.out.println("Original array values:");
		// Display the original array values
		for(int x = 0; x < NUM_INTS; ++x)
		{
			System.out.print(arry[x]+"  ");
		}	
		
		// creates a line seperator if user wants to enter new data
		System.out.println("");
		setwRF("", 50, '-');
		
		System.out.print("nThe quotient of the items in the array is: ");
		// Find the sum of the values in the array
		for(int x = 0; x < NUM_INTS; ++x)
		{
			// the code below literally means
			// totalSum = totalSum / arry[x]
			totalSum /= arry[x];
		}
		// after the calculations are complete, display the total to the user
		System.out.println(totalSum);									
	}// end of main	
	
	public static void setwRF(String str, int width, char fill)
	{
		System.out.print(str);
		for (int x = str.length(); x < width; ++x)
		{
			System.out.print(fill);     
		}
	}// end of setwRF	
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
				
						import java.util.Random;
 
public class Division
{
	// global variable declaration
	static Random rand = new Random();		
	static final int NUM_INTS = 12;	// const int allocating space for the array
	
	public static void main(String[] args)
	{
		// declare & initialize variables
		int[] arry = new int[NUM_INTS]; // array is initialized using a const variable
		double totalSum = 1;		
		
		System.out.println("Welcome to My Programming Notes' Java Program.n");
		
		// place random numbers into the array
		for(int x = 0; x < NUM_INTS; ++x)
		{
			arry[x] = rand.nextInt(100)+1;
		} 
		
		System.out.println("Original array values:");
		// Display the original array values
		for(int x = 0; x < NUM_INTS; ++x)
		{
			System.out.print(arry[x]+"  ");
		}	
		
		// creates a line seperator if user wants to enter new data
		System.out.println("");
		setwRF("", 50, '-');
		
		System.out.print("nThe quotient of the items in the array is: ");
		// Find the sum of the values in the array
		for(int x = 0; x < NUM_INTS; ++x)
		{
			// the code below literally means
			// totalSum = totalSum / arry[x]
			totalSum /= arry[x];
		}
		// after the calculations are complete, display the total to the user
		System.out.println(totalSum);									
	}// end of main	
	
	public static void setwRF(String str, int width, char fill)
	{
		System.out.print(str);
		for (int x = str.length(); x < width; ++x)
		{
			System.out.print(fill);     
		}
	}// end of setwRF	
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

SAMPLE OUTPUT

Welcome to My Programming Notes' Java Program.
Original array values: 28 85 90 52 1 64 93 85 4 22 4 28 -------------------------------------------------- The quotient of the items in the array is: 1.8005063061510687E-17

Monthly Archives: January 2013

C++ || Simple Spell Checker Using A Hash Table

C++ || Custom Template Hash Table With Iterator Using Separate Chaining

Java || Snippet – How To Do Simple Math Using Integer Arrays

Search

Compile Your Code Now

Translate Page

Popular Pages

Recent

Archives

Categories