Programar en C: Más fácil que tomarse dos orujos

1.- Pilas y colas. Descripción y esquematización

Tanto las pilas como las colas son métodos para almacenar elementos y
pasárselos ordenadamente a algo o alguien. Cada una tiene características propias
definitorias y según estas decidiremos cual puede servir mejor a nuestros fines.

Las pilas
Una pila es un “montón” de elementos. Imagina una pila de documentos o una
pila de libros. Son varios puestos unos encima de los otros. Cuando llega uno nuevo se
pone por encima de los demás, y cuando se retira uno, se va el que está en la parte
superior (sistema LIFO; Last In, First Out).

Las colas
Una cola es una “hilera” de unidades. Piensa en la cola del cine o la del autobús.
Cuando llega alguien nuevo se pone al final y cuando alguien sale de la cola para entrar
al cine o al bus, se va el que está al principio (sistema FIFO; First In, First Out).

Pilas y colas, similitudes y diferencias

Ambas son grupos ordenados de cosas, que sitúan a las nuevas de una forma
predeterminada y luego les dan salida de forma preestablecida. En las dos se sitúan los
nuevos “objetos” al final. La diferencia entre ambas está en la manera en que se dan
salida a los elementos que están dentro:
En las colas, el primer elemento en salir es el primero que llegó, el más antiguo.
En las pilas sale primero el último que llegó.

Operaciones con pilas y colas

Teniendo claro lo que es cada una y como funcionan vamos a observar como
suceden en ellas distintas rutinas:
1- llegada de un nuevo elemento: el elemento busca el primer hueco (que estará
al final) .y se coloca en él
2- salida de un elemento en una cola: el elemento más antiguo (situado al
principio de la cola) sale y deja un hueco. El que era el segundo ocupa su lugar,
el tercero pasa a ser segundo, el cuarto a ser tercero…
2- salida de un elemento en una pila: el último elemento que llegó (situado al
final) se va.
3- contar los elementos: desde el principio de la pila/cola vamos avanzando y
contando las cosas almacenadas hasta que lleguemos al primer hueco vacío.
4- consultar el primer elemento: nos ponemos al principio de la cola/pila y
observamos que/quien está al principio.
5- consultar el último elemento: nos ponemos al principio de la cola/pila y
vamos avanzando por ella hasta encontrar el primer hueco vacío. Miramos qué
hay antes del hueco.
6- listar todos los elementos: nos ponemos al principio del grupo y escribimos
quien está ahí. Vamos avanzando y escribiendo quien está en cada posición, así
hasta que lleguemos al final (hueco vacío).
Programar en C: Más fácil que tomarse dos orujos

Estas son las ideas que luego deberemos desarrollar, así que es imprescindible
conocer y comprender qué es una pila, qué es una cola, en que se diferencian y como se
producen en ellas las distintas operaciones. NO CONTINÚES SI NO TIENES ESTO
CLARO.

2.- Estructuración y esquematización de cada una

de las operaciones
Una vez que sabemos qué son las pilas y colas y como se desarrollan las
operaciones en ellas, debemos dividir cada operación en pequeñas tareas/pasos lo más
simples posible, creando un esquema o esqueleto. De esta forma llegaremos a una
solución estructurada de lo que queremos realizar. Por muy complejo que sea el
problema, tendremos una serie de pequeños trabajos simples y claros que nos permitirán
llegar a la solución final.

Operaciones comunes 1: llegada de un nuevo elemento

1- buscamos un sitio libre, si no hay mostramos un mensaje de error
* al principio podemos tener un contador inicializado a cero
* con cada elemento q se añade, sumamos uno al contador
* por cada elemento q se retira, restamos uno al contador
* este contador nos servirá para localizar el sitio libre (su dirección será
vector+contador o &vector[contador])
2- pedimos el elemento que se añadirá a la lista
3- lo almacenamos en el sitio libre
4- mostramos mensaje de conformidad

Operaciones comunes 2: contar cuantos elementos hay

en la lista
* si hemos utilizado un contador para indicar el sitio libre en la entrada, este
indicador tiene el número exacto de los elementos que hay actualmente en la
pila/cola

Operaciones comunes 3: consultar el primer elemento de

la lista
* si miramos el contenido de vector[0] lo veremos

Operaciones comunes 4: consultar el último elemento de

la lista
1- sabemos que en vector[contador] está el primer hueco libre
2- entonces en vector[contador-1] tendremos el último elemento de la lista

Operaciones comunes 5: enumerar todos los elementos

de la lista
* voy a recorrer el vector imprimiendo cada uno de los elementos
1- inicializo otro contador a 0
Programar en C: Más fácil que tomarse dos orujos

2- muestro el contenido de vector[contador2]

3- sumo 1 a contador2
4- repito 2 y 3 mientras contador2 sea inferior a contador

Salida de un elemento en una pila

* sabemos que tiene q irse el último q entró
1- buscamos el último
* utilizamos el método descrito en el punto 4
2- lo retiramos
* no es precisa una “eliminación total”, llega con una “retirada virtual”
a) sabemos q en las posiciones de memoria puede haber “basura”
(información aleatoria no deseada)
b) restamos uno a nuestro contador de elementos
c) para cualquier operación que realicemos ahora, el elemento que antes
estaba en tal posición no se tiene en cuenta (sigue estando ahí
“físicamente”, pero como nuestra lista tiene un elemento menos, eso pasa
a ser una basura que ahora está fuera de nuestra lista)
*3- pondremos un aviso si la lista está vacía para avisar al usuario

Salida de un elemento en una cola

* tiene que irse el primero que entró (está situado al principio del vector)
1- eliminamos el primero
2- movemos cada elemento a la posición inmediatamente anterior
* usamos un bucle que se detiene cuando hemos movido el último
elemento
3- restamos 1 al contador de elementos

3.- Programación de las operaciones a realizar en

una pila
* una vez que estén claras las ideas y bien definidos el problema y las soluciones,
escribir el código no debería de ser problema.