Estructura de Datos - Unidad III Estructuras Lineales Material de Clase de la Asignatura Estructura de Datos Ingeniería en Sistemas Computacionales Estructuras de datos en C++

1. Ingeniería en Sistemas Computacionales
Estructura de Datos
Unidad III: Estructuras Lineales
Este material fue diseñado para la asignatura de Estructura de Datos de la carrera de Ingeniería en Sistemas
Computacionales, plan de estudios ISIC-2010-224.

2. Competencia de la
Unidad
• Conocer, identificar
y aplicar las
estructuras lineales
en la solución de
problemas del
mundo real.

3. Estructuras Lineales
• En esta unidad se comienza el estudio de las estructuras de datos dinámicas.
Al contrario que las estructuras de datos estáticas (arrays) en las que su
tamaño en memoria se establece durante la compilación y permanece
inalterable durante la ejecución del programa, las estructuras de datos
dinámicas crecen y se contraen a medida que se ejecuta el programa, por lo
que la cantidad de memoria que requieren para funcionar es muy variable.
• Las estructuras lineales de elementos homogéneos implementadas con arrays
necesitan fijar por adelantado el espacio a ocupar en memoria, de modo que
cuando se desea añadir un nuevo elemento, que rebase el tamaño prefijado,
no será posible sin que se produzca un error en tiempo de ejecución. Esto hace
ineficiente el uso de los arrays en algunas aplicaciones.

4. LISTAS ENLAZADAS

5. • Una lista enlazada es una colección o secuencia de elementos dispuestos uno
detrás de otro, en la que cada elemento se conecta al siguiente elemento por
un “enlace”.
• La idea básica consiste en construir una lista cuyos elementos, llamados
nodos, se componen de dos partes o campos:
 La primera parte contiene la información y es, por consiguiente, un valor
de un tipo genérico (denominado Dato, TipoElemento, Info, etc.);
 La segunda parte es un enlace que apunta al siguiente nodo de la lista.

6. • La representación gráfica más extendida es aquella que utiliza una caja con dos
secciones en su interior. En la primera sección se encuentra el elemento o
valor a almacenar y en la segunda sección el enlace o puntero, representado
mediante una flecha que sale de la caja y apunta al siguiente nodo.

7. Clasificación de las listas enlazadas
LISTAS SIMPLEMENTE ENLAZADAS: Cada nodo (elemento)
contiene un único enlace que conecta ese nodo al nodo siguiente
o nodo sucesor. La lista es eficiente en recorridos directos
(“adelante”).

8. Clasificación de las listas enlazadas
LISTAS DOBLEMENTE ENLAZADAS: Cada nodo contiene dos
enlaces, uno a su nodo predecesor y el otro a su nodo sucesor. La
lista es eficiente tanto en recorrido directo (“adelante”) como en
recorrido inverso (“atrás”).

9. Clasificación de las listas enlazadas
LISTA CIRCULAR SIMPLEMENTE ENLAZADA: Una lista simplemente
enlazada en la que el último elemento (cola) se enlaza al primer
elemento (cabeza) de tal modo que la lista puede ser recorrida de
modo circular (“en anillo”).

10. Clasificación de las listas enlazadas
LISTA CIRCULAR DOBLEMENTE ENLAZADA: Una lista doblemente
enlazada en la que el último elemento se enlaza al primer
elemento y viceversa. Esta lista se puede recorrer de modo circular
(en anillo) tanto en dirección directa (“hacia adelante”) como
inversa (“hacia atrás”).

11. TRABAJANDO CON LISTAS
• Para trabajar con una lista enlazada debemos crear una estructura que refleje
la información contenida en cada nodo de la misma y que contenga una
variable de tipo apuntador que conecte cada nodo con el nodo siguiente.
La variable tipo apuntador
se define con un asterisco
y debe ser del mismo tipo
de la estructura declarada

12. TRABAJANDO CON LISTAS
• Después debemos definir el nombre de la lista que utilizaremos a lo largo de
nuestro programa y una serie de variables auxiliares que servirán para la
creación de nodos, estas variables también son de tipo apuntador.
Cuando declaramos una variable con
un asterisco antes del nombre
estamos reservando un espacio de
memoria para el objeto que
posteriormente será creado

13. INSERTAR NODO INICIAL O CABECERA DE LA LISTA
• Cando declaramos la variable I utilizando un asterisco (*I) lo que hicimos fue
reservar un espacio en memoria para almacenar la información, por lo que al
insertar el primer nodo sólo es necesario crear el objeto o nodo que
utilizaremos:
Crea el nuevo
objeto o nodo
Asigna valor a la
variable de trabajo
Apunta a NULL ya que no hay
otros nodos por el momento
Algoritmo de inserción
Crear el nuevo nodo
Asignar la información
al campo
correspondiente
Asignar NULL a la
variable apuntador

14. ALGORITMO DE INSERCIÓN
DE NODOS SUBSECUENTES
EN LA LISTA (INCLUYENDO
NODO COLA O “TAIL”).
SI T==NULL
crear nuevo nodo
asignar datos al campo correspondiente
asignar NULL a la variable apuntador
apunta la cabecera al nuevo nodo cola
SINO
reservar memoria y crear nuevo nodo
asignar datos al campo correspondiente
asignar NULL a la variable apuntador del nodo final
enlazar el nodo anterior con el nuevo
igualar nodo cola a nodo de trabajo
FINSI

15. INSERTAR NODOS SUBSECUENTES EN LA LISTA
(INCLUYENDO NODO COLA O “TAIL”).
Cuando no hay
ningún nodo
salvo la cabeza
Cuando ya existe
un nodo cola, se
agrega otro al
final y se cambia
la referencia del
nodo cola
Crea el nodo
Asigna Datos
Apunta a NULL
el nodo final
Apunta la cabecera
al nuevo nodo cola
Reserva memoria y crea
el nodo
Asigna Datos
Apunta a NULL
el nuevo nodo
Enlaza el nodo
anterior al nuevo
Asigna nodo cola

16. RECORRER LA LISTA DESDE EL INICIO
• Algoritmo de recorrido
Igualar nodo de trabajo a nodo cabeza
MIENTRAS nodo de trabajo != Nulo
Imprimir datos del nodo
Nodo de trabajo = siguiente nodo
FINMIENTRAS
• Código en C++

17. ALGORITMO DE INSERCIÓN DE NODOS AL INICIO DE LA LISTA O NODO CABEZA.
SI cabeza==NULL
crear nuevo nodo inicial
asignar datos al campo correspondiente
asignar NULL a la variable apuntador
SINO
reservar memoria y crear nuevo nodo
asignar datos al campo correspondiente
enlazar el nodo actual con el nodo cabeza
igualar nodo cabeza al nodo actual
FINSI

18. CÓDIGO DE INSERCIÓN DE NODOS AL INICIO DE LA LISTA O
NODO CABEZA.
Cuando no hay
ningún nodo en
la lista
Cuando ya
existe un nodo
CABEZA, se
agrega el nuevo
al inicio
Crea nodo
cabeza
Reserva memoria y
crea el nodo
Asigna Datos
Nuevo nodo apunta
al nodo inicial
Convierte el nuevo
nodo en nodo CABEZA

19. ELIMINAR UN NODO DE LA LISTA
• Para eliminar un nodo de la lista
debemos verificar primero si se
trata del nodo cabeza o de un
nodo subsecuente.
• Para realizar esta eliminación
son necesarios 3 variables
auxiliares tipo nodo: auxiliar,
actual, anterior
• A continuación se presenta el
algoritmo para hacer dicha
verificación y la posterior
eliminación;
SI (DATO == cabeza-> info)
hacer auxiliar = nodo inicial
hacer nodo cabeza= auxiliar->siguiente
eliminar(auxiliar)
SINO
anterior = cabeza
actual = cabeza->siguiente
MIENTRAS (actual != NULL && actual->info != DATO)
anterior = actual
actual = actual->siguiente
FINMIENTRAS
SI (actual != NULL)
auxiliar = actual
anterior->siguiente = actual->siguiente
eliminar(auxiliar)
SI (anterior->siguiente ==NULL) T=anterior FINSI
FINSI
FINSI

20. CÓDIGO DE ELIMINACIÓN
DE UN NODO DE LA LISTA

21. • Ejercicio: Realizar el programa completo con listas enlazadas simples.
 Debe incluir menú de opciones;
 Debe incluir módulo de captura de Nodo de Inicio o Nodo Cabeza;
 Debe poder capturar Nodo Cola;
 Debe poder insertar un nuevo Nodo Cabeza;
 Debe poder eliminar un nodo seleccionado;
 Debe incluir un recorrido desde el Nodo Cabeza hasta el Nodo Cola
mostrando el promedio los elementos contenidos y el número de nodos
de la lista;
• Entregar el programa

22. PILAS

23. PILAS
PILA: Es un conjunto de elementos que solo pueden insertarse y
eliminarse por un extremo. Se trata de una estructura de datos de
acceso restrictivo a sus elementos.
Un ejemplo de pila es una torre de discos compactos, en la cual los
discos se insertan y se extraen por el mismo extremo.

24. • En la computación estas estructuras suelen ser fundamentales. La recursividad
se simula en un computador con la ayuda de una pila. Asimismo muchos
algoritmos emplean las pilas como estructura de datos fundamental, por
ejemplo para mantener una lista de tareas pendientes que se van acumulando.
• Las pilas ofrecen dos operaciones fundamentales, que son apilar y desapilar
sobre la cima. El uso que se les de a las pilas es independiente de su
implementación interna. Es decir, se hace un encapsulamiento. Por eso se
considera a la pila como un tipo abstracto de datos.
• Es una estructura de tipo LIFO (Last In First Out), es decir, último en entrar,
primero en salir.

25. ELEMENTOS DE UNA PILA
• Tope o cima: Indica el último elemento insertado en la pila.
• Máximo: Se refiere al número de elementos que puede contener la pila.

26. • Pilas con Arreglos: Representar pilas usando arreglos es relativamente más
sencillo que usando listas enlazadas, el único problema que existe es la
limitante de espacio en memoria, ya que al definir un tamaño máximo ya no es
posible insertar más elementos.

27. • Pilas con Listas enlazadas: Son llamadas también estructuras dinámicas, ya
que el espacio en memoria se crea hasta que se inserta el elemento.

28. OPERACIONES CON PILAS
Operaciones Auxiliares con PILAS
• Pila llena (si el tope == Máximo-1)
• Pila vacía (si tope == -1)
• Recorrer pila (desde elemento 0 hasta tope)
Eliminar un elementoInsertar un elemento

29. Estatus de las PILAS

30. TRABAJANDO CON PILAS POR MEDIO DE ARRAYS (ESTÁTICAS)
Crear las variables necesarias
int pila[5];
int maximo=5;
Int tope=-1;
Int dato=0;
Int opc=0;
Pila
Máximo de
elementos
Iniciar tope con
valor negativo
Variable para
captura de datos
Variable para menú
de opciones

31. VERIFICAR SI LA PILA ESTA LLENA
Algoritmo
FUNCION boolena llena()
SI (tope == maximo – 1)
regresar verdadero
SINO
regresar falso
FINSI
FINFUNCION

32. VERIFICAR SI LA PILA ESTA VACIA
Algoritmo
FUNCION boolena vacia()
SI (tope == – 1)
regresar verdadero
SINO
regresar falso
FINSI
FINFUNCION

33. INSERTAR ELEMENTO EN LA PILA
Algoritmo
MODULO insertar() {
SI LA PILA ESTA LLENA
MOSTRAR “Pila llena”
SINO
CAPTURAR ELEMENTO
INCREMENTAR tope EN 1
pila[tope]=ELEMENTO;
FINSI
FINMODULO

34. ELIMINAR ELEMENTO EN LA PILA
Algoritmo
MODULO eliminar() {
SI LA PILA ESTA VACIA
MOSTRAR “Pila Vacia”
SINO
MOSTRAR CONTENIDO
ELIMINAR ELEMENTO
DECREMENTAR TOPE EN 1
FINSI
FINMODULO

35. RECORRIDO DE UNA PILA
Algoritmo
MODULO recorrer() {
DECLARAR var de trabajo
SI LA PILA ESTA VACIA
MOSTRAR “Pila Vacia”
SINO
MIENTRAS var<=tope
MOSTRAR CONTENIDO
INCREMENTAR var en 1
FINMIENTRAS
FINSI
FINMODULO

36. • Ejercicio: Desarrolle el programa correspondiente a la PILA que se ha visto en
clase creando un menú que contemple las siguientes opciones:
1. Pila llena
2. Pila vacía
3. Insertar
4. Eliminar
5. Recorrido
6. Terminar
• Entregar el programa en código para revisión

37. COLAS

38. Definición de COLAS
Una COLA es un conjunto homogéneo de elementos, del cual
pueden suprimirse elementos sólo desde un extremo llamado
parte delantera, asimismo, sólo pueden agregarse elementos en
el extremo contrario llamado parte posterior.
• El primer elemento en ser agregado a una COLA es
el primer elemento en ser eliminado.
• Por esta razón una COLA se denomina FIFO (First
In-First Out), que es justo el concepto contrario a
una PILA o LIFO (Last In-First Out).

39. COLAS DINÁMICAS CON NODOS
Parte
Delantera o
Salida
Parte
Posterior o
Entrada

40. COLAS ESTÁTICAS CON ARRAYS
Parte
Posterior o
Entrada
Parte
Delantera
o Salida
Operaciones Auxiliares con COLAS
• COLA llena (si el final == Máximo-1)
• COLA vacía (si final == -1)
• Recorrer COLA (desde elemento 0 hasta final)

41. TRABAJANDO CON COLAS ESTÁTICAS
• Una cola estática utiliza un arreglo con un número limitado de elementos en el
mismo, dicho arreglo requiere de una constante que controle el máximo de
elementos que pueden ser cargados a la cola, y de una variable que controle el
elemento final de la cola (último en ser insertado).
• Declaración de las variables de la COLA estática
int cola[5];
int final = -1;
int maximo = 5;
COLA
Último elemento
Máximo de elementos

42. ALGORITMO PARA DETERMINAR SI LA COLA ESTÁ LLENA
FUNCION BOLEANA llena ()
SI (final >= maximo - 1 ) ENTONCES
REGRESAR verdadero
SINO
REGRESAR falso
FINSI
FINFUNCION
ALGORITMO

43. ALGORITMO PARA DETERMINAR SI LA COLA ESTÁ VACIA
FUNCION BOLEANA vacia ()
SI (final < 0) ENTONCES
REGRESAR verdadero
SINO
REGRESAR falso
FINSI
FINFUNCION
ALGORITMO

44. ALGORITMO PARA INSERTAR ELEMENTO EN LA COLA
MODULO insertar(DATO)
SI (llena) ENTONCES
IMPRIME “cola llena”
SINO
incrementar final
cola[final]=DATO
FINSI
FINMODULO
ALGORITMO

45. ALGORITMO PARA ELIMINAR ELEMENTO EN LA COLA
MODULO eliminar ()
SI (vacia) ENTONCES
IMPRIME “cola vacia”
SINO
FOR (J=0, J<máximo, j++)
cola[j]=cola[j+1]
FINFOR
FINSI
DECREMENTAR final
FINMODULO
ALGORITMO

46. ALGORITMO PARA HACER RECORRIDO DE COLA
MODULO recorrer ()
SI (vacia) ENTONCES
IMPRIME “cola vacia”
SINO
FOR (J=0, J<=final, j++)
imprime cola[j]
FINFOR
FINSI
FINMODULO
ALGORITMO

47. • Ejercicio: Desarrolle el programa correspondiente a la COLA que se ha visto en
clase creando un menú que contemple las siguientes opciones:
1. Cola llena
2. Cola vacía
3. Insertar
4. Eliminar
5. Recorrido
6. Salir
• Nota: Cada vez que se desee eliminar un elemento debe verificarse la cantidad
que se desea eliminar: si es menor al valor del elemento en la parte delantera
de la cola deberá restarse pero sin eliminar el elemento; si es mayor debe
eliminarse y el faltante restarlo del siguiente elemento en la cola a manera de
un inventario de almacén.

48. Bibliografía
• Joyanes, Zahonero. Estructura de Datos en C++. McGraw Hill. Madrid, España.
2007. ISBN: 978-84-481-5645-9.