So I am having alot of difficulty conceptualizing answers for the following questions. I am not looking for answers but rather useful steps that I can take that will enable me to present the answers on my own. Note: to answer these questions I am given classes referenced, and a driver program. The questions are as follows:
Q.1 Implement a method replace for the ADT bag that replaces and returns any object currently in a bag with a
given object.
Q.2.Write a remove method to remove every instance of an element in an ArrayBag.
Q.3. Give at least two examples of a situation where a fixed bag is appropriate and two examples of a situation where a resizable bag is appropriate.
The following code is what I have started but am not sure if I am in right direction:
a.1 public T replace(T theItem) {
Random generator = new Random();
int randomPosition = generator.nextInt(numberOfEntries);
T result = null;
if (!isEmpty() && (randomPosition >= 0)) {
result = bag[randomPosition]; // Entry to remove
bag[randomPosition] = theItem; // Replace entry to remove with
// last entry
}
return result;
a.2 public void clear(T theItem) {
while (!this.isEmpty(ArrayBag))
this.remove();
a.3 not sure it should be related to coding examples or something else.
Additionally, the class for the ArrayBag is below for reference:
import java.util.Arrays;
import java.util.Random;
public final class ArrayBag<T> implements BagInterface<T> {
private final T[] bag;
private int numberOfEntries;
private boolean initialized = false;
private static final int DEFAULT_CAPACITY = 25;
private static final int MAX_CAPACITY = 10000;
/** Creates an empty bag whose initial capacity is 25. */
public ArrayBag() {
this(DEFAULT_CAPACITY);
} // end default constructor
/**
* Creates an empty bag having a given capacity.
*
* #param desiredCapacity
* The integer capacity desired.
*/
public ArrayBag(int desiredCapacity) {
if (desiredCapacity <= MAX_CAPACITY) {
// The cast is safe because the new array contains null entries
#SuppressWarnings("unchecked")
T[] tempBag = (T[]) new Object[desiredCapacity]; // Unchecked cast
bag = tempBag;
numberOfEntries = 0;
initialized = true;
} else
throw new IllegalStateException("Attempt to create a bag "
+ "whose capacity exceeds " + "allowed maximum.");
} // end constructor
/**
* Adds a new entry to this bag.
*
* #param newEntry
* The object to be added as a new entry.
* #return True if the addition is successful, or false if not.
* /
public boolean add(T newEntry) {
checkInitialization();
boolean result = true;
if (isArrayFull()) {
result = false;
} else { // Assertion: result is true here
bag[numberOfEntries] = newEntry;
numberOfEntries++;
} // end if
return result;
} // end add
/**
* Retrieves all entries that are in this bag.
*
* #return A newly allocated array of all the entries in this bag.
*/
public T[] toArray() {
checkInitialization();
// The cast is safe because the new array contains null entries.
#SuppressWarnings("unchecked")
T[] result = (T[]) new Object[numberOfEntries]; // Unchecked cast
for (int index = 0; index < numberOfEntries; index++) {
result[index] = bag[index];
} // end for
return result;
// Note: The body of this method could consist of one return statement,
// if you call Arrays.copyOf
} // end toArray
/**
* Sees whether this bag is empty.
*
* #return True if this bag is empty, or false if not.
*/
public boolean isEmpty() {
return numberOfEntries == 0;
} // end isEmpty
/**
* Gets the current number of entries in this bag.
*
* #return The integer number of entries currently in this bag.
*/
public int getCurrentSize() {
return numberOfEntries;
} // end getCurrentSize
/**
* Counts the number of times a given entry appears in this bag.
*
* #param anEntry
* The entry to be counted.
* #return The number of times anEntry appears in this ba.
*/
public int getFrequencyOf(T anEntry) {
checkInitialization();
int counter = 0;
for (int index = 0; index < numberOfEntries; index++) {
if (anEntry.equals(bag[index])) {
counter++;
} // end if
} // end for
return counter;
} // end getFrequencyOf
/**
* Tests whether this bag contains a given entry.
*
* #param anEntry
* The entry to locate.
* #return True if this bag contains anEntry, or false otherwise.
*/
public boolean contains(T anEntry) {
checkInitialization();
return getIndexOf(anEntry) > -1; // or >= 0
} // end contains
/** Removes all entries from this bag. */
public void clear() {
while (!this.isEmpty())
this.remove();
} // end clear
/**
* Removes one unspecified entry from this bag, if possible.
*
* #return Either the removed entry, if the removal was successful, or null.
*/
public T remove() {
checkInitialization();
T result = removeEntry(numberOfEntries - 1);
return result;
} // end remove
/**
* Removes one occurrence of a given entry from this bag.
*
* #param anEntry
* The entry to be removed.
* #return True if the removal was successful, or false if not.
*/
public boolean remove(T anEntry) {
checkInitialization();
int index = getIndexOf(anEntry);
T result = removeEntry(index);
return anEntry.equals(result);
} // end remove
public boolean removeRandom() {
Random generator = new Random();
int randomPosition = generator.nextInt(numberOfEntries);
T result = removeEntry(randomPosition);
if (result == null) {
return false;
} else {
return true;
}
}
#Override
public boolean equals(Object obj) {
if (obj instanceof ArrayBag) {
ArrayBag<T> otherArrayBag = (ArrayBag<T>) obj;
if (numberOfEntries == otherArrayBag.numberOfEntries) {
// I create new arrays so that I can manipulate them
// and it will not alter this.bag or otherArrayBag.bag
T[] currentBagTempArray = toArray();
T[] otherBagTempArray = otherArrayBag.toArray();
Arrays.sort(currentBagTempArray);
Arrays.sort(otherBagTempArray);
for (int i = 0; i < numberOfEntries; i++) {
if (!currentBagTempArray[i].equals(otherBagTempArray[i])) {
return false;
}
}
return true;
} else {
return false;
}
} else {
return false;
}
}
public ResizableArrayBag<T> createResizableArray() {
T[] currentBagContents = toArray();
ResizableArrayBag<T> newBag = new ResizableArrayBag<T>(currentBagContents);
return newBag;
}
// Returns true if the array bag is full, or false if not.
private boolean isArrayFull() {
return numberOfEntries >= bag.length;
} // end isArrayFull
// Locates a given entry within the array bag.
// Returns the index of the entry, if located,
// or -1 otherwise.
// Precondition: checkInitialization has been called.
private int getIndexOf(T anEntry) {
int where = -1;
boolean found = false;
int index = 0;
while (!found && (index < numberOfEntries)) {
if (anEntry.equals(bag[index])) {
found = true;
where = index;
} // end if
index++;
} // end while
// Assertion: If where > -1, anEntry is in the array bag, and it
// equals bag[where]; otherwise, anEntry is not in the array.
return where;
} // end getIndexOf
// Removes and returns the entry at a given index within the array.
// If no such entry exists, returns null.
// Precondition: 0 <= givenIndex < numberOfEntries.
// Precondition: checkInitialization has been called.
private T removeEntry(int givenIndex) {
T result = null;
if (!isEmpty() && (givenIndex >= 0)) {
result = bag[givenIndex]; // Entry to remove
int lastIndex = numberOfEntries - 1;
bag[givenIndex] = bag[lastIndex]; // Replace entry to remove with
// last entry
bag[lastIndex] = null; // Remove reference to last entry
numberOfEntries--;
} // end if
return result;
} // end removeEntry
// Throws an exception if this object is not initialized.
private void checkInitialization() {
if (!initialized)
throw new SecurityException(
"ArrayBag object is not initialized properly.");
} // end checkInitialization
} // end ArrayBag
Someone else implemented Bag using an Array at Bag Class Implementation in Java/Using Array . I only glanced at the code, so it may be a mixed Bag.
I'm assuming that Bag is like a Set, except in can store the same object more than once.
You would want to implement a private collection of some sort (perhaps an Array like above). Let's call it myBag.
Since you're using a generic type T, your Bag will only contain objects of type T.
For Q1, your replace() method might need to take two parameters: The object to be replaced (say findMe) and the object you're replacing it with (say replacement).
If your Bag can hold duplicates, then you will probably want to replace the first object that matches.
Rather than use Random(), you might need to go element by element through myBag, and replace the found element with the one you're replacing. You might want to throw an error if findMe is not found. So the method declaration might be something like:
public boolean replace(T findMe, T replacement)
and return true if findMe was found, false otherwise.
For Q2, you could create a while loop that removes the first element in myBag while the size of myBag was > 0.
For Q3, thre's no coding involved. This is a thinking question. In general, a fixed size Bag would be helpful when the size is known at the beginning will not change.
A resizable bag makes sense in more cases, where you don't know the size at the beginning and it is likely to shrink or grow, for example, a waiting list for a class.
I looked your starting code and class but I did not run it.
But I can say that you are in right direction.
For Q2, You should search the given element in array and remove the each one. Because question clearly says that "remove every instance of an element " Please check the getIndexOf() method. You can see how to search and element. If you find one matching remove it. Be careful if you remove and element while you are iterating over it. If you delete one element while you are iterating size will change. I offer you to store each matching on an array. After iteration use remove(index) method for each found element
Give at least two examples of a situation where a fixed bag is appropriate and two examples of a situation where a resizable bag is appropriate.
For this item you can add some explanation and some sample code or algorithm.
I can offer you two thing:
1. If the array is not getting full too fast fixed size is good. But if array is getting full too fast you should resize new array and copy all elements again and again. Overhead amount is important.
2. Amount of capacity is important. How you will decide initial size ? Big size or small size ? Think that
I hope this helps
Related
I'm trying to use this code to implement a Priority Queue. There are a number of questions regarding this implementation on the site, but given how many different ways you can write code to do essentially the same thing I am still at a loss after looking through a handful of other examples.
There are some missing lines in this code, but I am limited to editing only the four marked lines and so I find myself stuck on one particular aspect. I can't seem to understand how 'quantity' is incremented.
From my understanding main creates a new object of maxSize = 5. Then calls the insertItem method passing the value of 130. This should be placed into the root (I had put queArray[quantity] = item; into the first blank) at which point the insertItem method exits and is then called again with the next value. So at what point is 'quantity' incremented? Maybe I am missing something incredibly simple, or maybe there is another way of solving this that may not be apparent or known to beginners like me?
I would think you would want to increment quantity under the initial if statement, but that doesn't seem to be an option, so as far as I can tell the else statement can never be executed as quantity doesn't change. I know I am incorrect, but I don't know how, some help would be greatly appreciated.
public class Main {
/**
* #param args the command line arguments
*/
// array in sorted order, from max at 0 to min at size-1
private int maxSize;
private long[] queArray;
private int quantity;
public Main(int s) {
maxSize = s;
queArray = new long[maxSize];
quantity = 0;
}
public void insertItem(long item) {
int i;
if (quantity == 0)
__________; // insert at 0
else
{
for (i = quantity - 1; i >= 0; i--) // start at end,
{
if (item > queArray[i]) // if new item larger,
__________; // shift upward
else
// if smaller,
break; // done shifting
}
__________; // insert it
__________;
} // end else (quantity > 0)
}
public boolean PQEmpty(){
return (quantity == 0);
}
public long removeItemPQ(){
return queArray[--quantity];
}
public long peekMin(){
return queArray[quantity - 1];
}
public static void main(String[] args) {
Main thePQ = new Main(5);
thePQ.insertItem(130);
thePQ.insertItem(450);
thePQ.insertItem(110);
thePQ.insertItem(430);
thePQ.insertItem(280);
while (!thePQ.PQEmpty()) {
long item = thePQ.removeItemPQ();
System.out.print(item + " ");
}
System.out.println("");
}
}
It isn't a style I'd recommend, but you could use queArray[quantity++] = item;.
Right now, I have a method that is supposed to use binary search to find if a prefix is in a list.
For example, user enters "ca" and if dictionary contains "cat", then the method should return true.
This is my method and along it is a helper method. The problem I have right now is that when I call the recursive method and the prefix is greater than the words in the dictionary, I will get an index out of bounds error because of the substring() method.
I'm using this method in conjunction with a recursive function in order to find all permutations of a string. (The generateWords() method).
How can I modify this function in order to check whether a prefix is in a list of words given that the list of words have words of varying lengths?
public boolean findPrefix(String Prefix){
return findBinaryPrefix(listOfWords, Prefix,0, listOfWords.size()-1, 0);
}
/**
* Helper function for findPrefix.
* #param list arraylist
* #param prefix prefix you want to find
* #param low lowest index
* #param high highest index of the array.
* #return returns true if prefix is in the dictionary, else false.
*/
private boolean findBinaryPrefix(ArrayList<String> list, String prefix, int low, int high, int prefixLength){
int charCounter = prefixLength;
if(low>high){
return false;
}
int mid = (low+high)/2;
if(list.get(mid).substring(0, charCounter).equals(prefix.substring(0, charCounter))){
//If the word is equal, then that's the base case.
return true;
}
else if (list.get(mid).substring(0, charCounter).compareTo(prefix.substring(0, charCounter)) < 0){
return findBinaryPrefix(list, prefix, mid+1, high, charCounter);
}
else
return findBinaryPrefix(list, prefix, low, mid-1, charCounter);
}
private ArrayList<String> generateWords(Dictionary dict,String prefix, String seq){
if(seq.length() == 0){
if(dict.findWord(prefix)){
permList.add(prefix);
}
}
else{
for(int i = 0;i<seq.length(); i++){
if(!dict.findPrefix(prefix)){break;}
//if prefix is not even in dictionary, don't bother generating.
//generate permutations when the character is in a different position with each iteration of the loop.
generateWords(dict, prefix + seq.charAt(i) ,seq.substring(0,i) + seq.substring(i+1, seq.length()));
}
}
return permList;
}
add
if(list.get(mid).length() < charCounter) {
//do something
}
I'm getting some weird bad operand errors which I cannot seem to resolve.
public class Model {
// Keep track of whether a move animation is currently playing.
// When a move animation is busy then no new moves are allowed.
private boolean moveInProgress = false;
private int[][] pieces = new int[7][7];
private boolean gameOver = false;
public void checkGameOver() {
// TODO (step 3): implement this correctly.
gameOver = true;
}
/**
* Check if a new disk can be inserted in the current column.
* #param column
* #return true if and only if a move in this column is allowed.
*/
public boolean playableMove(int column) {
// No new moves are allowed when an animation is busy.
if (getMoveInProgress()) {
return false;
}
// TODO (step 3) No moves are allowed when the game is over.
if (gameOver) {
return false;
}
// TODO: Check if this move is playable.
if (pieces[column] > 6) {
return false;
}
return true;
}
/**
* Compute the final destination row of a candidate move.
* #param column
* #return the row.
*/
public int moveDestination(int column) {
// TODO: implement this method properly.
int positie = 6 - pieces[column];
return positie;
}
/**
* Commit the insertion of a new disk in a given column.
* #param column
*/
public void playMove(int column) {
// TODO: Verify the following preconditions:
// assert (isGameOver() == false);
// assert (playableMove(column) == true);
// TODO: Update the model to reflect the new move.
// TODO (step 3): Also check for termination conditions.
// TODO (step 3): Notify subscribers about important model changes.
if (!gameOver && playableMove(column)) {
pieces[column]++;
}
}
}
The errors are at
(76,28) bad operator for binary operator '>'
first type int[]
second type int
The same error is repeated 4 times.
Can anyone help me with this
You've defined private int[][] pieces = new int[7][7];. So when you access it with pieces[column], you're left with an array, so you can't compare it with an int.
You probably meant pieces[column].length ?
If you want to do any arithmetic operations with each element of an array, you'll have to do so explicitly.
For example,
if (!gameOver && playableMove(column)) {
for (int i=0; i < pieces[column].length; i++) {
pieces[column][i]++;
}
}
About the other checks (6 - pieces[column] which is meant to result in an integer and pieces[column] > 6 which leaves it unclear if this condition is meant to be applied to all elements or at least one) I cannot help you due to unknown preconditions.
everyone. I am currently having issue on doing the evaluation of postfix expression in Java and I think everything is alright except the output is not really correct. But never mind, please let me to post all the codes so that all of you can have a look on them. By the way, please be noted that all of you just need to concentrate on TestPalindrome class is enough because I never change the codes for the other classes except the class that I specified just now.
StackInterface defines all the methods that are available to ArrayStack class.
//There is no need to check this.
public interface StackInterface<T> {
/** Task: Adds a new entry to the top of the stack.
* #param newEntry an object to be added to the stack */
public void push(T newEntry);
/** Task: Removes and returns the stack誷 top entry.
* #return either the object at the top of the stack or, if the
* stack is empty before the operation, null */
public T pop();
/** Task: Retrieves the stack誷 top entry.
* #return either the object at the top of the stack or null if
* the stack is empty */
public T peek();
/** Task: Detects whether the stack is empty.
* #return true if the stack is empty */
public boolean isEmpty();
/** Task: Removes all entries from the stack */
public void clear();
} // end StackInterface
ArrayStack class that is nothing special.
//There is no need to check this.
public class ArrayStack<T> implements StackInterface<T> {
private T[] stack; // array of stack entries
private int topIndex; // index of top entry
private static final int DEFAULT_INITIAL_CAPACITY = 50;
public ArrayStack() {
this(DEFAULT_INITIAL_CAPACITY);
} // end default constructor
public ArrayStack(int initialCapacity) {
stack = (T[]) new Object[initialCapacity];
topIndex = -1;
} // end constructor
public void push(T newEntry) {
topIndex++;
if (topIndex >= stack.length) // if array is full,
doubleArray(); // expand array
stack[topIndex] = newEntry;
} // end push
public T peek() {
T top = null;
if (!isEmpty())
top = stack[topIndex];
return top;
} // end peek
public T pop() {
T top = null;
if (!isEmpty()) {
top = stack[topIndex];
stack[topIndex] = null;
topIndex--;
} // end if
return top;
} // end pop
public boolean isEmpty() {
return topIndex < 0;
} // end isEmpty
public void clear() {
} // end clear
/** Task: Doubles the size of the array of stack entries.
* Refer to Segment 5.18 */
private void doubleArray() {
T[] oldStack = stack; // get reference to array of stack entries
int oldSize = oldStack.length; // get max size of original array
stack = (T[]) new Object[2 * oldSize]; // double size of array
// copy entries from old array to new, bigger array
System.arraycopy(oldStack, 0, stack, 0, oldSize);
} // end doubleArray
} // end ArrayStack
The following class is TestPalindrome class.(The class name may sounds strange because the exercises that I did were all in the same class and I do not post the irrelevant codes in the class.)
import java.util.Scanner;
public class TestPalindrome {
public TestPalindrome() {
}
public static void main(String[] args) {
//P3Q2
StackInterface<Character> myStack = new ArrayStack<Character>();
Scanner scanner = new Scanner(System.in);
int result;
char resultInChar;
System.out.print("Please enter a postfix expresion : ");
String postfix = scanner.nextLine();
for(int i = 0; i < postfix.length(); i++)
{
char postfixChar = postfix.charAt(i);
if(Character.isDigit(postfixChar)) //If postfixChar is a digit, then it will be pushed into the stack.
{
myStack.push(postfixChar);
}
/*(For else statement) First operand will be popped as right operand and second
operand will be popped as left operand if postfixChar is operator such as + .
The calculation of both operands will be carried out based on the operator given.
After this the result of calculation will be pushed back into the stack and the
same things will happen again.*/
else
{
int firstOperand = Character.getNumericValue(myStack.pop()); //To get numeric value of the first character stored.
System.out.println("\nThe right operand : " + firstOperand);
int secondOperand = Character.getNumericValue(myStack.pop()); //To get numeric value of the second character stored.
System.out.println("The left operand : " + secondOperand);
switch(postfixChar)
{
case '+':
result = secondOperand + firstOperand;
System.out.println("The result is " + result);
resultInChar = (char)result; //Convert the result of calculation back to character data type so that it can be pushed into the stack.
System.out.println("Strange output : " + resultInChar); //Here is where the strange output occurred.
myStack.push(resultInChar);
break;
case '-':
result = secondOperand - firstOperand;
System.out.println("The result is " + result);
resultInChar = (char)result;
myStack.push(resultInChar);
break;
case '/':
result = secondOperand / firstOperand;
System.out.println("The result is " + result);
resultInChar = (char)result;
myStack.push(resultInChar);
break;
case '*':
result = secondOperand * firstOperand;
System.out.println("The result is " + result);
resultInChar = (char)result;
myStack.push(resultInChar);
break;
}
}
}
System.out.println("\nThe answer of " + postfix + " is " + Character.getNumericValue(myStack.pop())); //To get the final answer in the form of numeric value
}
}
Here is the attachment of the picture to show all the outputs of the program.
Please explain the wrong part as I really cannot figure out why this will happen since 1 + 1 = 2 and the ASCII code of 2 which is 50 should be displayed instead of the weird square symbol.Thanks because spending the valuable time to look into my problem.
You say:
Please explain the wrong part as I really cannot figure out why this
will happen since 1 + 1 = 2 and the ASCII code of 2 which is 50 should
be displayed instead of the weird square symbol.
Yes, 1 + 1 = 2. But if you cast it to a char, it will use ASCII value 2, and not 50. To do that, you should do something like:
resultCharIn = (char) ('0' + result);
In other words: '0' != 0.
However, this seems like a wrong approach, because: what if the result is greater than 9. You will need two characters. Maybe you should consider a different design?
I am creating a stock exchange type program and so far I've got the input working so that it takes the command from the user properly. However what it does to the input isn't working as expected. The first thing I am confused on is why it is throwing me a NullPointerException when I run the code.
Basically the program will take an input of 3 things followed by whitespace between them. So for instance I want to buy 30 shares at $20 each, I would type the input like the following:
b 30 20
It would then split it into 3 parts and store it into an array. After that it will compare the first index of the array to see what the program should do, in this example it will buy so it will invoke the buy method and store the share amount and share value into my CircularArrayQueue.
It gets the share value and share amount stored into a Node, but when I try to invoke the enqueue method with my CirularArrayQueue to store the Node into the Queue, it gives me a NullPointerException.
Another issue I've been running into was the termination for the program. The program is supposed to terminate when it sees that the first index value of the input is "q". I've made a while loop stating that it will loop when the boolean quit is false. Then within the while loop I've made an if statement checking to see if the value of stockParts[0] is "q". If so it would change the value of quit to be true so it can end the loop, but for some reason it isn't terminating and it is still looping.
I've been scratching my head on these issues for a couple hours but I cannot seem to find the root of the problem. Could someone please assist me on this? The following is the code from my main class and the CircularArrayQueue class:
import java.util.Scanner;
import java.lang.Integer;
public class StockTran {
String command = "";
String[] stockParts = null;
CircleArrayQueue Q;
boolean quit = false;
public StockTran(String inputCommand) {
try {
Scanner conReader = new Scanner(System.in);
this.command = inputCommand.toLowerCase();
this.stockParts = command.split("\\s"); // splits the input into three parts
buyShares(Integer.parseInt(stockParts[1]), Integer.parseInt(stockParts[2])); //testing purpose only
while (quit == false) {
if (this.stockParts[0] == "q") { // ends transaction and terminates program
System.out.println("Share trading successfully cancelled.");
quit = true;
}
if (this.stockParts == null || this.stockParts.length > 3) {
throw new Exception("Bad input.");
}
if (stockParts[0] == "b") { // checks to see if it is a buying of shares
int shares = Integer.parseInt(stockParts[1]); // stores share amount
int value = Integer.parseInt(stockParts[2]); // stores selling value
buyShares(shares, value); // calls buyShares method and adds share to queue
}
else if (stockParts[0] == "s") { // checks to see if it is a selling of shares
int shares = Integer.parseInt(stockParts[1]); // stores share amount
int value = Integer.parseInt(stockParts[2]); // stores selling value
sellShares(shares, value); // calls sellShares method
}
else if (stockParts[0] == "c") { // checks to see if it is capital gain
capitalGain(); // calls capitalGain and calculates net gain
}
System.out.println("Enter your next command or press 'q' to quit: ");
command = conReader.nextLine().toLowerCase();
stockParts = command.split("\\s");
}
} catch (Exception e) {
e.printStackTrace();
}
}
public void buyShares(int shareAmout, int shareValue) { // takes in share total and values for each share
Node temp = new Node(shareAmout, shareValue); // stores values into node
try {
Q.enqueue(temp); // enqueues the node into the CircularArrayQueue
//System.out.println(Q.toString());
} catch (FullQueueException e) {
e.printStackTrace();
}
}
public void sellShares(int shareAmount, int sharePrice) { // ToDo
}
public int capitalGain() { // ToDo
return 0;
}
public static void main(String[] args) {
String inputCommand = "";
Scanner mainReader = new Scanner(System.in);
System.out.println("Enter 'b' to purchase share, 's' to sell share, 'c' for capital gain, or 'Q' to quit: ");
inputCommand = mainReader.nextLine();
StockTran tran = new StockTran(inputCommand);
}
}
public class CircleArrayQueue implements Queue {
protected Node Q[]; // initializes an empty array for any element type
private int MAX_CAP = 0; // initializes the value for the maximum array capacity
private int f, r;
public CircleArrayQueue(int maxCap) {
MAX_CAP = maxCap;
Q = new Node[MAX_CAP]; // sets Q to be a specific maximum size specified
f = 0; // sets front value to be 0
r = 0; // sets rear value to be 0;
}
public int size() {
return (MAX_CAP - f + r) % MAX_CAP; // returns the size of the CircularArrayQueue
}
public boolean isEmpty() { // if front and rear are of equal value, Queue is empty
return f == r;
}
public Node front() throws EmptyQueueException { // method to get the front value of the CircularArrayQueue
if (isEmpty()) throw new EmptyQueueException("Queue is empty.");
return Q[f]; // returns object at front of CircularArrayQueue
}
public Node dequeue() throws EmptyQueueException { // method to remove from the front of the CircularArrayQueue
if (isEmpty()) throw new EmptyQueueException("Queue is empty.");
Node temp = Q[f]; // stores front object in local variable
Q[f] = null; // sets the value to be null in the array
f = (f + 1) % MAX_CAP; // sets the new front value to be this
return temp; // returns the object that was originally in the front
}
public void enqueue(Node element) throws FullQueueException { // method to add to the end of the CircualarArrayQueue
if (size() == MAX_CAP - 1) throw new FullQueueException("Queue has reached maximum capacity.");
Q[r] = element; // stores the new element at the rear of array
r = (r + 1) % MAX_CAP; // sets the new rear value to be the location after element insertion
}
}
You haven't initialized the reference Q. Since it's a field variable, it's initialized by default to null.
CircleArrayQueue Q;
When you're faced with a problem like this, you have to debug it. One source of information is the stack trace from the exception, which will tell you where the exception was thrown. You may also be able to ask the debugger in your development environment to stop automatically at the point an exception is thrown.
Secondly, when you compare strings in Java, use the equals() method rather than the == operator. The equals() method compares object values. The == operator compares the values of the references that point to the objects. You can have two equal objects with different reference values.
initialize your CircleArrayQueue Q. if you dont initialize it. it takes null as default value.
CircleArrayQueue q= new CircleArrayQueue(size);