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