Algoritmos y Estructuras de Datos

3. Estructuras de Datos Básicas

3.1. Conceptos Generales

Manejo de datos

Los datos son costosos, por esto deben ser manejados de tal manera que sean correctos y estén
disponibles para producir información. Aspectos a considerar en el manejo de datos:

Medición
Colección

Transcripción

Validación

Organización

Almacenamiento

Agregación

Actualización

Recuperación

Protección

El objetivo de un sistema de manejo de datos es hacer que estos sean adaptables y flexibles para apoyar
el proceso de toma de decisiones de una organización. Cuatro sugerencias útiles para un sistema de
administración de datos son:

Los datos deben representarse y almacenarse en cierta forma para accesarlos posteriormente.

Los datos deben organizarse de manera adecuada para accesarlos selectiva y eficientemente.

Los datos deben procesarse y presentarse de tal manera que puedan apoyar eficientemente al

usuario.
Los datos deben protegerse y manejarse para que no pierdan su valor.

Estructura de datos

Es una clase de datos que se puede caracterizar por su organización y operaciones definidas sobre ella.
También se puede llamar tipo de dato.

En un programa cada variable pertenece a alguna estructura de datos explícita o implícitamente

definida, la cual determina el conjunto de operaciones válidas para ella. Las estructuras de datos lógica
puede tener varias representaciones físicas diferentes, es decir, varias estructuras de almacenamiento.

Estructuras primitivas: son aquellas que no están compuestas por otras estructuras de datos. Ej enteros,
booleanos, caracteres.

Estructuras simples: son estructuras que se construyen a partir de estructuras primitivas. Ej. cadenas,
arreglos, registro.

Estructuras lineales: es una estructura de datos compleja, es decir, formada por estructuras simples. En
esta estructura para cada elemento hay un elemento siguiente. Ej. pila, filas, listas ligadas.

Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela

Facultad de Ingeniería Docente Área Informática
Estructura de datos no lineales: también es una estructura de datos compleja pero en este caso los
elementos están representados por relaciones más complejas. En este caso para cada elemento hay
varios elementos siguientes, por eso es que se llaman estructuras de ramificación. Ej. grafos, árboles.

Estructuras primitivas y simples

Enteros: Es un elemento del siguiente conjunto:

{. . . , -(n-1), -n, ..., -2, -1, 0, 1, 2, ..., n, (n+1), ...}

Ej. En Pascal: var contador, suma: integer;

Las operaciones fundamentales sobre los enteros son: suma, resta, multiplicación, división y otras.

Booleanos: también llamado lógico. Es un dato que puede tener uno de dos valores: verdadero o falso.
Los operadores booleanos son la negación (not), la conjunción (and) y la disyunción (or).

Ej. En Pascal: var respuesta: boolean;

Caracteres: Un carácter es un elemento tomado de un conjunto de símbolos. Por ejemplo el conjunto:

{0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,...,X,Y,Z,?, *, +,#,...}

Este conjunto contiene dígitos, letras del alfabeto y caracteres especiales.

Ej. En Pascal: var letra: char;

Cadena: Es una secuencia finita de símbolos tomados de un conjunto de caracteres. Las operaciones
más comunes sobre las cadenas son la longitud, concatenación y subcadena.

Ej. En Pascal: var nombre: packed array[1..20] of char;

Arreglo: Un arreglo es un conjunto finito ordenado de elementos homogéneos. Es ordenado porque se

puede identificar el primero, el segundo, etc. y es homogéneo porque todos los elementos son del
mismo tipo. Existen arreglos unidimensionales, bidimensionales, tridimensionales, ...,
multidemsionales.

Ej. En Pascal: var arreglo: array[1..4] of integer;

Registros: Es una colección finita y ordenada de elementos, posiblemente heterogéneos, que se tratan
como una unidad. Los elementos de un registro son llamados campos. Un campo es un área específica
de un registro utilizada para una clase particular de información.

type
tipo_elemento = record
num_cta : integer;
nombre : packed array [1..20] of char;
direccion: packed array [1..50] of char;
end;

Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela

Facultad de Ingeniería Docente Área Informática
3.2. LISTAS

Introducción

Una lista enlazada o encadenada es una colección de elementos ó nodos, en donde cada uno contiene
datos y un enlace o liga.
Un nodo es una secuencia de caracteres en memoria dividida en campos (de cualquier tipo). Un nodo
siempre contiene la dirección de memoria del siguiente nodo de información si este existe.
Un apuntador es la dirección de memoria de un nodo
La figura siguiente muestra la estructura de un nodo:

DATO LIGA

El campo liga, que es de tipo puntero, es el que se usa para establecer la liga con el siguiente nodo de la
lista. Si el nodo fuera el último, este campo recibe como valor NIL (vacío).
A continuación se muestra el esquema de una lista :

Juan Luis María Sofía NIL

Forma de declarar una lista enlazada

Type nodo = record
dato : array[1..20] of char;
liga : ^nodo:
end;

LISTA = ^nodo;

Operaciones en Listas Enlazadas

Las operaciones que podemos realizar sobre una lista enlazada son las siguientes:
• Recorrido. Esta operación consiste en visitar cada uno de los nodos que forman la lista . Para
recorrer todos los nodos de la lista, se comienza con el primero, se toma el valor del campo liga
para avanzar al segundo nodo, el campo liga de este nodo nos dará la dirección del tercer nodo,
y así sucesivamente.
• Inserción. Esta operación consiste en agregar un nuevo nodo a la lista. Para esta operación se
pueden considerar tres casos:
o Insertar un nodo al inicio.
o Insertar un nodo antes o después de cierto nodo.
o Insertar un nodo al final.
• Borrado. La operación de borrado consiste en quitar un nodo de la lista, redefiniendo las ligas
que correspondan. Se pueden presentar cuatro casos:
o Eliminar el primer nodo.
o Eliminar el último nodo.
o Eliminar un nodo con cierta información.
o Eliminar el nodo anterior o posterior al nodo cierta con información.
• Búsqueda. Esta operación consiste en visitar cada uno de los nodos, tomando al campo liga
como puntero al siguiente nodo a visitar.

Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela

Facultad de Ingeniería Docente Área Informática
Listas Lineales

En esta sección se mostrarán algunos algoritmos sobre listas lineales sin nodo de cabecera y con nodo
de cabecera.
Una lista con nodo de cabecera es aquella en la que el primer nodo de la lista contendrá en su campo
dato algún valor que lo diferencie de los demás nodos (como : *, -, +, etc). Un ejemplo de lista con
nodo de cabecera es el siguiente:

* Luis María Sofía NIL

En el caso de utilizar listas con nodo de cabecera, usaremos el apuntador CAB para hacer referencia a
la cabeza de la lista.
Para el caso de las listas sin nodo de cabecera, se usará la expresión TOP para referenciar al primer
nodo de la lista, y TOP.dato, TOP.liga para hacer referencia al dato almacenado y a la liga al siguiente
nodo respectivamente.

Algoritmo de Creación

Crea_lista_final(p){donde p es de tipo puntero}

{top es un puntero al inicio de la lista, q es de tipo puntero}
top<--NIL
repite
crea(p)
leer(p^.dato)
si top=NIL entonces
top<--p
q <-- p
en caso contrario
q^.liga<--p
p^.liga<--NIL
q<--p
mensaje('otro nodo?')
leer(respuesta)
hasta respuesta=no
Crea_lista_inicio(p){donde p es de tipo puntero}
{top es un puntero al inicio de la lista, q es de tipo puntero}
top<--NIL
repite
crea(p)
leer(p^.dato)
si top=NIL entonces
top<--p
en caso contrario
p^.liga<--top
top<--p
mensaje('otro nodo?')
leer(respuesta)
hasta respuesta=no

Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela

Facultad de Ingeniería Docente Área Informática
Algoritmo para Recorrido

Recorre_lista(TOP) {TOP es un puntero al inicio de una lista)

comienzo
p<--top;
mientras p<>NIL hacer
escribe(p^.dato);
p<--p^.liga;
fin

Algoritmo para insertar

inserta_final_lista(TOP)
comienzo
p<--top
mientras p^.liga<>NIL hacer
p<--p^.liga;
new(q)
leer(q^.dato);
p^.liga<--q
q^.liga<--NIL
fin

inserta_inicio_lista(TOP)
comienzo
crea(p);
leer(p^.dato);
p^.liga <-- top;
top <-- p;
fin

Algoritmo para insertar antes/después de 'X' información

p<--top
mensaje(antes/despues)
lee(respuesta)
si antes entonces
mientras p<>NIL haz
si p(dato)='x' entonces
new(q)
leer(q(dato))
q(liga)<--p
si p=top entonces
top<--q
en caso contrario
r(liga)<--q
p<--nil
en caso contrario
r<--p
p<--p(link)
si despues entonces
p<--top
mientras p<>NIL haz
si p(dato)='x' entonces
new(q)
leer(q(dato))
q(liga)<--p(liga)
p(liga)<--q

Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela

Facultad de Ingeniería Docente Área Informática
 p<--NIL
en caso contrario
p<--p(liga)
p<--top
mientras p(liga)<>NIL haz
p<--p(liga)
new(q)
p(liga)<--q
q(liga)<--NIL

Algoritmo para borrar un nodo

p<--top
leer(valor_a_borrar)
mientras p<>NIL haz
si p(dato)=valor_a_borrar entonces
si p=top entonces
si p(liga)=NIL entonces
top<--NIL
en caso contrario
top(liga)<--top(liga)
en caso contrario
q(liga)<--p(liga)
dispose(p)
p<--NIL
en caso contrario
q<--p
p<--p(liga)
Algoritmo de creación de una lista con nodo de cabecera

new(cab)
cab(dato)<--'*'
cab(liga)<--NIL
q<--cab
repite
new(p)
leer(p(dato))
p(liga)<--NIL
q<--p
mensaje(otro nodo?)
leer(respuesta)
hasta respuesta=no

Algoritmo de extracción en una lista con nodo de cabecera

leer(valor_a_borrar)
p<--cab
q<--cab(liga)
mientras q<>NIL haz
si q(dato)=valor_a_borrar entonces
p<--q(liga)
dispose(q)
q<--NIL
en caso contrario
p<--q
q<--q(liga)

Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela

Facultad de Ingeniería Docente Área Informática
Listas Dobles

Una lista doble , ó doblemente ligada es una colección de nodos en la cual cada nodo tiene dos
punteros, uno de ellos apuntando a su predecesor (li) y otro a su sucesor(ld). Por medio de estos
punteros se podrá avanzar o retroceder a través de la lista, según se tomen las direcciones de uno u otro
puntero.
La estructura de un nodo en una lista doble es la siguiente:
LI DATO LD

Existen dos tipos de listas doblemente ligadas:

Listas dobles lineales. En este tipo de lista doble, tanto el puntero izquierdo del primer nodo
como el derecho del último nodo apuntan a NIL.
Listas dobles circulares. En este tipo de lista doble, el puntero izquierdo del primer nodo
apunta al último nodo de la lista, y el puntero derecho del último nodo apunta al primer nodo de
la lista.

Debido a que las listas dobles circulares son más eficientes, los algoritmos que en esta sección se traten
serán sobre listas dobles circulares.

En la figura siguiente se muestra un ejemplo de una lista doblemente ligada lineal que almacena
números:

En la figura siguiente se muestra un ejemplo de una lista doblemente ligada circular que almacena
números:

Algoritmo de creación de lista dobles circulares

top<--NIL
repite
si top=NIL entonces
new(p)
lee(p(dato))
p(ld)<--p
p(li)<--p
top<--p
en caso contrario
new(p)
lee(p(dato))
p(ld)<--top
p(li)<--p
p(ld(li))<--p
mensaje(otro nodo?)
lee (respuesta)
hasta respuesta=no

Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela

Facultad de Ingeniería Docente Área Informática
Algoritmo para recorrer la lista

--RECORRIDO A LA DERECHA.

p<--top
repite
escribe(p(dato))
p<--p(ld)
hasta p=top

--RECORRIDO A LA IZQUIERDA.

p<--top
repite
escribe(p(dato))
p<--p(li)
hasta p=top(li)

Algoritmo para insertar antes de 'X' información

p<--top
mensaje (antes de ?)
lee(x)
repite
si p(dato)=x entonces
new(q)
leer(q(dato))
si p=top entonces
top<--q
q(ld)<--p
q(li)<--p(li)
p(ld(li))<--q
p(li)<--q
p<--top
en caso contrario
p<--p(ld)
hasta p=top

Algoritmo para insertar despues de 'X' información

p<--top
mensaje(despues de ?)
lee(x)
repite
si p(dato)=x entonces
new(q)
lee(q(dato))
q(ld)<--p(ld)
q(li)<--p
p(li(ld))<--q
p(ld)<--q
p<--top
en caso contrario
p<--p(ld)
hasta p=top

Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela

Facultad de Ingeniería Docente Área Informática
Algoritmo para borrar un nodo

p<--top
mensaje(Valor a borrar)
lee(valor_a_borrar)
repite
si p(dato)=valor_a_borrar entonces
p(ld(li))<--p(ld)
p(li(ld))<--p(li)
si p=top entonces
si p(ld)=p(li) entonces
top<--nil
en caso contrario
top<--top(ld)
dispose(p)
p<--top
en caso contrario
p<--p(ld)
hasta p=top

Listas Circulares

Las listas circulares tienen la característica de que el último elemento de la misma apunta al primero.
La siguiente figura es una representación gráfica de una lista circular.

Enseguida se mostrarán los algoritmos más comunes en listas circulares. Al igual que en las secciones
anteriores, utilizaremos el apuntador top para hacer referencia al primer nodo en la lista.

Algoritmo de creación
repite
new(p)
lee(p(dato))
si top=nil entonces
top<--p
q<--p
en caso contrario
q(liga)<--p
q<--p
p(liga)<--top
mensaje (otro nodo ?)
lee(respuesta)
hasta respuesta=no

Algoritmo para recorrer la lista

p<--top
repite
escribe(p(dato))
p<--p(liga)
hasta p=top

Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela

Facultad de Ingeniería Docente Área Informática
Algoritmo para insertar antes de 'X' información
new(p)
lee(p(dato))
si top=nil entonces
top<--p
p(liga)<--top
en caso contrario
mensaje(antes de ?)
lee(x)
q<--top
r<--top(liga)
repite
si q(dato)=x entonces
p(liga)<--q
r(liga)<--p
si p(liga)=top entonces
top<--p
q<--q(liga)
r<--r(liga)
hasta q=top

Algoritmo para insertar después de 'X' información

new(p)
lee(p(dato))
mensaje(después de ?)
lee(x)
q<--top
r<--top(liga)
repite
si q(dato)=x entonces
q(liga)<--p
p(liga)<--r
q<--q(liga)
r<--r(liga)
hasta q=top

Algoritmo para borrar

mensaje(valor a borrar )
lee(valor_a_borrar)
q<--top; r<--top; p<--top
mientras q(liga)<>top haz
q<--q(liga)
repite
si p(dato)=valor_a_borrar entonces
si p=top entonces
si top(liga)=top entonces
top<--NIL
en caso contrario
top<--top(liga)
q(liga)<--top
en caso contrario
r(liga)<--p(liga)
dispose(p)
p<--top
en caso contrario
r<--p
p<--p(liga)
hasta p=top

Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela

Facultad de Ingeniería Docente Área Informática
Listas doblemente encadenadas

En estas listas cada nodo conoce quien es el siguiente nodo y quien es el anterior.

NODO Ant Dato Sig

Donde Ant y Sig son punteros a NODO.

TOP NIL

NIL FIN

Procedimiento de crear el primer nodo de una lista enlazada

p1 TOP5 NIL3

1. crea(p)
2. p^.dato= INFO INFO2
3. p^.sig = NIL
4. p^.ant = NIL
5. TOP = p
6. FIN = p NIL4 FIN6

Procedimiento para insertar un nodo al comienzo

1. crea(p)
2. p^.dato= INFO
3. p^.sig = TOP
4. p^.ant = NIL
5. TOP^.ant = p
6. TOP = p

Procedimiento para insertar despues de un nodo de referencia

Se recorre la pila hasta encontrar el nodo de referencia, que queda apuntado por q
crea(p)
p^.dato = INFO
p^.sig = q^.sig
p^.ant = q
q^.sig.ant = p
q^.sig =p

Procedimiento para insertar antes de un nodo de referencia

Se recorre la pila hasta encontrar el nodo de referencia, que queda apuntado por q
crea(p)
p^.dato = INFO
p^.sig = q
p^.ant = q^.ant
q^.ant.sig = p
q^.ant = p

Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela

Facultad de Ingeniería Docente Área Informática
3.3. Tipo de Dato Abstracto Pila (Stack)

Las pilas son otro tipo de estructura de datos lineales, las cuales presentan restricciones en cuanto a la
posición en la cual pueden realizarse las inserciones y las extracciones de elementos.

Una pila es una lista de elementos en la que se pueden insertar y eliminar elementos sólo por uno de los
extremos. Como consecuencia, los elementos de una pila serán eliminados en orden inverso al que se
insertaron. Es decir, el último elemento que se metió a la pila será el primero en salir de ella.

En la vida cotidiana existen muchos ejemplos de pilas, una pila de platos en una alacena, una pila de
latas en un supermercado, una pila de papeles sobre un escritorio, golosinas en una máquina de ventas
automáticas, etc.

Debido al orden en que se insertan y eliminan los elementos en una pila, también se le conoce como
estructura LIFO (Last In, First Out: último en entrar, primero en salir).

Representación en Memoria

Las pilas no son estructuras de datos fundamentales, es decir, no están definidas como tales en los
lenguajes de programación. Las pilas pueden representarse mediante el uso de :
• Arreglos.
• Listas enlazadas.
Nosotros ahora usaremos los arreglos. Por lo tanto debemos definir el tamaño máximo de la pila,
además de un apuntador (SP: entero) que indica la cima de la pila, es decir, dónde se debe insertar el
próximo elemento. La representación gráfica de una pila es la siguiente:

Arreglo : tamaño máximo 5

SP=2
DATO1

Como utilizamos arreglos para implementar pilas, tenemos la limitante de espacio de memoria
reservada. Una vez establecido un máximo de capacidad para la pila, ya no es posible insertar más
elementos.

Una posible solución a este problema es el uso de espacios compartidos de memoria. Supóngase que se
necesitan dos pilas , cada una con un tamaño máximo de n elementos. En este caso se definirá un solo
arreglo de 2*n elementos, en lugar que dos arreglos de n elementos.

En este caso utilizaremos dos apuntadores: SP1 para apuntar al último elemento insertado en la pila 1 y
SP2 para apuntar al último elemento insertado en la pila 2. Cada una de las pilas insertará sus
elementos por los extremos opuestos, es decir, la pila 1 iniciará a partir de la localidad 1 del arreglo y la
pila 2 iniciará en la localidad 2n. De este modo si la pila 1 necesita más de n espacios (hay que recordar
que a cada pila se le asignaron n localidades) y la pila 2 no tiene ocupados sus n lugares, entonces se
podrán seguir insertando elementos en la pila 1 sin caer en un error de desbordamiento.

Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela

Facultad de Ingeniería Docente Área Informática
Inicialmente SP debe estar en un extremo del arreglo, existen dos formas de implementar el arreglo:
creciente hacia abajo o creciente hacia arriba.

1 ///////////// push pop 1

2 ///////////// 2
. .
. .
n-2 n-2
n-1 n-1 //////////////// push pop
n n ////////////////
Creciente Creciente
hacia abajo hacia arriba

Pila vacia: sp = 1 Pila vacía: sp = n

Pila llena : sp = n+1 Pila llena : sp = 0

Operaciones en Pilas

Las principales operaciones que podemos realizar en una pila son:

• Insertar un elemento (push).

• Eliminar un elemento (pop).

Los algoritmos para realizar cada una de estas operaciones se muestran a continuación. La variable
máximo para hacer referencia al máximo número de elementos en la pila.

Inserción (Push)

si sp=máximo entonces
mensaje (overflow)
en caso contrario
sp<-- sp+1
pila[sp]<-- valor

Eliminación (Pop)

si sp=0 entonces
mensaje (underflow)
en caso contrario
x<--pila[sp]
sp<--sp-1

Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela

Facultad de Ingeniería Docente Área Informática
3.4. Tipo de Dato Abstracto Cola

Las colas son otro tipo de estructura de datos lineales, las cuales presentan restricciones en cuanto a la
posición en la cual pueden realizarse las inserciones y las extracciones de elementos.

Una cola es una lista de elementos en la que se insertan elementos por un extremo y se eliminan
elementos por el extremo opuesto. Como consecuencia, los elementos de una cola serán eliminados en
el mismo orden en que se insertaron. Es decir, el primer elemento que se metió a la cola será el primero
en salir de ella.

En la vida cotidiana existen muchos ejemplos de colas, una cola para pagar cuentas en el banco, una
cola de llamadas telefónicas en una central, una cola de impresión, etc.

Debido al orden en que se insertan y eliminan los elementos en una cola, también se le conoce como
estructura FIFO (First In, First Out: primero en entrar, primero en salir).

Operaciones en Colas

Las principales operaciones que podemos realizar en una cola son:

• Insertar un elemento (in).
• Extraer un elemento (out).

Representación en Memoria

Las colas no son estructuras de datos fundamentales, es decir, no están definidas como tales en los
lenguajes de programación. Las colas pueden representarse mediante el uso de :
• Arreglos.
• Listas enlazadas.

Nosotros ahora usaremos los arreglos. Existen tres métodos diferentes para representar una cola
mediante arreglos:

Primer Método:

Se define un arreglo de tamaño máximo y un apuntador al inicio de la cola (primer elemento) y uno al
final de la cola (próximo espacio libre). Cada vez que se inserta un nuevo elemento se incrementa el
apuntador del final hasta que se llega al tamaño máximo más uno. Cada vez que se extrae un elemento
se decrementa el apuntador al inicio hasta que inicio es igual a final.

La representación gráfica de una cola es la siguiente:

Arreglo : tamaño máximo 5

1 A inicio =1
2 B
3 fin = 3
4
5

Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela

Facultad de Ingeniería Docente Área Informática
El problema con este tipo de representación es que si se inserta el tamaño máximo de elementos del
arreglo, no se podrá seguir insertando aunque se hayan extraído elementos.

Ejemplo: Realice en forma gráfica la siguiente secuencia de operaciones: in(A), in(B), in(C), out(A),
in(D), out(B), out(C), in(E), in(F). Registre cada vez los valores de inicio y fin.

La cola está vacía si inicio = 0 o fin = 1 y la cola está llena si fin = tam_max + 1

El esta representación tanto la inserción de elementos como la eliminación son de O(1).

Segundo Método:

Una forma de solucionar este problema es desplazar los datos hacia arriba cada vez que se extrae un
elemento. De esta forma el dato a extraer siempre estará en la primera posición del arreglo.

Ejemplo: Realice en forma gráfica la siguiente secuencia de operaciones: in(A), in(B), in(C), out(A),
in(D), out(B), out(C), in(E), in(F). Registre cada vez los valores de inicio y fin.

El problema que surge con este método es que la inserción es de O(1) y la extracción se incrementa a
O(n) por tener que hacer los corrimientos.

Tercer Método:

Este método consiste en implementar la cola utilizando un buffer circular, en este caso tanto la
inserción como la extracción de elementos se mantienen de O(1).

El apuntador inicio siempre está en la posición donde se debe extraer el próximo elemento y el
apuntador fin estará en la posición donde se debe insertar el próximo elemento, Si fin está en la
posición del tamaño máximo del arreglo debe ser inicializado en el primer elemento del arreglo de
manera de continuar circularmente, esto siempre y cuando inicio no sea igual al primer elemento, en
cuyo caso la cola estará llena. Inicio debe ser incrementado cada vez que se extrae un elemento e
inicializado en la primera posición del arreglo cuando se extraiga elemento de la última posición del
arreglo, esto siempre y cuando inicio sea distinto de fin en cuyo caso la cola estará vacía.

El problema con esta representación es que la condición inicio = fin se aplica tanto para la cola llena
como para la cola vacía. Para solucionar esto se utiliza una variable para almacenar el número de
elementos de la cola. Si la variable es igual a cero la cola está vacía, cuando la variable es igual al
tamaño máximo del arreglo la cola está llena.

Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela

Facultad de Ingeniería Docente Área Informática