Estructuras de Datos Especificación formal de Listas

Una lista es un conjunto de componentes estándar (stdelement) con estructura lineal no cíclica Lista Stdel 2Stdel 1Stdel 3

Especificación del Tipo de Datos Lista Caracterización: Agregado iterado con componentes stdelement Dominio: Agregado iterado con n (n>= 0, n  entero) componentes de tipo stdelement Estructura de Composición: –Aridad: Lineal –No cíclica Componentes: Conjunto de elementos estándar stdelement (objetos con campo clave o con clave derivada a partir de otros campos).

Características de la Estructura: Hay una relación no reflexiva dirigida entre los elementos, denominada “sucesor” Si n>0, hay un elemento que no es sucesor de ningún otro y se denomina “primero”. Si n>0 hay un elemento que no tiene sucesor y se denomina “último”. Todos los demás tienen un sucesor diferente a ellos y son el sucesor de otro diferente a ellos.

Definiciones 1/2 Primero: Elemento de la lista que no es sucesor de ningún otro. Último: Elemento de la lista que no tiene sucesor. eeSiguiente de e: Elemento sucesor de e. eeAnterior a e: Elemento del que e es el sucesor. eeCamino a e: Lista de los antecesores a e bajo la relación “sucesor”. Actual: El elemento señalado en la lista por el cursor Cursor: Posición del elemento señalado en la lista. Lista vacía: Lista con n = 0: {NULL}. Lista no vacía: {e 1,e 2,...,e n }

Definiciones 2/2 Adelante: Relación dirigida entre e  E y e’  E y e’  e. e’ está delante de e si se cumple cualquiera de las siguientes 2 condiciones: –1: e’ = siguiente(e)  e’ = adelante(e) –2: (  e”  E / (e” = adelante(e)  e’ = siguiente(e”))  e’ = adelante(e) Atrás: Relación dirigida entre e  E y e’  E y e’  e: e está atrás de e’ si se cumple: –1: e’ = adelante(e)  e = atras(e’) Posición de e: |{e’: e’  E / e’ = atrás(e)}| + 1

Operaciones Definición de variables: L: una lista. Cursor: entero, posición del elemento señalado. POF: una lista. PRF: una lista. e: un elemento del tipo del componente (stdelement). a: un elemento del tipo del componente (stdelement). n: un entero (el tamaño de la lista) n = tamaño(L). k: una clave del tipo de la clave del componente. t,i,p: Enteros. b: booleano

L = L.nueva_lista(): Crea la lista L vacía. PRE:  L POST:  L  L = {NULL}  Cursor = 0 L.destruir_lista(*L): Destruye la lista L. PRE: L = {NULL} POST:  L I) I) Operaciones de Creación y Destrucción

II) II) Operaciones Consultoras n= L.tamaño(): Tamaño de la lista. PRE:  L  L = {e,POF} POST: n = 1 + tamaño(POF) PRE:  L  L = {NULL} POST: n = 0 e = L.actual(): Recupera el elemento actual. PRE:  L  L = {PRF,a,POF}  tamaño(PRF) = Cursor – 1 POST: e = a

b= L.existe(k): ¿Existe el elemento de clave k en L?. PRE:  L  L = {e,POF} POST: if(clave(e) = k) b = true else existe(POF,k) PRE:  L  L = {NULL} POST: b = false t = L.posicion(e): Devuelve la posición de e. PRE:  L  L = {PRF,e,POF} POST: t = tamaño(PRF)+1

p= L.pos_clave(k): Retorna la posición del elemento con clave k. PRE:  L  L = {PRF, e} POST: if(clave(e) = k) p = tamaño(PRF) + 1 else pos_clave(PRF, k) PRE:  L  L = {NULL} POST: p = 0

III) III) Operaciones de Navegación L.a_primero(): Coloca el cursor en el primer elemento de L. PRE:  L  L  {NULL} POST: Cursor = 1 L.a_ultimo(): Coloca el cursor en el último elemento de L. PRE:  L  L  {NULL} POST: Cursor = n

L.a_anterior(): Se sitúa en el elemento anterior al actual. PRE:  L  L  {NULL}  i = Cursor POST: if( i = 1){Cursor = i} else {Cursor = i – 1} L.a_siguiente(): Se sitúa en el elemento siguiente al actual. PRE:  L  L  {NULL}  i = Cursor POST: if(i = n){Cursor = i} else{Cursor = i + 1}

L.a_iesimo(t): Se sitúa en el t-ésimo elemento. PRE:  L  L  {NULL}  i = Cursor POST: if(t n){Cursor = i} else {Cursor = t} L.a_clave(k): Se sitúa en el elemento de clave k. PRE:  L  L  {NULL}  i = Cursor POST: if(existe(L, k)){Cursor = pos_clave(L, k)} else {Cursor = i}

IV) IV) Operaciones de Inserción y Borrado L= L.inserte_antes(e): Inserta e antes del actual. PRE:  L  L = {PRF,a,POF}  actual(L) = a  tamaño(PRF) = Cursor-1  i = Cursor  ¬existe(L, clave(e)) POST: L = {PRF, e,a, POF}  Cursor = i PRE:  L  L = {NULL} POST: L = {e}  Cursor = 1

L= L.inserte_despues(e): inserta e después del actual. PRE:  L  L = {PRF,a,POF}  actual(L) = a  tamaño(PRF) = Cursor – 1  i = Cursor ¬existe(L, clave(e)) POST: L = {PRF,a,e,POF}  Cursor = i + 1 PRE:  L  L = {NULL} POST: L = {e}  Cursor = 1

L= L.borre(): borra el actual. PRE:  L  L = {PRF,a,POF}  a = actual(L)  tamaño(PRF) = Cursor – 1  i = Cursor POST: L = {PRF,POF}  if(PRF  {NULL}) Cursor = i – 1 else if(POF  {NULL}) Cursor = i else Cursor = 0

V) V) Operaciones de Actualización L.actualize(e): Cambia el elemento actual por otro (siempre y cuando tenga la misma clave) PRE:  L  L = {PRF,a,POF}  a = actual(L)  tamaño(PRF) = Cursor – 1  clave(a) = clave(e) POST: L = {PRF,e,POF}

Pilas Los stacks (pilas) son listas cuyo comportamiento obedece a la disciplina LIFO (last in, first out) esto significa que el último elemento en entrar es el primero en salir. Ej: Pila de bandejas en una cafetería. Su especificación se diferencia de las listas en las funciones de inserción y borrado de componentes

Especificación pila Operaciones de inserción y borrado. L.push(e:stelement): Inserta e después del último elemento insertado. PRE:  L  L  {NULL}  L = {PRF}  tamaño(L) = n  ¬existe(L, clave(e)) POST: L = {PRF,e}  tamaño(L) = n + 1 PRE:  L  L = {NULL} POST: L = {e}  n = 1 L.pop(): borra el elemento recientemente insertado. PRE:  L  L = {PRF, e}  tamaño(L) = n POST: L = {PRF}  tamaño(L) = n – 1

Colas Las colas son listas que exhiben un comportamiento FIFO (first in, first out). Los elementos pueden ser adicionados a la cola uno tras otro, sin embargo el único elemento que puede ser retirado es el que ha permanecido más tiempo almacenado en la cola. Ej: Una fila en un supermercado Al igual que las pilas su especificación se diferencia de las listas en las funciones de inserción y borrado de componentes

Especificación Cola Operaciones de inserción y borrado. L.enqueue(e:stelement): Inserta e después del último elemento insertado. PRE:  L  L  {NULL}  L = {PRF}  tamaño(L) = n  ¬existe(L, clave(e)) POST: L = {PRF,e}  tamaño(L) = n + 1 PRE:  L  L = {NULL} POST: L = {e}  n = 1 L.serve(): borra el elemento menos recientemente insertado. PRE:  L  L = {e, POF}  tamaño(L) = n POST: L = {POF}  tamaño(L) = n – 1