Clase Stack para manejar Pilas en PHP

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 ArrayObject $stack El objeto que contiene la Pila
	 */
	private ArrayObject $stack;
	
	/**
	 * @var int $key El índice para organizar los elementos de la pila
	 */
	private int $key = 0;
  
	/**
	 * Constructor. Crea la pila
	 */
	public function __construct() {
		$this->stack = new ArrayObject();
	}
	
	/**
	 * Inserta un elemento en el tope de la pila.
	 *
	 * @param mixed $value Elemento a insertar
	 */
	public function push(mixed $value) : void {
		$this->stack->offsetSet($this->key, $value);
		$this->key = $this->key + 1;
	}
	
	/**
	 * 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() : mixed {
		$value = $this->peek();
		if($value !== null) {
			$this->stack->offsetUnset($this->key - 1);
			$this->key = $this->key - 1;
		}
		return $value;
	}
	
	/**
	 * Checa si la pila está vacía
	 *
	 * @return boolean True si está vacía, false caso contrario
	 */
	public function isEmpty() : bool {
		return $this->stack->count() == 0;
	}
	
	/**
	 * Cuenta el tamaño de la pila
	 *
	 * @return int El tamaño de la pila
	 */
	public function count() : int {
		return $this->stack->count();
	}
	
	/**
	 * Regresa el ultimo elemento de la pila, sin removerlo
	 * 
	 * @return mixed El último elemento de la pila
	 */
	public function peek() : mixed {
		if($this->stack->offsetExists($this->key - 1)) {
			$value = $this->stack->offsetGet($this->key - 1);
		}
		return $value ?? null;
	}
}
Lenguaje del código: PHP (php)

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: (Muestra un 5):
echo $stack->count();

// 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();
}Lenguaje del código: PHP (php)

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.

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

// Esta linea mostrara un: bool(true)
var_dump(isPalindrome('anitalavalatina');
Lenguaje del código: HTML, XML (xml)

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.