Hay una función que también es usada en pilas y colas que es la de consultar el elemento sin extraerlo, es decir consultar el elemento que está en la cima de la pila o consultar el elemento en la cabeza de la cola.
Para la pila hay se usa el mismo código que para el POP quitando la linea que mueve el puntero a la cima, pero cuando una función esté incluida en otra hay que reutilizar siempre el código y no duplicarlo, ya que esto además de simplificar el código evita errores, si mañana se cambia la forma de extraer el elemento de la cima, solo hay una función que modificar, por lo que además de añadir la función PILA_VER cambio también la función PILA_POP (como siempre las lineas que comienzan por :: son prescindibles, están para rellenar con ceros y que visualmente sea mas fácil localizar la cima en el arreglo):
1540 REMark -------------------------------------------------------------- 1550 REMark -- v = PILA_VER -- Devuelve dato sin extraerlo -- 1560 REMark -- RETORNA: Valor de la cima de la pila -- 1570 REMark -------------------------------------------------------------- 1580 DEFine FuNction PILA_VER 1590 IF PILA_VACIA THEN 1600 PRINT"Error: Pila vacia" 1610 STOP 1620 END IF 1630 RETurn ArrPila(ArrPila(PILA_TOP)) 1640 END DEFine 1650 : 1660 REMark -------------------------------------------------------------- 1670 REMark -- v = PILA_POP -- Saca un dato de la pila -- 1680 REMark -- RETORNA: Valor de la cima de la pila -- 1690 REMark -------------------------------------------------------------- 1700 DEFine FuNction PILA_POP 1710 LOCal valor 1720 : 1730 valor=PILA_VER 1740 :: ArrPila(ArrPila(PILA_TOP))=0 1750 ArrPila(PILA_TOP)=ArrPila(PILA_TOP)-1 1760 RETurn valor 1770 END DEFine
Para la cola lo mismo exactamente, se crea la nueva función COLA_VER y se modifica COLA_EXTRACT para que la use. Para la cola simple:
1710 REMark -------------------------------------------------------------- 1720 REMark -- v = COLA_VER -- Muestra el dato de la cabeza de la cola -- 1730 REMark -- RETORNA: Valor de la cabeza de la cola -- 1740 REMark -------------------------------------------------------------- 1750 DEFine FuNction COLA_VER 1760 IF COLA_VACIA THEN 1770 PRINT"Error: Cola vacia" 1780 STOP 1790 END IF 1800 : 1810 RETurn ArrCola(ArrCola(COLA_CABEZA)) 1820 END DEFine 1830 : 1840 REMark -------------------------------------------------------------- 1850 REMark -- v = COLA_EXTRACT -- Saca un dato de la cola -- 1860 REMark -- RETORNA: Valor de la cabeza de la cola -- 1870 REMark -------------------------------------------------------------- 1880 DEFine FuNction COLA_EXTRACT 1890 LOCal valor 1900 : 1910 valor = COLA_VER 1920 :: ArrCola(ArrCola(COLA_CABEZA))=0 1930 ArrCola(COLA_CABEZA)=ArrCola(COLA_CABEZA)+1 1940 IF COLA_VACIA THEN COLA_INIT 1950 RETurn valor 1960 END DEFine
Y para la cola circular la función COLA_VER es exactamente la misma anterior, solo cambia la función COLA_EXTRACT de la misma manera que en la anterior:
1990 REMark -------------------------------------------------------------- 2000 REMark -- v = COLA_EXTRACT -- Saca un dato de la cola -- 2010 REMark -- RETORNA: Valor de la cabeza de la cola -- 2020 REMark -------------------------------------------------------------- 2030 DEFine FuNction COLA_EXTRACT 2040 LOCal valor 2050 : 2060 valor=COLA_VER 2070 :: ArrCola(ArrCola(COLA_CABEZA))=0 2080 ArrCola(COLA_CABEZA)=ArrCola(COLA_CABEZA)+1 2090 IF ArrCola(COLA_CABEZA) > DIMN(ArrCola) THEN 2100 ArrCola(COLA_CABEZA)=2 2110 END IF 2120 : 2130 REMark Ver si cola vacia 2140 IF ArrCola(COLA_CABEZA) = ArrCola(COLA_COLA)+1 THEN COLA_INIT 2150 RETurn valor 2160 END DEFine
Existen mas variantes de las colas, la cola circular une cabeza y cola de forma que se puede ir recorriendo de manera continua. Las dobles colas unen pila y cola en una misma estructura, en ellas los elementos se pueden introducir o extraer por cualquiera de los dos lados. Las colas por prioridades son una variante en que los elemento se extraen comenzando por los mas prioritarios.
En general para montar una pila se usa un espacio en memoria contiguo, similar a un arreglo, pero las colas en cambio se suelen montar usando estructuras de nodos enlazados en lugar de arreglos, ya que son mas flexibles, cuesta un poco mas de montar, pero son muy sencillas de recorrer. Esto lo haré en otra entrada de manera sencilla usando también un arreglo, lo que será la base de la siguiente estructura de datos importante, los árboles. Posteriormente quiero usar las estructuras de datos directamente en memoria, pero eso en un lenguaje que no soporta punteros ni estructuras como el BASIC o el SuperBASIC es otro cantar, hay que pasar a manejar directamente la memoria del ordenador con PEEK y POKE, desarrollar un controlador de memoria que nos controle los huecos y la ocupación, y alguna cosita mas. Es un reto muy interesante para un programador, recomiendo intentarlo por vuestra cuenta pues es muy instructivo.
Aquí todo lo desarrollado hasta el momento.
No hay comentarios:
Publicar un comentario