Ingeniería en Sistemas ComputacionalesEstructura 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.

Competencia de la Unidad

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

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.

LISTAS ENLAZADAS

• 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.

• 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.

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”).

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”).

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”).

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”).

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

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

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 nodoAsignar la información al campo correspondienteAsignar NULL a la variable apuntador

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 colaSINO 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 trabajoFINSI

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 DatosApunta a NULL el nuevo nodo

Enlaza el nodo anterior al nuevo

Asigna nodo cola

RECORRER LA LISTA DESDE EL INICIO• Algoritmo de recorrido

Igualar nodo de trabajo a nodo cabezaMIENTRAS nodo de trabajo != Nulo Imprimir datos del nodo Nodo de trabajo = siguiente nodoFINMIENTRAS

• Código en C++

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 apuntadorSINO reservar memoria y crear nuevo nodo asignar datos al campo correspondiente enlazar el nodo actual con el nodo cabeza igualar nodo cabeza al nodo actualFINSI

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

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 FINSIFINSI

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

• 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

PILAS

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.

• 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.

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.

• 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.

• 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.

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

Estatus de las PILAS

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

VERIFICAR SI LA PILA ESTA LLENA

AlgoritmoFUNCION boolena llena() SI (tope == maximo – 1) regresar verdadero SINO

regresar falso FINSIFINFUNCION

VERIFICAR SI LA PILA ESTA VACIA

AlgoritmoFUNCION boolena vacia() SI (tope == – 1) regresar verdadero SINO

regresar falso FINSIFINFUNCION

INSERTAR ELEMENTO EN LA PILA

AlgoritmoMODULO insertar() { SI LA PILA ESTA LLENA MOSTRAR “Pila llena” SINO CAPTURAR ELEMENTO INCREMENTAR tope EN 1 pila[tope]=ELEMENTO; FINSIFINMODULO

ELIMINAR ELEMENTO EN LA PILA

AlgoritmoMODULO eliminar() { SI LA PILA ESTA VACIA MOSTRAR “Pila Vacia” SINO MOSTRAR CONTENIDO ELIMINAR ELEMENTO DECREMENTAR TOPE EN 1 FINSIFINMODULO

RECORRIDO DE UNA PILA

AlgoritmoMODULO recorrer() { DECLARAR var de trabajo SI LA PILA ESTA VACIA MOSTRAR “Pila Vacia” SINO MIENTRAS var<=tope MOSTRAR CONTENIDO INCREMENTAR var en 1 FINMIENTRAS FINSIFINMODULO

• Ejercicio: Desarrolle el programa correspondiente a la PILA que se ha visto en clase creando un menú que contemple las siguientes opciones:

1. Pila llena2. Pila vacía3. Insertar4. Eliminar 5. Recorrido6. Terminar

• Entregar el programa en código para revisión

COLAS

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).

COLAS DINÁMICAS CON NODOS

Parte Delantera o

SalidaParte

Posterior o Entrada

COLAS ESTÁTICAS CON ARRAYSParte

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)

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

ALGORITMO PARA DETERMINAR SI LA COLA ESTÁ LLENA

FUNCION BOLEANA llena () SI (final >= maximo - 1 ) ENTONCES REGRESAR verdadero SINO

REGRESAR falso FINSIFINFUNCION

ALGORITMO

ALGORITMO PARA DETERMINAR SI LA COLA ESTÁ VACIA

FUNCION BOLEANA vacia () SI (final < 0) ENTONCES REGRESAR verdadero SINO

REGRESAR falso FINSIFINFUNCION

ALGORITMO

ALGORITMO PARA INSERTAR ELEMENTO EN LA COLA

MODULO insertar(DATO) SI (llena) ENTONCES IMPRIME “cola llena” SINO incrementar final cola[final]=DATO FINSIFINMODULO

ALGORITMO

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 finalFINMODULO

ALGORITMO

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

FINSIFINMODULO

ALGORITMO

• Ejercicio: Desarrolle el programa correspondiente a la COLA que se ha visto en clase creando un menú que contemple las siguientes opciones:

1. Cola llena2. Cola vacía3. Insertar4. Eliminar 5. Recorrido6. 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.

Bibliografía

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