/*OddStack.

java
* Author: Seth Cram
* Description:
* A stack that holds ten integers and prioritizes odd number,
* without using a Stack Library. Its output is shown in
* outputOddStack.txt, and W11Main.java is its test file.
*
*Instructions:
* Create a file called OddStack.Java. In it create a class OddStack.
*
* OddStack must have 3 methods:
* public void push(int e)
* public int pop()
* @Override (not required but helps prevent errors)
* public String toString()
*
* OddStack is like most stacks. It takes in integers. The first integer
* pushed in is the last one popped out, but OddStack has one odd feature:
* all the odd integers that are pushed (like 5, 37 or 1) get popped before
* any even integer get popped even if an even integer is pushed after the
* odd ones. Other than that it maintains the order.
* The toString method prints out the elements in the form
* [e1, e2, ... en], but it prints them in the order they would be popped
* (not the order that they were pushed).
* You are free to implement your OddStack any way you want, as long as
* you do not use a Stack library from Java.
* The stack itself holds 10 elements. If you try to push to a full stack
* it must give the error:
* Error: OddStack is full
* If you try to pop form a stack that is empty it must give the error:
* Error: OddStack is empty
* Beyond that they only other thing that it should print is a confirmation
* when you push an element.
* For example push(35) should report:
* Pushing: 35
* Remember, you have limited space for compiling and running your program,
* so do not make your class too complex.
*
* Compile:
* javac -J-Xmx10m -J-Xms5m OddStack.java
* Run:
* java -Xmx10m -Xms5m W11Main
*
* Stack is a FIFO, first in first out, data structure
*
*/

public class OddStack {

private int max_depth; // max size of stack
private int ocurr_depth; //present size of odd array
private int ecurr_depth; //present size of even array
private int[] oddArray = new int[10];//array odd numbers stored in
private int[] evenArray = new int[10];//array even numbers stored in

//constructor
public OddStack(){
//odd and even arrays start with depths of 0
ocurr_depth = 0;
ecurr_depth = 0;
 max_depth = 10; //can't hold more than 10 ints
}

//adds number passed in to the top of either the even or odd array
public void push(int num){
System.out.println("Pushing: " + num);

if( ecurr_depth + ocurr_depth == max_depth ){ //if trying to append to a full

stack
System.out.println("Error: OddStack is full");
}
else{ //add number to an array

if( num % 2 == 1 ){ //if number is odd

ocurr_depth++; //add 1 to odd array depth
oddArray[ocurr_depth] = num; //add number to odd array
}else{ //number is even
ecurr_depth++; //adds 1 to even depth
evenArray[ecurr_depth] = num; //add number to even array
}
}
}

//Removes odd numbers in a FIFO manner, then removes even numbers in

// the same manner. Popped value locations aren't scrubbed.
public int pop(){
if( ecurr_depth + ocurr_depth == 0 ){ //if both arrrays empty
System.out.println("Error: OddStack is empty");
return 0; //To signify an error in addition to the print statement
}
else{

if( ocurr_depth != 0 ){ //if still odd numbers left

//removes the need for a temporary variable bc it returns

oddArray[occur_depth], then decrements occur_depth after
return oddArray[ocurr_depth--];
} else{ //only even numbers left
return evenArray[ecurr_depth--];
}
}
}

//Returns stack from right to left in list form. Rightmost number

// is the top of the stack.
@Override //overiding predefined toString() functions
public String toString(){
// new total array to hold combined even and odd arrays to return
int totArraySize = ocurr_depth + ecurr_depth; //needed in for loop
int[] totArray = new int[totArraySize];

//placeholders for odd and even depth so method caller's odd and deven depths
aren't altered
int oddPH = ocurr_depth;
int evenPH = ecurr_depth;

String completeList; //string to return the completed list of what's in

OddStack
 //combines even and odd arrays into totArray
while( oddPH + evenPH > 0 ){
if( oddPH > 0 ){ //copy over odd array
totArray[oddPH+evenPH-1] = oddArray[oddPH]; //have to subtract 1 bc if
totArray[0] not overwritten, it outputs a 0
oddPH--; //decremented to move onto next odd value
}else{ //copy over even array
totArray[evenPH-1] = evenArray[evenPH];
evenPH--;
}
}

// appends totArray's entries onto completeList string

completeList = "[";
for(int i = 0; totArraySize > i; i++){
completeList = completeList + totArray[i];

if( i != totArraySize-1){ //subtract 1 so don't add comma after final

element
completeList = completeList + ","; //commas to separate entries
}

}
completeList = completeList + "]";

return completeList; //return completeList string in the form of a list

}
}