Question

Create a new Java Application that test MyStack by having the following methods in main class:

1. A method to generate a number of element between two given values and save them in a stack

2. A method to print a stack (10 elements per line). The original stack should remain as is after the print

3. A method to exchange the first element and the last element in a stack

4. A Boolean method to search for a value in a stack. The stack should remain the same after the search is finished.

5. A method to check if a stack is included in another stack (q1 is included in q2 if q1 is a sub-stack of q2). q1 and q2 should remain as they were originally

. 6. A method to inverse a stack.

7. A method to make a copy of a stack into a stack (the original stack should remain as it is).

8. The main method that does a.

Create 2 stacks s1 and s2 b. Insert 23 integers between 20 and 60 (do not insert duplicates) into s1 c. Insert 35 integers between 10 and 80 (do not insert duplicates) into s2. d. Give the user the choice which methods (2-7) to call and option to exit

Answer 1

1. For Generating random numbers and inserting into stacks:

public class Main {

final Random random = new Random();

final Set<Integer> stackSet1 = new HashSet<>();             //for stack1

final Set<Integer> stackSet2 = new HashSet<>();            // for stack2

final int[] numbers1 = new int[stackSet1.size()];

final int[] numbers2 = new int[stackSet2.size()];

public void Randomnumbers1 (){

while (stackSet1.size() < 24) {                         //for stack 1 as it contains only 23 elements.

stackSet1.add(random.nextInt(60-20) + 20);        // range for stack 1 is given between 20 to 60.

}

public void Randomnumbers2 (){

while (stackSet2.size() < 36) {                         //for stack 2 as it contains only 35 elements.

stackSet2.add(random.nextInt(80-10) + 10);        // range for stack 1 is given between 10 to 80.

}

final Iterator<Integer> iter1 = stackSet1.iterator();

for (int i = 0; iter1.hasNext(); ++i) {

numbers1[i] = iter1.next();

}

final Iterator<Integer> iter2 = stackSet2.iterator();

for (int i = 0; iter2.hasNext(); ++i) {

numbers2[i] = iter2.next();

}

System.out.println(Arrays.toString(numbers1));               //elements of stack 1

System.out.println(Arrays.toString(numbers2));              // elements of stack 2

}

For inserting elements into stack:

follow the following snippet:

public void stack_push(Stack<Integer> stack)

{

for(int i = 0; i < 24; i++)

{

stack.push(numbers1);

}

for(int i = 0; i < 36; i++)

{

stack.push(numbers2);

}

}

2. For printing the stack

static void printStack()

    {

        if(stack1.size() > 0)

        {

            int x = stack1.peek();                //same for stack 2

            stack1.pop();

            printStack();

        }

    }

3. Method to exchange 1st and last element of stack: same can be done with second stack

public void exchange(){

Object[] arr = stackSet1.toArray();

int x = stack1[0];

stack1[0] = stack1[stack1.length-1];

stack1[stack1.length-1] = x;

System.out.println("after swaping of first and last elements: "+Arrays.toString(stack1));

}

4. search a value in stack

public boolean serach(){

if (stack1.contains(numbers1[i])){

return true;

}

else

return false;

}

5. Inverse of stack can be implemented using function defined in 2 step, just add this method to the method mentioned in second step.

public void insert_at_the_bottom_of_array(int x)

    {

        if(stack1.isEmpty())

            stack1.push(numbers1[i]);

        else

        {

int a = stack1.peek();

            stack1.pop();

           insert_at_the_bottom_of_array(x)

             stack1.push(a);

        }

    } // same for stack 2

Others methods can be implemented using simple logic.