Carátula para entrega de prácticas

Facultad de Ingeniería Laboratorio de docencia

Laboratorios de computación
salas A y B
M.I Edgar Tista García
Profesor:

Estructura de Datos y Algoritmos 1

Asignatura:

01
Grupo:

06
No de Práctica(s):

González González Pedro José

Integrante(s):
No. de Equipo de
Trabajo en casa
cómputo empleado:

24
No. de Lista o Brigada:

2022-2
Semestre:

20 de marzo de 2022
Fecha de entrega:

Observaciones:

CALIFICACIÓN: __________
Objetivos
Objetivo general:

Revisarás las definiciones, características, procedimientos y ejemplos de las

estructuras lineales cola circular y cola doble, con la finalidad de que comprendas
sus estructuras y puedas implementarlas.

Objetivo de la clase:

Realizar ejercicios sencillos para la comprensión de las operaciones de cola circular

doble
Desarrollo
Desarrollo de la practica:

Actividad 1.

a) Dentro de la biblioteca, se puede encontrar primero a la declaración de

nuestra cola, en este caso vemos que como miembros tiene a más índices
que los convencionales, uno se encarga de tener control de los elementos
del inicio -primero- el otro se hace cargo del último elemento (último), el
miembro tamaño se hará cargo de darle el tamaño a la lista de la cola,
mientras que el miembro disponibles llevara la cuenta de los elementos
restantes que tiene la cola, por ultimo tenemos a nuestra lista, la cual está
declarada como un apuntador que después se hará un apuntador dinámico,
para darle una mayor flexibilidad a la lista.
Después de la estructura de nuestra cola, pasamos a la función crearCola, la
cual devuelve a la cola que se cree en ella y recibe como parámetro valor del
tamaño que se desea para la cola. Lo que se lleva a cabo internamente en
esta función es declarar a una variable de tipo c y después inicializar al índice
primero en 1 y al último en 0, ya que, para el momento de su creación, la cola
no contiene nada. Al miembro tamaño se le da el valor del parámetro que
recibió la función y así mismo, al índice de disponibles se le da el valor de
tamaño, ya que este tendrá el control de los valores disponibles
restándoselos al total. Y, por último, se le asigna el espacio de memoria
reservada a la lista con calloc. Terminado este proceso, se retorna a la cola
creada.

La función isEmpty recibe como parámetro a la cola que analizará y devuelve

un valor entero que nos servirá para determinar si está vacía o no. Dentro de
la operación, las instrucciones que siguen son un tanto fáciles, ya que con
una condicional if se determina si está vacía o no, lo cual tiene que cumplirse
que los elementos disponibles sean iguales al tamaño de la cola, lo cual tiene
sentido ya que si no se ha ocupado ninguno se tendrán todos los espacios
libres, y, además, se necesita cumplir que el índice primero, sea igual al índice
ultimo más uno.

Para la función encolarFinal, lo que recibe como parámetro es a la cola en

forma de apuntador, ya que se necesita trabajar en paso por referencia, pues
se debe modificar a la cola y que estas modificaciones permanezcan, en el
segundo parámetro, lo que se recibe es al elemento que se encola. Dentro
de la función, lo que hace es revisar si la cola no ha llegado a su máxima
capacidad, lo cual se lleva a cabo mediante una condición if, que, dentro de
sus instrucciones, verificara si el índice de los elementos disponibles se
encuentra vació, que su valor sea cero, y si es verdad, nos mostrara en
pantalla un mensaje indicándolo. En cambio, si la condición no es verdadera,
se siguen las instrucciones que están dentro del else; en la línea 31 vemos
la siguiente instrucción:

c->ultimo=(c->ultimo->tamano) +1;

Lo que básicamente hace esta instrucción, es tener control del índice último,
ya que su funcionamiento es el siguiente: con el operador modulo (%) se
obtiene el residuo de la división entre el índice ultimo y el tamaño, por
ejemplo, si se tiene al índice ultimo igual a 0, entre 8, que es el tamaño de
una cola, nos daría como residuo 0 y más el 1 constante, el resultado de la
operación seria 1 y este valor se le asignaría al índice ultimo. Tomemos otro
ejemplo, si el índice último es igual a 1, se divide entre 8, que es el tamaño
de la cola, el residuo dará 1 y más el 1 constante, el resultado es igual a 2.
En pocas palabras, esta instrucción está haciendo que el índice ultimo vaya
aumentando de 1 en 1.

Siguiendo con las instrucciones, en la línea 32, se le asigna a la lista el valor

que se pasó como parámetro, utilizando con índice al resultado de ultimo
menos un 1 constante. Y, por último, en la línea 33, se hace uso del operador
--, asociado con los elementos que se encuentran disponibles, pues de lo que
se encarga esto, es de ir reduciendo a los elementos disponibles de uno en
uno.

Para la función encolarInicio, lo que se recibe como parámetro es al elemento

que será encolado. Ya dentro de esta función, en la línea 38, vemos que hace
uso de una condición if, la cual nos dice que si el índice último se encuentra
en la posición 0, o sea, si la cola está vacía, se guardaran los elementos,
pero llamando a la función encolarFinal. Esto se hace debido a que el primer
elemento, al estar vacía la cola, siempre entrara en la posición 1 cuando se
guarde.

Continuando, dentro del else de la línea 45, se vuelve a aplicar una condición,
pero esta vez, es para comprobar si la cola llego a su máxima capacidad, si
es que esto es falso, entra a otro else anidado y dentro de este, se vuelve a
encontrar otra condicional, la cual sirve para ver si el primer elemento se
encuentra en la posición 1, si esto es verdad, lo que se estará haciendo es ir
colocando a los valores de sentido contrario, de la posición que encuentra
detrás de 1, por ejemplo, si la cola es de 8 elementos, por su naturaleza
circular de la cola, la posición anterior de 1 será 8, y se ira recorrido de forma
descendiente (8,7,6…). Si es que la condición no es verdadera, se pasara al
último else, el cual hace uso del operador modulo para manejar al índice de
la lista.

Para la función desencolarInicio, se devolverá un valor entero, el cual será el

valor que se elimine, además de esto, recibe como parámetro a nuestra cola
en forma de apuntador. Ya dentro de esta función, lo primero que se hace es
uso comprobar si la cola está vacía, ya que no tiene sentido eliminar un
 elemento donde no hay nada, si es que esto no es verdadero, lo primero que
se hace es incrementar de uno en uno a nuestra variable que controla los
elementos disponibles, después se declara a la variable aux y se recupera al
valor que se desea eliminar de la posición del inicio. Una vez hecho esto, se
elimina el elemento colocando en su lugar un 0.

Después de estas instrucciones siguen las que se encargan del movimiento

del índice, ya que, si se cumple que el primer índice, es diferente que, del
último, se usa al operador modulo y al residuo se le suma un 1, para
asignárselo al índice. Si esto no se cumple, entonces solo se incrementa de
uno en uno al índice, por último, se devuelve el valor.

En la siguiente función: desencolarFinal, la función va a devolver a un valor

entero, el cual corresponde al elemento rescatado que se elimine, como
parámetro se recibe a la cola en forma de apuntador, pues se necesita
modificar a la cola. De igual forma que la función anterior, lo primero que se
hace es ver si la cola está vacía, si esto no se cumple, se siguen las
siguientes instrucciones:

Al eliminar un valor, se necesita aumentar los valores disponibles, por

lo tanto, se hace uso de la instrucción de la línea 81. Después de esto, se
declara a la función aux, que se retornara, y en ella se rescata el valor que
se elimina de la posición final, posteriormente, para borrarlo a la posición en
la que se encontraba, se le asigna un cero y al índice último, se reduce de
uno en uno. Para las siguientes instrucciones, lo que se quiere hacer es ver
si la pila termina vacía al realizar las operaciones anteriores, si resulta
verdadero, se crea una nueva pila.

Para la penúltima operación, mostrarValores, se recibe como parámetro a

nuestra cola, pues solo imprimirá elementos. Ya dentro de esta función, se
aplica un ciclo for el cual se encargará de ir recorriendo a la cola para mostrar
los elementos en las posiciones que se encuentran.

Ya, por último, tenemos a nuestra función mostrarIndices, la cual recibe a

nuestra cola como parámetro y solo se encargará de usar printf para
pongamos como parámetro a los valores del índice primero, ultimo y a los
valores disponibles que tiene nuestra estructura cola.

b) Como explicamos en algún punto anteriormente, el módulo que en algunas

de las operaciones se usa:
if(c->primero! =c->ultimo)

a. c->primero=(c->primero % c->tamano) +1;

Funciona para tener control del índice de la cola, que no se exceda del tamaño que
tiene la cola. El proceso que sigue es, por ejemplo:

Si el índice primero es igual a 0 y el tamaño de la cola es 8, a la hora de hacer la

división, el residuo es igual a 0, que más el uno constante seria 1. Ahora, si el índice
primero es igual a 2 y el tamaño de la cola es 8, a la hora de hacer la división, el
residuo es igual a 2, más la contante 1, sería igual a 3.

Básicamente lo que la instrucción hace es obtener al residuo, gracias al operador

modulo (%), de la división entre el índice que corresponde y el tamaño de la cola, lo
cual limita a tener un rango de número que no supere al tamaño de la cola.
Actividad 2.

Para crear el programa que pueda responder las preguntas, se hizo lo siguiente:

Como buena práctica, creamos dos funciones, las cuales tendrán las instrucciones
para cada inciso. Para esto, agregamos la declaración de la función colaincisoA y
colaincisoB a nuestra biblioteca “colaDoble.h”, las cuales no recibirán ningún
parámetro y no devolverán ningún valor, ya que lo único que se quiere hacer es
realizar las operaciones e imprimir las estructuras.

Hay que tomar en cuenta que solo vamos a usar a las operaciones encolarFinal y
desencolarInicio, ya que, tenemos como limitante usar solo las operaciones
correspondientes a una cola convencional y si recordamos, en una cola normal el
primer en llegar es el primero en llegar.

Lo que queda hacer, como siguiente paso, es escribir las instrucciones

correspondientes a las funciones, dentro del archivo colaDoble.c. Así pues, de la
línea 113 a la 136, definimos a la función colaIncisoA:

Comenzamos con declarar una variable auxiliar para guardar los elementos
que se desencolen. En la línea 117 creamos a nuestra cola queue con la función
crearCola, la cual recibe como parámetro un 9, esto debido a que se nos pide una
cola circular de tamaño 9 para el inciso a.

Posteriormente, de la línea 119 a la 125, se hizo uso de la operación

encolarFinal, la cual sería equivalente a la operación encolar de una cola
convencional. Su uso fue fácil, lo que único que se hacía era llamar a la función,
pasarle como parámetros a la cola queue, en forma de apuntador, y al valor
correspondiente (15,25,35,45, etc.) por cada operación que se hacía. En las líneas
126,127 y 128, aplicamos a nuestra operación encolarInicio, que sería equivalente
a la operación encolar de una cola convencional. Para este caso, bastaba con llamar
a la función y pasarle como parámetro a queue, en forma de apuntador, y claro
asignarle el valor de retorno a nuestra variable aux Después de esto, se agregó otra
instrucción de encolar y desencolar, que sigue la misma lógica manejada.

Ya, por último, vamos a mostrar el contenido y los índices de la cola para este inciso,
para hacer esto, basta con mandar a llamar a la función mostrarValores y
mostrarIndices, tal y como se hizo en las 133 y 135.

Para las instrucciones de la función incisoB, se sigo la misma lógica que en la

función incisoA, salvo que, en esta función, como nos piden hacer las operaciones,
pero en una cola de tamaño 5, solamente mandamos a llamar a nuestra función
crearCola y le pasamos a un 5 cinco como parámetro, ya que este indica su tamaño.
Y para finalizar con este programa, dentro de nuestra función main, lo único que
hicimos fue mandar a llamar las funciones que anteriormente se definieron, para
que así se lleven a cabo las operaciones para cada inciso.

a) Cola circular de 9 elementos.

¿Cuál es el contenido de la estructura?

Según la ejecución del programa, el contenido es el siguiente:

¿Cuántos elementos vacíos o disponibles hay en la estructura?

¿Cuál es el valor del índice “primero”?

¿Cuál es el valor del índice “último”?

Las respuestas de las tres preguntas anteriores se obtuvieron con la ejecución del
programa:

b) Cola circular de 5 elementos.

¿Cuál es el contenido de la estructura?

Según la ejecución del programa, el contenido es el siguiente:

¿Cuántos elementos vacíos o disponibles hay en la estructura?

¿Cuál es el valor del índice “primero”?

¿Cuál es el valor del índice “último”?

Las respuestas de las tres preguntas anteriores se obtuvieron con la ejecución del
programa:

La salida completa tras ejecutar el programa es la siguiente:

Vemos que en la salida nos aparece dos mensajes que indican que la cola está a su máxima
capacidad, esto es debido a que dos de las operaciones no se pudieron llevar a cabo, en
algún momento de la cola de 5 elementos, ya que al tener menos “espacio” se llegó al límite
en la quinta operación de encolar.

c) La importancia de tener un miembro que controle el tamaño va de la mano con lo

último que se tocó anteriormente, ya que, si no se hubiera tenido a este miembro,
las dos instrucciones que fueron anuladas se realizarían y los elementos se
superpondrían, o sea, ocuparían su lugar y esos datos se perderían, lo cual no está
permitido. Es por esto que es importante contar con un miembro de control de
tamaño, ya que este se encarga de limitar a los elementos que se deseen encolar
si es que la cola llego a su máxima capacidad.
Actividad 3.

Para esta actividad se hizo uso de los archivos dados por el profesor sin ninguna
modificación. También hay que tomar en cuenta que los índices de la cola fueron
tomados de la siguiente manera:

Una vez hecha estas aclaraciones, seguimos con nuestro programa.

Dentro de nuestra función main, declaramos una variable auxiliar para que podamos
usar nuestras operaciones de desencolar. Después, en la línea 7, creamos a nuestra
cola con la función crearCola, a la cual le pasaremos como parámetro al tamaño de
nuestra cola, que será de 8.

Para replicar al esquema 1, lo que vemos es que solo tiene elementos en los lugares
2,3,4 y 5, por lo tanto, encolamos los números del 101 al 105, con nuestra función
encolarFinal, ya que lo que queremos es ver a los elementos de manera consecutiva
y, por último, para que en el lugar 1 no se tenga nada, hacemos uso de la operación
desencolarInicio, pues el primer elemento es el que se necesita eliminar.

Mandamos a que nos muestre como quedo la cola al final de estas operaciones,
haciendo uso de la operación mostrarValores, y la salida en pantalla es la siguiente:
Para replicar al segundo esquema, lo que se hace es desencolar al elemento que
se encuentra al inicio, mediante nuestra función desencolarInicio de la línea 24. Esto
debido a que, para este esquema, el número que ocupa la posición 2 será 99 y no
102, Después, usamos a nuestra función desencolarFinal, debido a que
necesitamos a esa posición para almacenar otro valor.

Una vez eliminados los elementos necesarios, para colocar a los números 97,98 y
99, necesitamos ir almacenándolos en el inicio, por esto es que en línea 26,27 y 28,
se hizo uso de la función encolaInicior, pero íbamos pasando los parámetros de
forma descendiente, ya que al guardar los elementos con esta función se recorre en
sentido antihorario. Para agregar a los demás elementos, simplemente se usó a la
función encolarFinal, debido a que lo que se quiere es que estos elementos se
encuentren en las siguientes posiciones a las del último elemento (104).

Mandamos a mostrar en pantalla a los elementos de la cola, con la famoso

operación mostrarValores, y queda de la siguiente manera:

Y, por último, para replicar al esquema 3, vemos que necesitamos eliminar a los tres
primeros elementos (97,98 y 99) y después agregar a un elemento al final. Así pues,
para llevar acabo esto, usamos tres veces a nuestra operación desencolarInicio,
pues si recordamos, el primer elemento es el que se encuentra en la posición 8 y
de ahí se irán borrando en sentido horario. Posteriormente vamos a encolar al final
al número 122, para esto usamos a nuestra función encolarFinal y después,
mandamos a mostrar los valores, los cuales quedan de la siguiente manera:
Ejercicio 4.

Por falta de tiempo no se pudo realizar el análisis del avance que tuvo con este
programa.
Conclusiones
Ahora que hemos visto y realizo todo lo anterior, puedo considerar que los objetivos
se lograron de manera muy buena. Gracias a las actividades que están propuestas,
pude analizar las definiciones, características, procedimientos y ejemplos que
involucran a estas estructuras lineales, para así poder implementarlas a ejercicios
que ayudaron mucho a la comprensión completa de cada concepto.

Considero que el manejo de índices que permite la cola doble será de gran utilidad
para mi aprendizaje en la programación, debido a que son temas que se me
facilitaron y son muy útiles para resolver problemas.

Es un tema sencillo que, con la práctica, hizo que algunos huecos con los que
contaba se fueran llenando, gracias a esto, es que en la mayoría de los programas
solicitados se llegó al %100 de cumplimiento, excepto en el programa de la actividad
4, que a mi parecer se llegó a cumplir un 80% con éxito lo solicito, ya que tiene
errores de lógica los cuales se me dificultaron observar.

Así pues, con los resultados obtenidos, puedo concluir que los temas abordados por
esta práctica quedaron totalmente cubiertos y, si bien, se llego a fallar con la
actividad 4, los errores no vienen sobre este tema, si no mas bien, vienen de errores
lógicos y de antecedentes que se siguen complicando.

Por lo tanto, la implementación de una cola doble-circular comienza a abrir puertas

para una programación avanzada en mí, pues me doy cuenta de que todas las
operaciones que lleva esta estructura de datos nos sirven para el almacenamiento
de todo tipo de datos y para su manejo de asignar o eliminar en casi cualquier lugar
de la cola.