Stack(pilas) -java-

Buenas, en esta ocasión vengo a compartir una implementación propia de la clase Stack, con el fin de entender su funcionamiento.

Un stack o pila es una colección de elementos donde el primer objeto ingresado es el primero que sale. Imaginémonos un grupo de libros apilados uno encima de otro en una caja,

cuando introduzcamos un libro a la pila este quedara encima de los demás, es decir, sera el primero que podremos sacar. Sucede lo mismo con la clase Stack, en la que contamos con 5 métodos:
empty nos permite saber si la pila esta vacia
peek devuelve el valor del primer elemento (lo hojea).
pop saca el primer elemento y retorna su valor
push agrega un elemento a la pila
search busca el elemento recibido y retorna un entero con su posición (si no esta retorna -1)


La forma en que almacene los elementos fue por medio de nodos simplemente encadenados (explicado de forma general en otro post)



:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=

clase Nodo
public class Node<E>{
        E element;
        Node next;
        public Node(E elem, Node link){
            element = elem;
            next = link;
        }
    }
no hay encapsulamiento puesto que la clase Node es una subclase de Stack



:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=

Atributos

-> Node first referencia al primer nodo
-> int size longitud de la pila


:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=

Metodos

-> empty
se puede implementar de dos maneras; la primera, mirar si el valor del atributo size es 0:

public boolean empty(){
     return size == 0 ;
}

la segunda, mirar si el elemento del primer nodo es nulo:

public boolean empty(){
     return first.element ==  null;
}

las dos son bastante sencillas


-> peek
retornara el valor del primer elemento, sin sacarlo de la pila:

public E peek(){
     return first.element;
}



-> pop
remueve el primer elemento de la pila, retornando su valor:

public E pop(){
        E temp = first.element;  //guardamos el valor que vamos a retornar
        first = first.next;             // "eliminamos" el nodo, diciéndole que el siguiente elemento sera el primer nodo
        size--;                           //reducimos en uno el valor de la longitud
        return temp;                  //retornamos el valor que habíamos guardado 
}



-> push
agrega un elemento en la primera posición de la pila:

public void push(E newElem){
      Node newNode = new Node(newElem, first) //creamos un nodo con el dato recibido y una referencia del   que era el ultimo nodo
      first = newNode      // ahora el primer nodo sera el que creamos
      size++;                   // aumentamos en uno la longitud
}



-> search
nos devuelve la posición del elemento que buscamos, si no se encuentra retorna -1

public int search(E toSearch){
       Node current = first;         // nodo temporal que sera "recorrido"
       for(int i=1; i < size ; i++){
           if(current.element == toSearch) // evaluamos si es el nodo que buscamos
              return i;                                   // retornamos su posición
           current = current.next;               // continuamos con el siguiente
      }    
      return -1;                                        // si no lo encontró retorna -1
}



:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=

Espero que les halla gustado, esta implementación también se puede hacer con vectores, pero a mi me gusta mas así , comenten cualquier duda