Las pilas son estructuras de datos muy prácticas y que nos sirven para infinidad de aplicaciones. Dentro del desarrollo web no me ha tocado verles tanta utilidad como en aplicaciones de escritorio sin embargo las hay y en este microtutorial veremos como implementarlas en PHP.

Lo primero que hay que saber es que una pila -tanto en PHP como en Java y cualquier lenguaje- no es más que un arreglo de elementos que funciona mediante la filosofía LIFO. Ahora crearemos una clase para manejar una pila o stack.

<?php

class Stack {

	/**
	 * @var Stack El objeto que contiene la Pila
	 */
	private $stack;
  
	/**
	 * Constructor. Crea la pila
	 */
	public function __construct(){
		$this->stack = array();
	}
	
	/**
	 * Inserta un elemento en el tope de la pila.
	 * El formato $array[]=$v es más eficiente para un elemento que la función nativa array_push()
	 *
	 * @param mixed $v Elemento a insertar
	 */
	public function push($v){
		$this->stack[] = $v;
	}
	
	/**
	 * Remueve el elemento al tope de la pila y lo regresa
	 *
	 * @return mixed El elemento del tope.
	 * Si la pila está vacía devolverá NULL
	 */
	public function pop(){
		return array_pop($this->stack);
	}
	
	/**
	 * Checa si la pila está vacía
	 *
	 * @return boolean True si está vacía, false caso contrario
	 */
	public function isEmpty(){
		return empty($this->stack);
	}
	
	/**
	 * Cuenta el tamaño de la pila
	 *
	 * @return int El tamaño de la pila
	 */
	public function length(){
		return count($this->stack);
	}
	
	/**
	 * Observa el ultimo elemento de la pila, sin removerlo
	 * 
	 * @return mixed El último elemento de la pila
	 */
	public function peek(){
		return $this->stack[($this->length() - 1)];
	}
}
?>

Esta clase es una implementación muy similar a la Stack de Java, y por lo tanto su uso es prácticamente igual.

Primero debemos crear una instancia de la clase u objeto y posteriormente trabajaremos con él insertando y sacando elementos.

<?php
// Creamos la pila
$stack = new Stack();

// Insertamos 5 elementos...
$stack->push('Hola');
$stack->push('Mundo');
$stack->push('Amigos');
$stack->push('de');
$stack->push('Microplagio');

// Mostramos el tamaño de la pila (5):
echo $stack->length();

// Sacamos los últimos 4 elementos
$stack->pop();
$stack->pop();
$stack->pop();
$stack->pop();

// Si la pila no esta vacía mostramos el elemento del tope
if(!$stack->isEmpty()){
	// En este caso el elemento que se mostrará es "Hola"
	echo $stack->peek();
}
?>

Un ejemplo típico de uso de una pila es verificar si una palabra dada es palíndromo. Palíndromo es aquella palabra que leída de derecha a izquierda es igual que de izquierda a derecha.

Para hacer esto necesitamos tomar la palabra que queremos verificar. Luego hay que meter cada caracter a un arreglo y posteriormente sacar cada caracter en orden inverso a como se metieron y concatenarlo a otra cadena. Una vez vaciado el arreglo comparamos la palabra original y la cadena que creamos al vaciar el arreglo, si son iguales, la palabra es un palíndromo.

Esta sería la función PHP que comprueba si una palabra es palíndromo o no.

function isPalindrome($word) {
	$cadena = '';
	$pila = new Stack();
	$wordSize = strlen($word);
	for ($i = 0; $i < $wordSize; $i++) { $pila->push(substr($word, $i, 1) );
	}
	while ($pila->length() > 0 ) {
		$cadena .= $pila->pop();
	}
	return ($word == $cadena);
}

// Esta linea mostrara un: bool(true)
var_dump(isPalindrome('radar');

Tambien podrían usarse por separado las funciones nativas array_push() y array_pop() para insertar y sacar respectivamente elementos de un array. Sin embargo, el uso de clases y objetos hace el código más bonito jajaja.

Así que no sean vagos y usen clases.