TIPOS ABSTRACTOS DE DATOS 2 TIPOS ABSTRACTOS DE

TIPOS ABSTRACTOS DE DATOS

2 TIPOS ABSTRACTOS DE DATOS þ Un Tipo Abstracto de Dato (TAD) es un modelo constituido por un conjunto de objetos y una colección de operaciones realizables sobre ellos þ Los lenguajes procedimentales no contemplan encapsulamiento, razón por la cual la representación (datos) no es exclusiva de la implementación (operaciones)

3 TIPOS ABSTRACTOS DE DATOS þ Los lenguajes modulares proveen encapsulamiento, exclusividad de la implementación sobre la representación, pero no instanciación þ Los lenguajes orientados a objetos proveen encapsulamiento, exclusividad de la implementación sobre la representación e instanciación

4 STACKS (PILAS) þ Un stack es un TAD de comportamiento LIFO, con las operaciones create, push, pop y empty þ En un stack sólo se puede acceder a uno de sus extremos, el cual se denomina top þ La operación push pone un elemento en el top del stack y la operación pop saca el elemento situado en el top del stack

5 LA CLASE STACK #define MAX 10 typedef int Base; typedef Base Vector[MAX]; class Stack { private: Vector v; int top; public: Stack(); bool Empty(); void Push(Base); Base Pop(); };

6 LA CLASE STACK Stack: : Stack() { top = -1; } bool Stack: : Empty() { return top == -1; } void Stack: : Push(Base e) { v[++top] = e; } Base Stack: : Pop() { return v[top--]; }

7 LA CLASE STACK Ejercicio Implementar la función Ultimo(S), que elimina y retorna el último elemento existente en un stack S. Base Ultimo(Stack &S) { if(!S. Empty()) { Base x = S. Pop(); if(!S. Empty()) { Base y = Ultimo(S); S. Push(x); return y; } else return x; } else return 0; }

8 QUEUES (COLAS) þ Una cola es un TAD de comportamiento FIFO, con las operaciones crear, agregar, extraer y vacía þ En una cola sólo se puede acceder a uno de extremos, denominado rear, para agregar un elemento y al otro, denominado front, para extraer un elemento

9 LA CLASE COLA #define MAX 10 typedef int Base; typedef Base Vector[MAX]; class Cola { private: Vector v; int front; int rear; public: Cola(); bool Vacia(); void Agregar(Base); Base Extraer(); };

10 LA CLASE COLA Cola: : Cola() { front = 0; rear = 0; } bool Cola: : Vacia() { return front == rear; } void Cola: : Agregar(Base e) { rear = (rear+1)%MAX; v[rear] = e; } Base Cola: : Extraer() { front = (front+1)%MAX; return v[front]; }

11 LA CLASE COLA Ejercicio Refleja es una cola con los mismos elementos de una cola Directa, pero en orden inverso. Implementar la función Reflejar(R, D), que concluya con las versiones Directa y Refleja de una cola. void Reflejar(Cola &R, Cola &D) { if(!R. Vacia()) { Base x = R. Extraer(); D. Agregar(x); Reflejar(R, D); R. Agregar(x); } }

12 PRIORITY QUEUES þ Una cola de prioridad es una cola cuyos elementos tienen asociada una prioridad que determina el orden en que son extraídos þ Una prioridad es un número entre 1 y p, donde 1 es la prioridad más alta þ En una cola de prioridad, se puede agregar un elemento de cierta prioridad, o bien, extraer el elemento de máxima prioridad

13 HEAPS þ El heap es el caso más notable de cola de prioridad y se define como un árbol binario con todos sus niveles completos excepto, generalmente, el último donde todos los nodos están ajustados a la izquierda þ Cada nodo en un heap tiene mayor prioridad que sus descendientes, de manera que el elemento de prioridad máxima se encuentra siempre en la raíz del árbol

14 HEAPS þ Los elementos se ingresan por nivel, de izquierda a derecha þ Después de un ingreso se debe reparar la eventual alteración de la propiedad de heap þ Debido a la forma de organización del árbol, se puede usar un arreglo para representarlo. Basta con numerar los nodos consecutivamente por nivel, de arriba hacia abajo y de izquierda a derecha

15 HEAPS þ Representación de árbol Salen 5 10 15 40 45 20 55 35 30 60 25 Entran

16 HEAPS þ Numeración de nodos 1 2 3 4 8 5 9 10 6 7

17 HEAPS þ Representación de arreglo 0 v: 1 5 2 3 10 15 4 5 40 20 6 7 30 25 8 45 9 10 55 35 Salen Entran þ El padre de un elemento v[i] es v[j], con j=i/2 þ Un elemento v[j] tiene hijos v[i] y v[i+1], con i= 2*j

18 LA CLASE HEAP #define MAX 10 typedef int Base; typedef struct Elemento { int p; Base info; }; typedef Elemento Vector[MAX];

19 LA CLASE HEAP class Heap { private: Vector v; int n; void Subir(); void Bajar(); public: Heap(); bool Vacio(); void Agregar(Elemento); Elemento Extraer(); };

20 LA CLASE HEAP void Heap: : Subir() { if(n > 1) { int i=n, k=i/2; v[0]. p = v[n]. p; v[0]. info = v[n]. info; while (v[k]. p > v[0]. p && k > 0) { v[i]. p = v[k]. p; v[i]. info = v[k]. info; i = k; k = i/2; }; v[i]. p = v[0]. p; v[i]. info = v[0]. info; } }

21 LA CLASE HEAP void Heap: : Bajar() { int k=1, i=2*k, fin=0; v[0]. p = v[1]. p; v[0]. info = v[1]. info; while (k <= n/2 && !fin) { if (i < n) if (v[i+1]. p < v[i]. p) i = i+1; if (v[0]. p > v[i]. p) { v[k]. p = v[i]. p; v[k]. info = v[i]. info; k = i; i = k*2; } else fin = 1; } v[k]. p = v[0]. p; v[k]. info = v[0]. info; }

22 LA CLASE HEAP Heap: : Heap() { n = 0; } bool Heap: : Vacio() { return (n == 0); } void Heap: : Agregar(Elemento e) { v[++n]. p = e. p; v[n]. info = e. info; Subir(); }

23 LA CLASE HEAP Elemento Heap: : Extraer() { Elemento e = v[1]; v[1]. p = v[n]. p; v[1]. info = v[n--]. info; Bajar(); return e; }

24 LA CLASE HEAP Ejercicio Implementar la función Impares(H), que elimina todos los elementos de ordinalidad par existentes en un heap H, es decir, los elementos segundo, cuarto, sexto, etc. void Impares(Heap &H) { if(!H. Vacio()) { Elemento e 1 = H. Extraer(); if(!H. Vacio()) Elemento e 2 = H. Extraer(); Impares(H); H. Agregar(e 1); } }