/** Questa classe permette di rappresentare un insieme di elementi, gestendo inserimenti
ed eliminazioni secondo una politica LIFO (Last In - First Out).
Gli elementi sono ospitati in un array, la cui dimensione raddoppia ogni volta che si
richiede di inserire un nuovo elemento e l'array è saturo.
Per evitare sprechi di memoria, l'array viene ristretto quando, a seguito di eliminazioni, l'array si
svuota eccessivamente.
*/

public class PilaMigliorata

{
	private int[] elementi;
	private int numElementi;
	
/**
 Costruisce una pila di capacità iniziale fissata.
 La capacità della pila sarà incrementata automaticamente
 quando sarà inserito un elemento che richiede l'estensione della capacità.
 */

	public PilaMigliorata()
	{
		elementi = new int[10];
		numElementi = 0;
	}
	
/**
 Costruisce una Pila di capacità iniziale fissata.
 La capacità della pila sarà incrementata automaticamente
 quando sarà inserito un elemento che richiede l'estensione della capacità.

 @param  capacita  il valore della capacità iniziale
 */
	
	public PilaMigliorata(int capacita)
	{
		elementi = new int[capacita];
		numElementi = 0;
	}
	
/**
 Restiruisce true se la pila è vuota, false altrimenti.
 La pila &egrave vuota se non contiene alcun elemento. In questo caso non può
 essere eseguita l'operazione top()
 
  @return      true se la pila è vuota, false se la pila non è vuota.
*/
	public boolean vuota()
	{
		if (numElementi == 0)
			return true;
		else
			return false;
	}
	
	
/*
 * Finche il sistema permette di allocare arrays, la pila non dovrebbe essere mai piena
 *
 	public boolean piena()
	{
		if (numElementi == maxElementi)
			return true;
		else
			return false;
	}
	
*/	


/**
 Inserisce un elemento nella pila.
 Se non vengono eseguite prima altre chiamate a push(), questo elemento sarà restituito dalla
 prossima operazione top.
 
 @param  e  Il valore int da inserire nella pila
 */

	public void push(int e)
	{
		if(numElementi == elementi.length)
		{
			int[] nuovoArray = new int[2*elementi.length];
			for(int i=0; i<numElementi; i++)
				nuovoArray[i]=elementi[i];
			elementi=nuovoArray;
		}
		elementi[numElementi] = e;
		numElementi++;
	}
	
/**
 Restituisce l'elemento inserito pi&ugrave; recentemente tra quelli presenti nella pila.
 Questa operazione non deve mai essere richiesta su una pila vuota. Per verificare se una pila &egrave; vuota
 si pu&ograve; utilizzare il metodo {@link #vuota()}.
 */
	
	public int top()
	{
		return elementi[numElementi - 1];
	}
	
/**
 Elimina l'elemento inserito pi&ugrave; recentemente tra quelli presenti nella pila.
 Questa operazione non deve mai essere richiesta su una pila vuota. Per verificare se una pila &egrave vuota
 si pu&ograve; utilizzare il metodo {@link #vuota()}.
 */
	
	public void pop()
	{
		if(!vuota())
			numElementi--;
		if(numElementi < elementi.length/3)
		{
			int[] nuovoArray = new int[elementi.length/2];
			for(int i=0; i<numElementi; i++)
				nuovoArray[i]=elementi[i];
			elementi=nuovoArray;
		}
	}
	
}