[Jogan101]

//------------------------------------------------------------------------------
   //  Essential Mutator: Increments the count associated with the given word.  If
   //		the word is not in the collection then it is added prior to the count being
   //		incremented.
   //------------------------------------------------------------------------------
	   public boolean Increment(String Word) {
		 boolean result = false;
		 int index = indexOf(Word);
		 if(index < 0) {
			if(next < limit) {
			
			   WC[next] = new WordCount(Word);
			  
			   next = WC[previous];
			   index = next;
			   next = next + 1;
			} 
			else {
			   index = -1;
			}
		 }
		 if(index >= 0) {
			result = (WC[index].Increment() > 0);
		 }
		 return result;
	  }
   	
   //------------------------------------------------------------------------------
   // Sorts the words in ascending order
   //------------------------------------------------------------------------------	

Alright so I need some clarification/help with this program. I need to take a word and insert into an array then take the next and insert that into the array and so on. The words need to be in ascending order. My question is should I make some sort of new method that sorts them or could I just somehow compare the words band then add them into there correct ascended position? using:

WC[next] = new WordCount(Word);

Thanks!

[markhazlett9]

You can do whichever works best for you. If you are going to be using your sorting algorithm more than once then I would recommend creating a separate method. This is just for optimization sake. You're on the right track. now do you need to put them in alphabetical order or something like that or just in space 0, 1, 2...?

[g00se]

Make WordCount implement Comparable and then use Arrays.sort, or use a custom Comparator

[Jogan101]

markhazlett9, on 6 Dec, 2008 - 01:05 PM, said:

You can do whichever works best for you. If you are going to be using your sorting algorithm more than once then I would recommend creating a separate method. This is just for optimization sake. You're on the right track. now do you need to put them in alphabetical order or something like that or just in space 0, 1, 2...?

They are going to be alphabetically

g00se, on 6 Dec, 2008 - 02:01 PM, said:

Make WordCount implement Comparable and then use Arrays.sort, or use a custom Comparator

Wordcount already implements Iterator is there a way to also implement Comparable

[Jogan101]

Heres my full code just for reference:

//*********************************************************************************
//  WordCounts.java	  Author: JTH
//	 An organized collection of WordCount objects.
//*********************************************************************************
   import java.util.*;
   
	public class WordCounts implements Iterator {
	  final public int LIMIT = 1024;	//The default capacity
	  private int limit;					//The object's actual capacity
	  private WordCount[] WC;				//The array of WordCount objects
	  private int next;						//The index of the available element position
   	
   //------------------------------------------------------------------------------
   //  Default Constructor: Uses the default capacity.
   //------------------------------------------------------------------------------
	   public WordCounts() {
		 Initialize(LIMIT);
	  }
		  
   //------------------------------------------------------------------------------
   //  Usual Constructor: Uses the given capacity;  if Limit < 1 then the default
   //		capacity is used instead.
   //------------------------------------------------------------------------------
	   public WordCounts(int Limit) {
		 if(Limit <= 0) {
			Limit = LIMIT;
		 }
		 Initialize(Limit);
	  }
   
   	/////////////////////////////////////////////////////////////////////////////
   	// Used by the constructors to initialize the instance variables
	   private void Initialize(int Limit) {
		 limit = Limit;
		 WC = new WordCount[Limit];
		 next = 0;
	  }
   	/////////////////////////////////////////////////////////////////////////////
   		
   //------------------------------------------------------------------------------
   //  Accessor: Returns the count of the number of elements in the collection.
   //------------------------------------------------------------------------------
	   public int N() {
		 return next;
	  }
   	
   	/////////////////////////////////////////////////////////////////////////////
   	// Used by Contains, Increment and get to determine the index of the given 
   	//	word.  A return value of -1 indicates the word was not found.
	   private int indexOf(String Word) {
		 int result = next - 1;
		 while((result >= 0) && (Word.compareTo(WC[result].Word()) != 0)) {
			result = result - 1;
		 }
		 //System.out.println(Word + "@" + result);
		 return result;
	  }
   	/////////////////////////////////////////////////////////////////////////////
   	
   //------------------------------------------------------------------------------
   //  Predicate: Used to determine whether the given word is currently in the
   //		collection.
   //------------------------------------------------------------------------------
	   public boolean Contains(String Word) {
		 int index = indexOf(Word);
		 return (index >= 0) && (Word.equals(WC[index].Word()));
	  }
   	
   //------------------------------------------------------------------------------
   //  Essential Mutator: Increments the count associated with the given word.  If
   //		the word is not in the collection then it is added prior to the count being
   //		incremented.
   //------------------------------------------------------------------------------
	   public boolean Increment(String Word) {
		 boolean result = false;
		 int index = indexOf(Word);
		 if(index < 0) {
			if(next < limit) {
			
			   WC[next] = new WordCount(Word);
			  
			   next = WC[previous];
			   index = next;
			   next = next + 1;
			} 
			else {
			   index = -1;
			}
		 }
		 if(index >= 0) {
			result = (WC[index].Increment() > 0);
		 }
		 return result;
	  }
   	
   //------------------------------------------------------------------------------
   // Sorts the words in ascending order
   //------------------------------------------------------------------------------	
			
   
   
   
   
   
   
   
   
   //------------------------------------------------------------------------------
   //  Accessor: Returns the WordCount object containing the given Word.  If the
   //		word is not in the collection then null is returned.
   //------------------------------------------------------------------------------
	   public WordCount get(String Word) {
		 WordCount result = null;
		 int index = indexOf(Word);
		 if(index >= 0) {
			result = WC[index];			
		 }
		 return result;
	  }
   	
   ///////////////////////////////////////////////////////////////////////////////////   
   // Iterator Interface instance variables and methods
   ///////////////////////////////////////////////////////////////////////////////////   
	  private int prev = Integer.MAX_VALUE;	//Index of the last element visited
	  private int curr = Integer.MAX_VALUE;	//Index of the next element to be visited
   	
   //------------------------------------------------------------------------------
   //  Resets the iteration so that it starts at the beginning.
   //------------------------------------------------------------------------------
	   public boolean Reset() {
		 curr = 0;	prev = 0;
		 return true;
	  }
   	
   //------------------------------------------------------------------------------
   //  Returns true if more elements remain to be visisted.
   //------------------------------------------------------------------------------
	   public boolean hasNext() {
		 return curr < next;
	  }
   	
   //------------------------------------------------------------------------------
   //  Returns the next WordCount object to be visisted.
   //------------------------------------------------------------------------------
	   public Object next() {
		 Object result = null;
		 if(this.hasNext()) {
			result = WC[curr];
			prev = curr;  curr = curr + 1;
		 }
		 return result;
	  }
   	
   //------------------------------------------------------------------------------
   //  Removes the last element visited from the collection.
   //------------------------------------------------------------------------------
	   public void remove() {
		 if((prev < curr) && (prev < next)) {
			for(int i=prev; i < next; i++) {
			   WC[i] = WC[i+1];
			}
			prev = curr;
			next = next - 1;
		 }
	  }
   	
   }

[William_Wilson]

you can implement as many interfaces as you want.
public class WordCounts implements Iterator, Comparable

[KYA]

Java's pseudo multiple inheritance.

[g00se]

It's the class WordCount that we need to see, not WordCounts

btw, is it just me or has the usual link to copy syntax-highlighted code to the clipboard disappeared..?

[Jogan101]

g00se, on 7 Dec, 2008 - 03:23 AM, said:

It's the class WordCount that we need to see, not WordCounts

btw, is it just me or has the usual link to copy syntax-highlighted code to the clipboard disappeared..?

//*********************************************************************************
//  WordCount.java	  Author: JTH
//*********************************************************************************

	public class WordCount {
	  private String word;				//The word represented as a string
	  private int count = 0;			//The corresponding count
		  
	   public WordCount(String S) {	//The essential constructor
		 word = S;
	  }
		  
	   public String Word() {			//Accessor for the word
		 return word;
	  }
		  
	   public int Increment() {		//Essential mutator that increases the count
		 count = count + 1;
		 return 1;
	  }
		  
	   public int Count() {			//Accessor for the count
		 return count;
	  }
   }

thanks

[g00se]

Do i take it that you want to sort by count rather than the word itself?

Method names, incidentally should begin lower case, as should variable names. An example would be

public class WordCount implements Comparable<WordCount> {
    private int count;

    public int compareTo(WordCount other) {
        return count - other.count;
    }
}

[Jogan101]

g00se, on 7 Dec, 2008 - 10:29 AM, said:

Do i take it that you want to sort by count rather than the word itself?

Method names, incidentally should begin lower case, as should variable names. An example would be

public class WordCount implements Comparable<WordCount> {
    private int count;

    public int compareTo(WordCount other) {
        return count - other.count;
    }
}

No i am trying to sort it alphabetically. I was thinking along the lines of an insertion sort algorithm I'm just not sure where exactly I would put that in my WordCounts class.

[Jogan101]

Is there anyway I can just compare the words in this method and then just add them into their correct alphabetical positions?

 //------------------------------------------------------------------------------
   //  Essential Mutator: Increments the count associated with the given word.  If
   //		the word is not in the collection then it is added prior to the count being
   //		incremented.
   //------------------------------------------------------------------------------
	   public boolean Increment(String Word) {
		 boolean result = false;
		 int index = indexOf(Word);
		 if(index < 0) {
			if(next < limit) {
			   
			   WC[next] = new WordCount(Word);
			  
			   index = next;
			   next = next + 1;
			} 
			else {
			   index = -1;
			}
		 }
		 if(index >= 0) {
			result = (WC[index].Increment() > 0);
		 }
		 return result;
	  }

[g00se]

If you store your WordCount obejcts in a TreeSet owned by WordCounts, then, with the change i just made applied to the word instead of the count, they'll be stored in word order automatically

[Jogan101]

g00se, on 7 Dec, 2008 - 02:34 PM, said:

If you store your WordCount obejcts in a TreeSet owned by WordCounts, then, with the change i just made applied to the word instead of the count, they'll be stored in word order automatically

What do you mean? Could you please show me?

See I was thinking about putting something along these lines into my WordCounts class.

 //------------------------------------------------------------------------------
	//  Sorts the words using the insertion sort algorithm
	//------------------------------------------------------------------------------
		public static void insertionSort (Comparable[] list)
		{
			for (int index = 1; index < list.length; index++)
			{
				Comparable key = list[index];
				int position = index;
				while (position > 0 && key.compareTo(list[position-1]) < 0)
				{
					list[position] = list[postion-1];
					postion--;
				}
				
				list[position] = key;
			}
		}
	}

I'm just not sure how to fix this code so it applies to the words.

[Jogan101]

Anyone have any idea about this?