Geek asks and answers

Stack array using pop () and push ()

I have a problem with two classes that I created for a program using the stack. The first problem I encountered is that when I try to start the program, an error occurs at runtime.

It is rather difficult to ask because he does a few things. It requests user input to add numbers to the stack and check if the stack is full or empty. I may also need help to copy the array.

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: -1 on IntegerStack.push (IntegerStack.java:24) in Lab15.main (Lab15.java:38)

This is the main class that runs the program.

import java.util.Scanner;


public class Lab15 {

    public static void main(String[] args)
    {
        System.out.println("***** Playing with an Integer Stack *****");
        final int SIZE = 5;
        IntegerStack myStack = new IntegerStack(SIZE);
        Scanner scan = new Scanner(System.in);

        //Pushing integers onto the stack
        System.out.println("Please enter an integer to push onto the stack - OR - 'q' to Quit");
        while(scan.hasNextInt())
        {
            int i = scan.nextInt();
            myStack.push(i);
            System.out.println("Pushed "+ i);
        }

        //Pop a couple of entries from the stack
        System.out.println("Lets pop 2 elements from the stack");
        int count = 0;
        while(!myStack.isEmpty() && count<2)
        {
            System.out.println("Popped "+myStack.pop());
            count++;
        }

        scan.next(); //Clearing the Scanner to get it ready for  further input.

        //Push a few more integers onto the stack
        System.out.println("Push in a few more elements - OR - enter q to quit");
        while(scan.hasNextInt())
        {
            int i = scan.nextInt();
            myStack.push(i);
            System.out.println("Pushed "+ i);
        }

        System.out.println("\nThe final contentes of the stack are:");
        while(!myStack.isEmpty())
        {
            System.out.println("Popped "+myStack.pop());
        }

    }

}

, , . . .

import java.util.Arrays;

public class IntegerStack 
{
    private int stack [];
    private int top; 

    public IntegerStack(int SIZE) 
    {
        stack = new int [SIZE];
        top = -1;
    }

    public void push(int i) 
    {
        if (top == stack.length)
        {
            extendStack();
        }

        stack[top]= i;
        top++;
    }

    public int pop() 
    {
        top --;
        return stack[top];
    }

    public int peek()
    {
        return stack[top];
    }

    public boolean isEmpty() 
    {
        if ( top == -1);
        {
            return true;
        }
    }

    private void extendStack()
    {
        int [] copy = Arrays.copyOf(stack, stack.length);
    }
}

.

+5
5

import java.util.List;
import java.util.ArrayList;
public class IntegerStack 

{

    private List<Integer> stack;

    public IntegerStack(int SIZE) 
    {
        stack = new ArrayList<Integer>(SIZE);
    }

    public void push(int i) 
    {

       stack.add(0,i);
     }

     public int pop() 
     { 
        if(!stack.isEmpty()){
           int i= stack.get(0);
           stack.remove(0);
           return i;
        } else{
           return -1;// Or any invalid value
        }
     }

     public int peek()
     {
        if(!stack.isEmpty()){
           return stack.get(0);
        } else{
           return -1;// Or any invalid value
        }
     }


     public boolean isEmpty() 
     {
       stack.isEmpty();
     }

 }

Array... .

import java.util.Arrays;
public class IntegerStack 
{

    private int stack [];
    private int top; 

    public IntegerStack(int SIZE) 
   {
    stack = new int [SIZE];
    top = -1; // top should be 0. If you keep it as -1, problems will arise when SIZE is passed as 0. 
    // In your push method -1==0 will be false and your code will try to add the invalid element to Stack .. 
     /**Solution top=0; */
    }

public void push(int i) 
{
    if (top == stack.length)
    {
        extendStack();
    }

       stack[top]= i;
        top++;

}

public int pop() 
{
    top --; // here you are reducing the top before giving the Object back 
   /*Solution 
      if(!isEmpty()){
      int value = stack[top];
       top --;
     return value; 
    } else{
      return -1;// OR invalid value
    }
   */
    return stack[top];
}

public int peek()
{
    return stack[top]; // Problem when stack is empty or size is 0
    /*Solution 
       if(!isEmpty()){
         return stack[top];
       }else{
         return -1;// Or any invalid value
       }
    */


}


public boolean isEmpty() 
{
    if ( top == -1); // problem... we changed top to 0 above so here it need to check if its 0 and there should be no semicolon after the if statement
   /* Solution if(top==0) */
    {
        return true;
    }
}

private void extendStack()
{

    int [] copy = Arrays.copyOf(stack, stack.length); // The second parameter in Arrays.copyOf has no changes, so there will be no change in array length.
  /*Solution  
    stack=Arrays.copyOf(stack, stack.length+1); 
   */
     }

     }
+8

top -1 , top push() , . , ++top:

public void push(int i) 
{
    if (top == stack.length)
    {
        extendStack();
    }

    stack[++top]= i;
}

ArrayIndexOutOfBoundsException, . , , " ".:)

+1

Stack execution in Java

  class stack
  {  private int top;
     private int[] element;
      stack()
      {element=new int[10];
      top=-1;
      }
      void push(int item)
      {top++;
      if(top==9)
          System.out.println("Overflow");
      else
              {
               top++;
      element[top]=item;

      }

      void pop()
      {if(top==-1)
          System.out.println("Underflow");
      else  
      top--;
      }
      void display()
      {
          System.out.println("\nTop="+top+"\nElement="+element[top]);
      }

      public static void main(String args[])
      {
        stack s1=new stack();
        s1.push(10);
        s1.display();
        s1.push(20);
        s1.display();
        s1.push(30);
        s1.display();
        s1.pop();
        s1.display();
      }

  }

Output

Top=0
Element=10

Top=1
Element=20

Top=2
Element=30

Top=1
Element=20
0
source

Here is an example of a stack implementation in java (array based implementation):

public class MyStack extends Throwable{

/**
 * 
 */
private static final long serialVersionUID = -4433344892390700337L;

protected static int top = -1;
protected static int capacity;
protected static int size;

public int stackDatas[] = null;

public MyStack(){
    stackDatas = new int[10];
    capacity = stackDatas.length;
}

public static int size(){

    if(top < 0){
        size = top + 1;
        return size;
    }
    size = top+1;
    return size; 
}

public void push(int data){
    if(capacity == size()){
        System.out.println("no memory");
    }else{
        stackDatas[++top] = data;
    }
}

public boolean topData(){
    if(top < 0){
        return true;
    }else{
        System.out.println(stackDatas[top]);
        return false;
    }
}

public void pop(){
    if(top < 0){
        System.out.println("stack is empty");
    }else{
        int temp = stackDatas[top];
        stackDatas = ArrayUtils.remove(stackDatas, top--);
        System.out.println("poped data---> "+temp);
    }
}

public String toString(){
    String result = "[";

    if(top<0){
        return "[]";
    }else{


    for(int i = 0; i< size(); i++){
        result = result + stackDatas[i] +",";
    }
    }

    return result.substring(0, result.lastIndexOf(",")) +"]";
 }
}

MyStack call:

    public class CallingMyStack {

public static MyStack ms;

public static void main(String[] args) {

    ms = new MyStack();
    ms.push(1);
    ms.push(2);
    ms.push(3);
    ms.push(4);
    ms.push(5);
    ms.push(6);
    ms.push(7);
    ms.push(8);
    ms.push(9);
    ms.push(10);
    System.out.println("size: "+MyStack.size());
    System.out.println("List---> "+ms);
    System.out.println("----------");
    ms.pop();
    ms.pop();
    ms.pop();
    ms.pop();
    System.out.println("List---> "+ms);
    System.out.println("size: "+MyStack.size());

 }
}

output:

size: 10
List---> [1,2,3,4,5,6,7,8,9,10]
----------
poped data---> 10
poped data---> 9
poped data---> 8
poped data---> 7
List---> [1,2,3,4,5,6]
size: 6
0
source 
 public class Stack {
     int[] arr;
     int MAX_SIZE;
     int top;

public Stack(int n){
    MAX_SIZE = n;
    arr = new int[MAX_SIZE];
    top=0;
}

    public boolean isEmpty(){
        if(top ==0)
            return true;
      else
        return false;
   }

public boolean push(int ele){

    if(top<MAX_SIZE){
        arr[top] = ele;
        top++;
        return true;
    }
    else{
        System.out.println("Stack is full");
        return false;
    }
}
public void show(){
    for(int element:arr){
        System.out.print(element+" ");
    }
}
public int size(){
    return top;
}
   public int peek(){
        if(!isEmpty()){
            int peekTest = arr[top-1];
            return peekTest;
                    }
   else{
       System.out.println("Stack is empty");
       return 0;
   } 
}
public int pop(){
    if(isEmpty()){
        System.out.println("Stack is Emmpty");
        return 0;
    }
    else{
        int element = arr[--top];
        return element;
    }
}

}

0
source

More articles:


All Articles