Estructuras de Datos

ContenidoListas............................................................................................................................................................1

¿Qué objetos se pueden modelar con una lista?.....................................................................................1

Definiendo una lista.................................................................................................................................1

TAD para representar una lista................................................................................................................1

Relacionando el concepto de “Ventana” con el de “Lista”......................................................................1

Describiendo las implementaciones de Listas.........................................................................................1

Vectores...............................................................................................................................................1

Listas doblemente enlazadas...............................................................................................................1

Mecanismos para implementar las listas en diferentes lenguajes..........................................................1

Pilas.............................................................................................................................................................1

¿Qué objetos se pueden modelar con una pila?.....................................................................................1

Definiendo una pila.................................................................................................................................1

TAD para representar una pila.................................................................................................................1

Mecanismos para implementar las pilas a través de listas y vectores.....................................................1

Cola..............................................................................................................................................................2

¿Qué objetos se pueden modelar con una cola?.....................................................................................2

Definiendo una cola.................................................................................................................................2

TAD para representar una cola................................................................................................................2

Particularidades de una cola con prioridades..........................................................................................2

Describiendo las implementaciones de colas con vectores circulares.....................................................2

Listas

¿Qué objetos se pueden modelar con una lista? Los ingredientes de una receta de cocina Los integrantes de una junta de vecinos Las partes de un aparato electrónico

Definiendo una lista En ciencias de computación, una lista o secuencia es un tipo de datos abstracto que se

implementa como una colección ordenada de valores, donde el mismo valor puede ocurrir más de una vez. Una instancia de lista es una representación del concepto matemático de secuencia finita. (http://en.wikipedia.org/wiki/List_(abstract_data_type)

Matemáticamente, una lista es una sucesión finita de cero, uno o más elementos del mismo tipo. Desde el punto de vista de las estructuras de datos, una lista es un conjunto finito de elementos, en el que para acceder a uno de ellos hay que pasar por todos los situados antes que Él. Una lista es, por lo tanto, una estructura de datos secuencial.(http://ocw.upm.es/ciencia-de-la-computacion-e-inteligencia-artificial/fundamentos-programacion/contenidosteoricos/ocwfundamentosprogramaciontema11.pdf)

TAD para representar una lista

Invariante: n > i >= p Resumen de Operaciones:

o crear: nil → Listao combinar: Lista x Lista → Listao dividir: Lista, int, bool → Lista, Listao truncar: Lista, int → Listao insertar: Nodo → Listao remover: Nodo → Listao siguiente: Nodo → Nodoo inicio: Lista → Nodo

o fin: Lista → Nodoo cantElem: Lista → int

Detalle de Operaciones:

Lista crear ()/*Construye una nueva lista */{Pre: -}{Post: crear es una lista con un solo nodo}

Lista combinar (Lista lst1, Lista lst2)/*Combina ambas listas en una sola, concatenando el último elemento de lst1 con el primero de lst2 */{Pre: l1 y l2 son listas no vacías}{Post: combinar es una lista que contiene todos los elementos de lst1 y lst2}

Lista dividir (Lista lst, int x, Boolean orientación)/*Remueve todos los elementos a partir del nodo X de lst y retorna una nueva lista con dichos elementos. Orientación define como se realiza la operación: si es TRUE se toman los elementos a la derecha de X, y viceversa */{Pre: N> x >= P, donde P es el índice del nodo inicial y N es el nodo final}{Post: dividir es una lista que contiene los elementos de lst a partir de X}

Lista truncar (Lista lst, int x)/*Remueve los elementos de lst a partir del nodo x*/{Pre: N> x >= P, donde P es el índice del nodo inicial y N es el nodo final}{Post: truncar es una lista que contiene X-P elementos}

Void insertar (Lista lst, Nodo n)/*Inserta un nuevo nodo al final de la lista*/{Pre:}{Post: lst[p] = n}

Nodo siguiente (Nodo n1)/*Devuelve el nodo que le sigue a n1 en la lista */{Pre: n1!= lst[p]}{Post: -}

Nodo inicio (Lista lst)/*Devuelve el nodo inicial de lst*/{Pre: lst es una lista no vacía}{Post: inicio es el nodo raíz de lst}

Nodo fin (Lista lst)/*Devuelve el ultimo nodo de la lista*/{Pre: lst es una lista no vacía.}{Post: fin es el último nodo de la lista}

Int cantElem (Lista lst)/*Devuelve la cantidad de nodos en lst*/{Pre: -}{Post: -}

Relacionando el concepto de “Ventana” con el de “Lista”

Imagine que está leyendo un libro. Usted abre el libro en la primera pagina, continua con la siguiente; se da cuenta que olvido leer algo y se devuelve al anterior. No es factible para usted leer más de una página a la vez, ¿verdad? A pesar de que el libro contiene decenas, tal vez cientos o miles de páginas, usted solo puede enfocarse en una a la vez.

Ahora imaginemos que el libro contiene una lista de páginas. De esa lista, usted solo lee una a la vez. La ventana de Libro<pagina> seria: pagina_actual. En otras palabras, la ventana en una lista es el elemento actual que estamos examinando. Por lo tanto, pasar la página implicaría mover la ventana.

La dirección de este movimiento, depende del tipo de lista que tengamos: para una lista doblemente enlazada, es una operación trivial moverse tanto para la izquierda (anterior) como para la derecha (siguiente); para una lista simplemente enlazada, moverse hacia la derecha es igualmente sencillo, pero moverse a la izquierda es complicado, ya que cada nodo solo conoce su sucesor, no su antecesor.

Describiendo las implementaciones de Listas

Vectores

En Java, las funcionalidades del vector están contenidas en la clase ArrayList. Hay una clase Vector pero su uso no es aconsejable. Un ArrayList es una estructura de datos que no se basa en nodos para el almacenamiento de la información, sino que internamente guarda punteros a cada uno de los elementos en un arreglo.

Esto permite que el acceso a los elementos sea indizado, óseo, que acceder al elemento <N> de un ArrayList es algo trivial; sin embargo, la debilidad de esta estructura es que si el arreglo se llena, es necesario copiar todo su contenido en otro arreglo de mayor tamaño y liberar el espacio de memoria ocupada por el arreglo anterior. Otro inconveniente es la inserción de elementos en el en el en otra posición que no sea al final ya que esta operación requiere la modificación de gran parte del arreglo.

Listas doblemente enlazadas

Esta es la otra implementación de la interfaz Lista en Java, que si utiliza nodos como unidades básicas de persistencia. Estos permiten que la lista no tenga límite teórico de crecimiento, simplemente se sigue agregando el nuevo nodo al final y se actualizan las referencias a este. La desventaja está en la lectura, ya que para leer el elemento <N> se necesita atravesar N elementos.

Mecanismos para implementar las listas en diferentes lenguajes C++: La librería de tipos estándar de C++ (STL) incluye una implementa la interfaz Lista con listas

doblemente enlazadas. El formato es:

C#: El namespace System. Collections incluye 3 implementaciones de lista: o List<t>:

Se comporta Como un vector, utilizando un arreglo para proporcionar los servicios de lista.

o LinkedList<t>: Se comporta Como una lista enlazada, utilizando nodos para almacenar los datos.

o SortedList<k, t>: Como su nombre lo indica, es una lista de elementos del tipo T, que se ordenan en base a la comparación valor de la clave K. En este caso la inserción es más lenta, ya que debe comparar los valores de las claves para ver donde insertar el nuevo nodo, pero la lectura es trivial ya que todos los nodos están ordenados.

Java: Implementa ArrayList y LinkedList. Vector también implementa la interfaz de lista, pero su uso no es recomendado en nuevas implementaciones. Estas implementaciones, y otras mas están contenidas en el paquete java.Util.Collections

Pilas

¿Qué objetos se pueden modelar con una pila?Supongamos que está atrapado en un laberinto cualquiera (Ya sea el laberinto del mino tauro, en Creta, o un callejón de Gualey, usted decide). Al llegar a un punto muerto, ¿Qué hará? Devolverse, lógicamente. Pero, ¿Hacia dónde? Pues hacia el último punto de divergencia. Esto se puede modelar como una pila donde colocamos (push) puntos y al encontrar un punto muerto, retrocedemos (pop) al primer punto de la pila.

Igualmente, supongamos que estas realizando una presentación para cierta clase de Estructuras de Datos en MS Word. Sin darte cuenta, has seleccionado todo el texto, y has presionado la tecla “Borrar”. ¿Qué haces? No hay problema, haces un Ctrl + Z y listo, ¿Verdad? Esa funcionalidad se implementa con una pila. El programa va colocando cada estado en una pila, y cuando “deshacemos” simplemente hacemos un “pop()” a la pila.

Igual el caso si quisiéramos por ejemplo, invertir una palabra. La agregamos carácter por carácter a la pila y luego la retornamos con Pop() en orden inverso.

13 + 21 * 5 = 170/118Vs.

13 21 + 5 * = 170

De hecho, las pilas son una importantísima herramienta en el análisis lexicográfico; los compiladores la utilizan para por ejemplo, encontrar las llaves que encierran un enunciado en el código fuente; o para evaluar expresiones matemáticas escritas utilizando una notación “in-fix” cambiándolas por una notación “post-fix” .

Definiendo una pilaUna pila o Stack es una estructura linear de datos, en la que el último en llegar es el primero en salir. Esta estructura también se conoce como LIFO, del inglés (Last In First Out).

Las dos operaciones más importantes de una pila son:

- Push, coloca un nuevo objeto en el tope de la pila- Pop, lee el primer elemento de la pila. Al leerlo, este elemento es eliminado de la pila, siendo

reemplazado por su anterior.

En todo momento, el único elemento visible de la estructura es el último que se colocó. Se define el tope de la pila como el punto donde se encuentra dicho elemento, y el fondo, como el punto donde se encuentra el primer elemento incluido en la estructura

TAD para representar una pila

- Invariante: Cantidad de elementos <= 0- Operaciones:

o crearPila Pila → Pilao push Elemento → Pilao pop Pila → Elementoo cantElem Pila → Entero

Mecanismos para implementar las pilas

Una pila puede implementarse tanto con una Lista como con un vector. Si utilizamos una lista, entonces estaríamos insertando / leyendo constantemente elementos al final de la lista, lo que en el caso de una Lista enlazada es algo trivial, ya que no se necesita recorrer la lista.

En el caso del vector, como siempre la limitación esta en el hecho de que las constantes rea locaciones para obtener más espacio disponible pueden convertirse en un problema.

Las operaciones Push () y Pop () deben tener una complejidad Constante de O(1), sin importar que mecanismos se utilicen para implementarla.

Cola

¿Qué objetos se pueden modelar con una cola?Considere el caso de un banco donde usted se dirige un día primero de cualquier mes a realizar el cambio del cheque de su salario. Al entrar al establecimiento se encuentra que decenas de personas están presentes para realizar la misma operación, pero la cantidad de cajeros es limitada. ¿Qué sucede? Se organizan en una fila, por orden de llegada. El primero en llegar (o el más vivo, dependiendo de qué país de trate) está en la primera posición y es despachado primero.

Esta situación se aplica bastante en la vida diaria: Al ir a un baño público, al esperar en la fila del supermercado, al esperar el autobús; Recursos en los que es necesario regular el acceso al mismo, debido a que son limitados.

En la informática se dan muchos casos de colas:

o Las colas de impresión.o Las colas de prioridades para los procesos en el CPUo Las colas de acceso a archivoso Las colas de despacho en los dispositivos de acceso a la red

Definiendo una colaUna cola es lo inverso a una pila; una estructura linear de datos donde el primero en llegar, es el primero en salir (FIFO), o lo que es lo mismo, el último en llegar, es el último en salir (LILO).

Los métodos más importantes de una cola son:

- Enqueue: coloca un elemento al final de la cola- Dequeue: remueve el primer elemento de la cola

TAD para representar una cola

- Invariante: Cantidad de elementos >= 0- Operaciones: - crearCola Cola → Cola- enqueue Elemento → Cola- dequeue Cola → Elemento- cantElem Cola → Entero

Describiendo las implementaciones de colas con vectores circularesUna cola circular es aquella en la que el último elemento de la cola hace referencia al primero.

En el caso de una lista, esto no supone mayores complicaciones, pero si se utiliza un array debe de aplicarse una matemática especial para los índices.

Referencias:

http://www.cs.cmu.edu/~adamchik/15-121/lectures/Stacks%20and%20Queues/Stacks%20and%20Queues.html

http://cupi2.uniandes.edu.co/libros/estructuras_de_datos/index.php?option=com_content&view=article&id=217&Itemid=68