Diseño de Pilas y Colas

Transcripción

1 Diseño de Pilas y Colas

2 Recordamos qué era una Pila? TAD Pila(α) Observadores básicos vacía?: pila(α) bool tope: pila(α) p α (~ vacía?(p)) Generadores vacía: pila(α) apilar: α pila(α) pila(α) Otras Operaciones desapilar: pila(α) p pila(α) (~ vacía?(p)) tamaño: pila(α) nat =pila : pila(α) pila(α) bool

3 Representación de Pilas con Arreglos Pila(α) se representa con tupla<p:arreglo(α) x tope:nat> Invariante de representación: 0 <= tope <= tam(p) Función de abstracción: ABS([p 1,p 2,...,p tam(p) ],0) = vacía (p i NAT U {indefinido}, i=1..tam(p)) ABS([p 1,p 2,...,p tam(p) ], tope) = apilar (p tope,abs ([p 1,p 2,...,p tam(p) ], tope-1) (p i NAT, i=1..tope, p i NAT U {indefinido}, i=tope+1..tam(p))

4 Representación de Pilas con Arreglos O sea... Los elementos de la pila están en el arreglo, entre la posición 1 y la posición tope, ordenados por orden de llegada y p[tope] es el tope de la pila. P i Pila Vacía P i tope = i P 2 P 1 P 2 P 1 Pila no Vacía tope = 0

5 Representación de Pilas con Arreglos Idea de los Algoritmos Vacía: crear un arreglo, con tope=0 Apilar elemento: incrementar tope (previa verificación de que tope< tam(p)), p[tope] elemento Tope: p[tope] Desapilar: if tope<>0 then tope tope-1 Tamaño: tope Análisis de complejidad: Tiempo: suponiendo que las operaciones de asignación al arreglo, y las operaciones de incrementar, decrementar y comparar un NAT con 0 llevan tiempo constante, todas las operaciones llevan tiempo constante Memoria: Una pila que contendrá como máximo n elementos requiere espacio proporcional a n.

6 Representación de Pilas con Listas Encadenadas Pila(α) se representa con lista(α) o... Pila(α) se representa con puntero a nodo(α), donde nodo(α) es tupla<valor: α, siguiente: puntero a nodo(α) Invariante de representación: En finitos pasos se llega a nil (o sea, es una lista!) Función de abstracción: ABS(nil) = vacía ABS(a) = apilar (a.valor,abs(a.siguiente))

7 Representación de Pilas con Listas Encadenadas O sea... Start Los elementos de la pila están en la lista, ordenados por orden inverso al de llegada, o sea el primer elemento de la lista es el tope de la pila. Por ejemplo: P N-1 P N-2 P i P 0

8 Representación de Pilas con Listas Encadenadas Idea de los Algoritmos Vacía: crear una lista vacía Apilar elemento: agregar un elemento a la secuencia Tope(p): p^.valor (primer elemento de la secuencia) Desapilar(p): if not vacía? then p ^.siguiente Y Tamaño? Análisis de complejidad: Tiempo: suponiendo que las operaciones de asignación de creación y asignación de punteros, y las de asignación del tipo base llevan tiempo constante, todas las operaciones llevan tiempo constante...salvo Tamaño! Alguna idea? Memoria: Una pila que contiene n elementos requiere espacio proporcional a n.

9 Recordamos qué era una Cola? TAD Cola(α) Observadores básicos vacía?: cola(α) bool próximo: cola(α) c α ( ~vacía?(c)) Generadores vacía: cola(α) encolar: α cola(α) cola(α) Otras Operaciones desencolar: cola(α) c cola(α) (~vacía?(c)) longitud: cola(α) nat =cola : cola(α) cola(α) bool

10 Representación de Colas con Arreglos Cola(α) se representa con tupla<p:arreglo(α) x prox:nat x ult:nat> Invariante de representación: 0 <= prox,ult <= tam(p) Función de abstracción: ABS([p 0,p 1,...,p tam(p)-1 ], n+1,n) = vacía (p i NAT U {indefinido}, i=1..tam(p)) ABS ([p 0,p 1,...,p tam(p)-1 ], n,m) = encolar (p m,abs ([p 0,p 1,...,p tam(p)-1 ], n,m-1) (si n m, p i NAT, i=n..m, pi NAT U {indefinido}, i=0..n-1 e i=m+1..tam(p), si n>m+1, p i NAT, i=n.. tam(p) e i=0..m p i NAT U {indefinido}, i=m+1..n-1)

11 Representación de colas con Arreglos O sea... Los elementos de la cola están en el arreglo, entre la posición prox y la posición ult, ordenados por orden de llegada y p[prox] es el próximo de la cola. P 0 P 1 P 2 P K-3 P K-2 P K-1 Elemento no usado K=tam(p) prox ult

12 Representación de Colas con Arreglos Idea de los Algoritmos Vacía: crear un arreglo, con prox=ult+1 Encolar elemento: incrementar ult módulo tam(p) (previa verificación de que tope < ult-1), p[ult] elemento próximo: p[prox] Desencolar: if prox<>ult then prox prox+1 Longitud: prox-ult+1 Análisis de complejidad: Tiempo: suponiendo que las operaciones de asignación al arreglo, y las operaciones de incrementar, decrementar y comparar un NAT con 0 llevan tiempo constante, todas las operaciones llevan tiempo constante Memoria: Una cola que contendrá como máximo n elementos requiere espacio proporcional a n.

13 Representación de Colas con Listas Encadenadas Cola(α) se representa con tupla<prox: puntero a nodo(α), ult: puntero a nodo (α) > donde nodo(α) es... Invariante de representación: Igual que antes... y además prox<>nil ult^.siguiente=nil Función de abstracción: ABS(<prox, ult>)= if prox=nil then cola_vacía() else c donde ~vacía(c) L próximo(c)=prox^.valor L desencolar(c)=abs(<prox^.siguiente, ult>)

14 Representación de Colas con Listas Encadenadas O sea... prox Los elementos de la pila están en la lista, ordenados por orden de llegada, el primer elemento de la lista es el próximo de la cola, y el último de la lista es el último de la cola. ult P N-1 P N-2 P i P 0

15 Representación de Colas con Listas Encadenadas Idea de los Algoritmos Vacía: crear una lista vacía Encolar: agregar un elemento al final de la secuencia prox: primer elemento de la secuencia (prox^.valor) Desencolar: if not vacía? then <prox^.siguiente, ult> Y longitud? Análisis de complejidad: Tiempo: suponiendo que las operaciones de asignación de creación y asignación de punteros, y las de asignación del tipo base llevan tiempo constante, todas las operaciones llevan tiempo constante...salvo longitud. Alguna idea para mejorar eso? Memoria: Una cola que contiene n elementos requiere espacio proporcional a n.