Almacenamiento y recuperacin de informacin Prof Hugo Moncayo

Almacenamiento y recuperación de información Prof. Hugo Moncayo López Cubículo H-294 Tel. 5318 -9532/139 Correo hmoncayo@hp 9000 a 1. uam. mx

Contenido sintético 1. 2. 3. 4. 5. 6. 7. Árbles AVL Grafos y sus aplicaciones Estructuras de archivos Ordenamiento externo Indexación Árboles B y B+ Dispersión

Evaluaciones l l l l Dos evaluaciones periódicas en las semanas 4 y 7 Una evaluación terminal en la semana de evaluaciones globales 8 tareas consistentes el elaboración de programas Calificación: Evaluaciones 60% Tareas 40%

Escala de calificaciones l l NA > 6 S entre 6 y menos de 7 B entre 7 y menos de 8. 5 MB 8. 5 o superior

Bibliografía l l l Folk, M. J. , Zoellick, Bill, Riccardi, Greg. "Fil estructures: an object orientes approach with C++, Addison Wesley Longman, Inc. 1998 Cormen, T. H. , Leiserson, C. E. , Rivest, R. L. , "Introduction to algorithms", Mc Graw Hill, 1998. Knuth, D. E. , "The art of computer programming: Vol. 3 Sorting and searching", Addison-Wesley Publishing Company, Inc. Philipines, 1973. Joyanes, L. "Programación en C++: Algoritmos, estructuras de datos y objetos", Mc. Graw-Hill/Interamericana de España, S. A. U. , 2000 Langsam, Y. , Augenstein, M. , Tenenbaum, A. M. , "Estructuras de datos con C y C++" segunda edición, Prentice-Hall Hispanoamericana, S. A. 1997.

1. - Árboles AVL l Adelson, Velskii, Landis l Son árboles de búsqueda bien balanceados l Permiten inserciones y remociones en tiempo muy eficientes l Mantienen una profundidad de O(log N)

Árboles no balanceados 11 10 5 3 13

Árbol balanceado 10 5 3 13 11

Propiedades de los árboles AVL l Balanceado l En cualquier nodo las alturas de los hijos izquierdo y derecho sólo pueden diferir en uno l Los nodos vacíos tienen altura de – 1 l Las hojas tienen altura de 0 l Los nodos se encuentran ordenados por una llave

Altura de los nodos 10 5 3 1 1 0 2 7 0 3 13 11 0 1

Estructuras de datos para árboles AVL raiz llave altura

Estructuras en C++ class Nodo; class avl{ public: Nodo *raiz; avl() {raiz = 0; } void Rotacion. Simple. Izquierda(); void Rotacion. Simple. Derecha(); . . . }; class Nodo{ public: int llave; int altura; avl izq, der; Nodo(int llave) { this->llave = llave; altura = 0; izq. raiz = 0; der. raiz = 0; } };

Rotación simple por la izquierda this 10 2 beta raiz->izq 5 1 delta 3 0 nil

Rotación simple por la izquierda this void avl: : Rotacion. Simple. Izquierda() { Nodo *t = raiz; 10 2 beta raiz t raiz->izq 5 1 delta 3 0 nil

Rotación simple por la izquierda this 10 2 beta raiz t raiz->izq 5 1 delta 3 0 nil void avl: : Rotacion. Simple. Izquierda() { Nodo *t = raiz; raiz = t->izq. raiz;

Rotación simple por la izquierda this 10 2 delta beta raiz t raiz->izq 5 1 gama delta 3 0 nil void avl: : Rotacion. Simple. Izquierda() { Nodo *t = raiz; raiz = t->izq. raiz; t->izq = raiz->der;

Rotación simple por la izquierda this 10 2 delta beta raiz t raiz->izq 5 1 gama 3 0 nil void avl: : Rotacion. Simple. Izquierda() { Nodo *t = raiz; raiz = t->izq. raiz; t->izq = raiz->der; raiz->der. raiz = t;

Rotación simple por la izquierda this 10 0 delta beta raiz t raiz->izq 5 1 gama 3 0 nil void avl: : Rotacion. Simple. Izquierda() { Nodo *t = raiz; raiz = t->izq. raiz; t->izq = raiz->der; raiz->der. raiz = t; raiz->der. Ajusta. Altura();

Rotación simple por la izquierda this 10 0 delta beta raiz t raiz->izq 5 1 gama 3 0 nil void avl: : Rotacion. Simple. Izquierda() { Nodo *t = raiz; raiz = t->izq. raiz; t->izq = raiz->der; raiz->der. raiz = t; raiz->der. Ajusta. Altura(); }

Rotación simple por la izquierda this void avl: : Rotacion. Simple. Izquierda() { Nodo *t = raiz; raiz = t->izq. raiz; t->izq = raiz->der; raiz->der. raiz = t; raiz->der. Ajusta. Altura(); } raiz->izq 5 1 gama 3 0 nil 10 0 delta beta

Rotación doble 50 20 rotación simple izquierda 20 30 50 30

Rotación doble izquierda this 50 2 alfa raiz->izq 20 1 Subarbol beta 30 0 gama delta alfa > 50 beta < 20 20 < gama < 30 30 < delta < 50

Rotación doble izquierda this void Rotacion. Doble. Izquierda() { raiz->izq. Rotacion. Simple. Derecha(); } 50 2 alfa raiz->izq 30 1 delta 20 0 beta gama Subarbol alfa > 50 beta < 20 20 < gama < 30 30 < delta < 50

Rotación doble izquierda this void Rotacion. Doble. Izquierda() { raiz->izq. Rotacion. Simple. Derecha(); Rotacion Simple. Izquierda(); } raiz->izq 30 1 20 0 beta gama Subarbol 50 0 delta alfa > 50 beta < 20 20 < gama < 30 30 < delta < 50

Grafos

Grafos Un grafo es un conjunto de vértices conectados por líneas llamadas aristas Grafo no dirigido 1 2 3 5 4 6 Grafo dirigido 1 2 3 4 5 G=(V, A)

Representación de grafos Lista de adyacencia 1 2 3 5 4 6 1 2 3 4 5 6 1 1 Matriz de adyacencia 2 1 3 1 4 5 6 2 3 5 1 3 4 1 2 6 1 6 4 3 2 3 1 1 1 4 4 5 6 1 1 1

Representación de grafos Lista de adyacencia 1 2 3 4 2 1 2 3 4 5 4 3 2 2 5 3 6 5 1 1 2 Matriz de adyacencia 4 5 1 1 3 1 4 1 5 3 1 1

Búsqueda primero en amplitud Para cada vertice u en V[G] u. color = blanco u. distancia = infinito u. padre = nil s. color = gris s. distancia = 0 s. padre = nil Q. Inserta. Final(s) Mientras Q no sea vacio u = Q. Extrae. Cabeza() Para cada vertice v en u. adyacencia Si v. color = blanco v. color = gris v. distancia = u. distancia+1 v. padre = u Q. Agrega. Final(v) u. color = negro

Búsqueda primero en aplitud r s t u 0 Q = {s} Q = {} v w x y r s t u 1 0 2 Q = {w, r} v 1 w Q = {r, t, x} x y v 1 w 2 x y

Búsqueda primero en amplitud r s t u r s t 1 0 2 u 3 Q = {x, v, u} Q = {t, x, v} 2 1 2 2 v w x y r s t u 1 0 2 1 v 3 2 w x r s t 1 0 2 y u 3 Q = {u, y} Q = {v, u, y} 2 v 1 w 2 x 3 y

Búsqueda primero en amplitud r s t 1 0 2 u 3 Q = {y} 2 v 1 w 2 x 3 y Q = {} 2 v 1 w 2 x 3 y

Búsqueda primero en amplitud l Funciona para arista unitarias l Calcula la distancia más corta desde el vértice origen a cada uno de los vértices a los que se puede llegar l Se puede aplicar a grafos direccionados o grafos no direccionados l Genera el árbol de rutas mas cortas mediante los predecesores de cada nodo

Implementación Clase deque Constructora: deque<Vertice*> adyacencia; Funciones de acceso: adyacencia. push_back(&Vertice) adyacencia. push_front(&Vertice) adyacencia. begin(); adyacencia. end();

Iterar en los elementos de deque<Vertice*>: : iterator it; for (it = u. adyacencia. begin(); it != u. ady { Vertice *v = *it; }

Búsqueda primero en profundidad l Busca primeramente la máxima profundidad posible en cada ruta l Cuando ha agorado una ruta en lo profundo regresa (backtrack) a los vértices por donde vino para analizar las aristas pendientes

Algoritmo ALGORITMO BPP(G) Para cada vértice u en G. V u. color = BLANCO u. padre = NIL time = 0 Para cada vértice u en G. V Si u. color = BLANCO BPP_Visita(u) ALGORITMO BPP_Visita(u) u. color = GRIS u. distancia = time++ Para cada vértice v en u. Adyacencia Si v. color = BLANCO v. padre = u BPP_Visita(v) u. color = NEGRO u. f = time++

BPP ALGORITMO BPP(G) Para cada vértice u en G. V u. color = BLANCO u. padre = NIL time = 0 Para cada vértice u en G. V Si u. color = BLANCO BPP_Visita(u) ALGORITMO BPP_Visita(u) u. color = GRIS u. distancia = time++ Para cada vértice v en u. Adyacencia Si v. color = BLANCO v. padre = u BPP_Visita(v) u. color = NEGRO u. f = time++ u 0 v 0 w 0 time 0 0 0 x 0 y z u=u(v, x) v=v u v w 1/ 0 0 0 x 0 y 0 z time 1

BPP ALGORITMO BPP(G) Para cada vértice u en G. V u. color = BLANCO u. padre = NIL time = 0 Para cada vértice u en G. V Si u. color = BLANCO BPP_Visita(u) ALGORITMO BPP_Visita(u) u. color = GRIS u. distancia = time++ Para cada vértice v en u. Adyacencia Si v. color = BLANCO v. padre = u BPP_Visita(v) u. color = NEGRO u. f = time++ u 1/ v 0 w 0 time 1 0 x 0 y 0 z x y z u=u(v, x), v(y) v=y w u v 1/ 2/ 0 0 x 0 y 0 z x y z time 2

BPP ALGORITMO BPP(G) Para cada vértice u en G. V u. color = BLANCO u. padre = NIL time = 0 Para cada vértice u en G. V Si u. color = BLANCO BPP_Visita(u) ALGORITMO BPP_Visita(u) u. color = GRIS u. distancia = time++ Para cada vértice v en u. Adyacencia Si v. color = BLANCO v. padre = u BPP_Visita(v) u. color = NEGRO u. f = time++ u v 1/ 2/ w 0 time 2 0 x 0 y 0 z x y z u=u(v, x), v(y), y(x) v=x w u v 1/ 2/ 0 0 x 3/ 0 z x y z time 3

BPP ALGORITMO BPP(G) Para cada vértice u en G. V u. color = BLANCO u. padre = NIL time = 0 Para cada vértice u en G. V Si u. color = BLANCO BPP_Visita(u) ALGORITMO BPP_Visita(u) u. color = GRIS u. distancia = time++ Para cada vértice v en u. Adyacencia Si v. color = BLANCO v. padre = u BPP_Visita(v) u. color = NEGRO u. f = time++ u v 1/ 2/ w 0 time 3 0 x 3/ 0 z x y z u=u(v, x), v(y), y(x), x(v) v=v w u v 1/ 2/ 0 4/ 3/ 0 z x y z time 4

BPP ALGORITMO BPP(G) Para cada vértice u en G. V u. color = BLANCO u. padre = NIL time = 0 Para cada vértice u en G. V Si u. color = BLANCO BPP_Visita(u) ALGORITMO BPP_Visita(u) u. color = GRIS u. distancia = time++ Para cada vértice v en u. Adyacencia Si v. color = BLANCO v. padre = u BPP_Visita(v) u. color = NEGRO u. f = time++ u v 1/ 2/ w 0 4/ 3/ 0 z x y z time 4 u=u(v, x), v(y), y(x), x(v) v=v w u v 1/ 2/ 0 4/5 3/ 0 z x y z time 5

BPP ALGORITMO BPP(G) Para cada vértice u en G. V u. color = BLANCO u. padre = NIL time = 0 Para cada vértice u en G. V Si u. color = BLANCO BPP_Visita(u) ALGORITMO BPP_Visita(u) u. color = GRIS u. distancia = time++ Para cada vértice v en u. Adyacencia Si v. color = BLANCO v. padre = u BPP_Visita(v) u. color = NEGRO u. f = time++ u v 1/ 2/ w 0 4/5 3/ 0 z x y z time 5 u=u(v, x), v(y), y(x), x(v) v= w u v 1/ 2/ 0 4/5 3/6 0 z x y z time 6

BPP ALGORITMO BPP(G) Para cada vértice u en G. V u. color = BLANCO u. padre = NIL time = 0 Para cada vértice u en G. V Si u. color = BLANCO BPP_Visita(u) ALGORITMO BPP_Visita(u) u. color = GRIS u. distancia = time++ Para cada vértice v en u. Adyacencia Si v. color = BLANCO v. padre = u BPP_Visita(v) u. color = NEGRO u. f = time++ u v 1/ 2/ w 0 time 6 4/5 3/6 0 z x y z u=u(v, x), v(y), y(x), x(v) v= w u v 1/ 2/7 0 4/5 3/6 0 z x y z time 7

BPP ALGORITMO BPP(G) Para cada vértice u en G. V u. color = BLANCO u. padre = NIL time = 0 Para cada vértice u en G. V Si u. color = BLANCO BPP_Visita(u) ALGORITMO BPP_Visita(u) u. color = GRIS u. distancia = time++ Para cada vértice v en u. Adyacencia Si v. color = BLANCO v. padre = u BPP_Visita(v) u. color = NEGRO u. f = time++ u v 1/ 2/7 w 0 time 7 4/5 3/6 0 z x y z u=u(v, x), v(y), y(x), x(v) v=x w u v 1/8 2/7 0 4/5 3/6 0 z x y z time 8

BPP ALGORITMO BPP(G) Para cada vértice u en G. V u. color = BLANCO u. padre = NIL time = 0 Para cada vértice u en G. V Si u. color = BLANCO BPP_Visita(u) ALGORITMO BPP_Visita(u) u. color = GRIS u. distancia = time++ Para cada vértice v en u. Adyacencia Si v. color = BLANCO v. padre = u BPP_Visita(v) u. color = NEGRO u. f = time++ u v 1/8 2/7 w 0 time 8 4/5 3/6 0 z x y z u=u(v, x), v(y), y(x), x(v), w(y, z) v=z w u v 1/8 2/7 9/ 4/5 3/6 0 z x y z time 9

BPP ALGORITMO BPP(G) Para cada vértice u en G. V u. color = BLANCO u. padre = NIL time = 0 Para cada vértice u en G. V Si u. color = BLANCO BPP_Visita(u) ALGORITMO BPP_Visita(u) u. color = GRIS u. distancia = time++ Para cada vértice v en u. Adyacencia Si v. color = BLANCO v. padre = u BPP_Visita(v) u. color = NEGRO u. f = time++ u v 1/8 2/7 w 9/ time 9 4/5 3/6 0 z x y z u=u(v, x), v(y), y(x), x(v), w(y, z), z(w, z) v=z w u v 1/8 2/7 9/ 4/5 3/6 10/ x y z time 10

BPP ALGORITMO BPP(G) Para cada vértice u en G. V u. color = BLANCO u. padre = NIL time = 0 Para cada vértice u en G. V Si u. color = BLANCO BPP_Visita(u) ALGORITMO BPP_Visita(u) u. color = GRIS u. distancia = time++ Para cada vértice v en u. Adyacencia Si v. color = BLANCO v. padre = u BPP_Visita(v) u. color = NEGRO u. f = time++ u v 1/8 2/7 w 9/ time 10 4/5 3/6 0 z x y z u=u(v, x), v(y), y(x), x(v), w(y, z), z(w, z) v=z w u v 1/8 2/7 9/ 4/5 3/6 10/11 x y z time 11

BPP ALGORITMO BPP(G) Para cada vértice u en G. V u. color = BLANCO u. padre = NIL time = 0 Para cada vértice u en G. V Si u. color = BLANCO BPP_Visita(u) ALGORITMO BPP_Visita(u) u. color = GRIS u. distancia = time++ Para cada vértice v en u. Adyacencia Si v. color = BLANCO v. padre = u BPP_Visita(v) u. color = NEGRO u. f = time++ u v 1/8 2/7 w 9/ time 11 4/5 3/6 10/11 x y z u=u(v, x), v(y), y(x), x(v), w(y, z), z(w, z) v=z u v w 1/8 2/7 9/12 4/5 3/6 10/11 x y z time 12

BPP u v w 1/8 2/7 9/12 4/5 3/6 10/11 x y z u w v z y x 1 2 3 4 5 6 7 8 9 10 11 12

Algoritmo de Dijkstra l Permite calcular la distancia y ruta màs corta a cualquier vértice a partir de punto de partida l Trabaja con longitudes de las aristas positivas y negativas l No trabaja con ciclos

Algoritmo de Dijkstra Inicializa(G, s) Para cada vértice v en G. V v. distancia = v. padre = nul s. distancia = 0 Relaja(u, v, w) Si v. distancia > u. distancia + w v. distancia = u. distancia + w v. padre = u Dijkstra (G, s) Inicializa(G, s) S= Q = G. V while Q != u = Q. Extrae. Min() u. color = GRIS S. Agrega(u) Para cada vertice v en u. Ady Relaja (u, v, u. distancia(v) u. color = NEGRO

Algoritmo de Dijkstra u v 1 Inicializa(G, s) Para cada vértice v en G. V v. distancia = v. padre = nul s. distancia = 0 10 3 2 s 0 9 6 4 7 5 x 2 y

Algoritmo de Dijkstra u Relaja(u, v, w) Si v. distancia > u. distancia + w v. distancia = u. distancia + w v. padre = u Dijkstra (G, s) Inicializa(G, s) S= Q = G. V while Q != u = Q. Extrae. Min() s. color = GRIS S. Agrega(u) Para cada vertice v en u. Ady Relaja (u, v, u. distancia(v) u. color = NEGRO 1 10 s 0 9 3 2 6 4 7 5 2 x u y v 1 10 10 3 2 s 0 S = {s} Q = {s, u, v, x, y} u = s(u, x) v = u v 9 6 4 7 5 x 2 y

Algoritmo de Dijkstra u 10 s 0 9 3 2 6 4 7 5 2 x y u v 1 10 10 3 2 s 0 S = {s} Q = {s, u, v, x, y} u = s(u, x) v = x 1 10 Relaja(u, v, w) Si v. distancia > u. distancia + w v. distancia = u. distancia + w v. padre = u Dijkstra (G, s) Inicializa(G, s) S= Q = G. V while Q != u = Q. Extrae. Min() s. color = GRIS S. Agrega(u) Para cada vertice v en u. Ady Relaja (u, v, u. distancia(v) u. color = NEGRO v 9 6 4 7 5 5 x 2 y

Algoritmo de Dijkstra u 10 s 0 9 3 2 4 7 5 5 2 x y u v 1 8 10 3 2 s 0 S = {s, x} Q = {s, u, v, x, y} u = s(u, x), x(u, v, y) v = u 1 10 Relaja(u, v, w) Si v. distancia > u. distancia + w v. distancia = u. distancia + w v. padre = u Dijkstra (G, s) Inicializa(G, s) S= Q = G. V while Q != u = Q. Extrae. Min() s. color = GRIS S. Agrega(u) Para cada vertice v en u. Ady Relaja (u, v, u. distancia(v) u. color = NEGRO v 9 6 4 7 5 5 x 2 y

Algoritmo de Dijkstra u 10 s 0 9 3 2 4 7 5 5 2 x y u v 1 8 10 3 2 s 0 S = {s, x} Q = {s, u, v, x, y} u = s(u, x), x(u, v, y) v = v 1 8 Relaja(u, v, w) Si v. distancia > u. distancia + w v. distancia = u. distancia + w v. padre = u Dijkstra (G, s) Inicializa(G, s) S= Q = G. V while Q != u = Q. Extrae. Min() s. color = GRIS S. Agrega(u) Para cada vertice v en u. Ady Relaja (u, v, u. distancia(v) u. color = NEGRO v 14 9 6 4 7 5 5 x 2 y

Algoritmo de Dijkstra u Relaja(u, v, w) Si v. distancia > u. distancia + w v. distancia = u. distancia + w v. padre = u 1 8 10 14 9 3 2 s 0 Dijkstra (G, s) Inicializa(G, s) S= Q = G. V while Q != u = Q. Extrae. Min() s. color = GRIS S. Agrega(u) Para cada vertice v en u. Ady Relaja (u, v, u. distancia(v) u. color = NEGRO 6 4 7 5 5 2 x y u v 1 8 10 3 2 s 0 S = {s, x} Q = {s, u, v, x, y} u = s(u, x), x(u, v, y) v = y v 14 9 6 4 7 5 5 x 2 7 y

Algoritmo de Dijkstra u 10 s 0 14 9 3 2 6 4 7 5 5 7 2 x y u v 1 8 10 3 2 s 0 S = {s, x, y} Q = {s, u, v, x, y} u = s(u, x), x(u, v, y), y(s, v) v = s, v 1 8 Relaja(u, v, w) Si v. distancia > u. distancia + w v. distancia = u. distancia + w v. padre = u Dijkstra (G, s) Inicializa(G, s) S= Q = G. V while Q != u = Q. Extrae. Min() s. color = GRIS S. Agrega(u) Para cada vertice v en u. Ady Relaja (u, v, u. distancia(v) u. color = NEGRO v 13 9 6 4 7 5 5 x 2 7 y

Algoritmo de Dijkstra u 10 s 0 13 9 3 2 4 7 5 5 7 2 x y u v 1 8 10 3 2 s 0 S = {s, x, y, u} Q = {s, u, v, x, y} u = s(u, x), x(u, v, y), y(s, v), u(x, v) v = x 1 8 Relaja(u, v, w) Si v. distancia > u. distancia + w v. distancia = u. distancia + w v. padre = u Dijkstra (G, s) Inicializa(G, s) S= Q = G. V while Q != u = Q. Extrae. Min() s. color = GRIS S. Agrega(u) Para cada vertice v en u. Ady Relaja (u, v, u. distancia(v) u. color = NEGRO v 13 9 6 4 7 5 5 x 2 7 y

Algoritmo de Dijkstra u 10 s 0 13 9 3 2 4 7 5 5 7 2 x y u v 1 8 10 3 2 s 0 S = {s, x, y, u} Q = {s, u, v, x, y} u = s(u, x), x(u, v, y), y(s, v), u(x, v) v = v 1 8 Relaja(u, v, w) Si v. distancia > u. distancia + w v. distancia = u. distancia + w v. padre = u Dijkstra (G, s) Inicializa(G, s) S= Q = G. V while Q != u = Q. Extrae. Min() s. color = GRIS S. Agrega(u) Para cada vertice v en u. Ady Relaja (u, v, u. distancia(v) u. color = NEGRO v 9 9 6 4 7 5 5 x 2 7 y

Algoritmo de Dijkstra u Relaja(u, v, w) Si v. distancia > u. distancia + w v. distancia = u. distancia + w v. padre = u 1 8 10 9 9 3 2 s 0 Dijkstra (G, s) Inicializa(G, s) S= Q = G. V while Q != u = Q. Extrae. Min() s. color = GRIS S. Agrega(u) Para cada vertice v en u. Ady Relaja (u, v, u. distancia(v) u. color = NEGRO 6 4 7 5 5 7 2 x y u v 1 8 10 3 2 s 0 S = {s, x, y, u, v} Q = {s, u, v, x, y} u = s(u, x), x(u, v, y), y(s, v), u(x, v), v(y) v = y v 9 9 6 4 7 5 5 x 2 7 y

Archivos

Representación de los datos Textual Requieren de conversión Pierden precisión Facilitan su lectura Permiten el intercambio Representación Binaria Se almacenan igual que en la memoria No se requiere conversión Ahorran espacio de almacenamiento No se pierde precisión

Campos de longitud fija

Campos de longitud variable l l l 73|76368772|Juan José Morales|19900222|15250. 22 14|73882084|Pedro Martinez|19910401|12. 50 73|67388408|René Mendoza|19970725|152667. 81 14|84773872|Corlos Murillo|19960617|0. 00 14|74657290|Martín Jaramillo|19980823|2500. 00 73|74983678|Martha Mijares|19980101|250754. 30

Registros Trailer 4 Encabezado Cuatro segmentos Cuenta

Archivos con registros homogéneos

Registros heterogéneos

Serialización . xls. doc. ppt

Medios magnéticos Ensamble de discos Peine de cabezas Ensamble de discos Cabezas de lectura/escritura

Arquitectura del disco Sector Pistas Cilindro

Parámetros de discos magnéticos l Tiempo de Posicionamiento (tp ms) mínimo – máximo – promedio – l l l Velocidad de rotación (vr rpm) Tiempo de lectura/escritura(tle ms) Sectores por pista(spp) Numero de cabezas(ncab) Número de cilindros(ncil) Capacidad Sector (caps bytes/sector) – Pista(capp bytes/pista) – Cilindro(capc bytes/cilindro) – Total(capt bytes) – • Retraso rotacional (rr ms)

Parámetros del Quantum Pionner SG Capacidad total = 2. 111 GB Capacidad total Número cabezas = 16 Número de cilindros = 4092 Sectores por pista = 63 capt = 63*4*4092*512 = 2, 111, 864, 832 bytes = 2. 11 GB Posicionamiento mínimo = 4 ms Posicionamiento promedio = 12 ms Posicionamiento máximo = 26 ms Velocidad de rotación = 4, 500 RPM Retraso rotacional Tiempo de lectura de un sector

Elsistema de archivos de Unix boot block super block lista de inodos Bloques de datos. . Inodo propietario grupo tipo de archivo permisos accesado modificación del inodo tamaño del archivo tabla de bloques de datos número de ligas

La tabla de bloques de datos Bloque de datos 0 1 2 3 4 Bloques de datos 5 6 Bloques Idirectos 7. . . 8 9 Bloque indirecto . . . Bloque doble indircto . . . Bloque triple indirecto. .

Los Directorios inodo 1523 1567 234 608 0 421 422 Nombre. . . datos include lib bin

Las tuberías (pipes) Bloques directos Siguiente posición para lectura Siguiente posición para escritura Número de bytes en el pipe 12354

Montón (Heap) Xi <= X 2 i+1 Xi <= X 2 i+2 X 0 X 2 X 1 X 3 X 4 X 8 X 7 X 5 X 10 X 9 Xi X 2 i+1 X 11 X(s-1)/2 X 2 i+2 Xs X 6 X(s-1)/2 Xs void inserta(double x[], int I, int D) { int k; double t; while(D >= 2*I+1) { k = 2*I+1; if (k < D && x[k+1] < x[k]) k++; if (x[k] < x[I]) {t = x[I]; x[I] = x[k]; x[k] = t; } else break; I = k; } }

Jerarquía de clases Entrada/Salida ios istream ostream istrstream ofstream istream_with assign ostream_withassi gn iostream ofstream ifstream strstreambuf filebuf strstreambuf stdiostreaminit stdiobuf

ios l Es la clase base de todas las clases para el manejo de streams – Manipuladores – Enumeradores – Funciones

Manipuladores l Son funciones que modifican las operaciones de un stream l Se ejecutan de dos formas – boolalpha(cout) – cout << boolalpha

Manipuladores boolalpha noboolalpha dec hex oct fixed scientific setw(n) left, right internal showbase noshowbase setprecision(n) Datos bool como true, flase Datos bool como 1 y 0 Uso de base decimal Representacoón hexadecimal Representación octal Los números flotantes como punto fijo Notación científica para números flotantes Establece el número de posiciones para el campo Ajuste a la derecha o izquierda Signo a la izquierda valor a la derecha(- 12. 5) Muestra la base numérica No muestra la base numérica Establece el número de cifras significativas

Manipuladores #include <iostream> #include <iomanip> using namespace std; int main() { int x = 100; cout << "Con showbasen"; cout << dec << showbase << x << endl; cout << hex << showbase << x << endl; cout << oct << showbase << x << endl; cout << << "Con noshowbasen"; dec << noshowbase << x << endl; hex << noshowbase << x << endl; oct << noshowbase << x << endl; cout << "Uso de setw(10)" << endl; cout << "-" << setw(10) << x << "-" << endl; cout << "setprecision(4)" << endl; float pi = 3. 14159254; cout << setprecision(4) << pi << endl; } Con showbase 100 0 x 64 0144 Con noshowbase 100 64 144 Uso de setw(10) 144 setprecision(4) 3. 142

istream, ostream • Sus constructoras requiere un objeto streambuf , la cual es una clase abstracta • Para manipular archivos se puede usar filebuf

istream y ostream #include <iostream> #include <fstream> #include <istream> #include <ostream> using namespace std; int main() { filebuf entrada, salida; entrada. open("datos. txt", ios: : in); salida. open("resultados. txt", ios: : out | ios: : trunc); istream IStream(&entrada); ostream OStream(&salida); char buf[200]; while(!IStream. eof()) { IStream. getline(buf, 200); OStream << buf << endl; } entrada. close(); salida. close(); }

Manejo de errores ios_base: : iostate (tipo bitmask) Contiene los siguientes bits ios_base: : badbit ios_base: : eofbit ios_base: : failbit ios_base: : goodbit Pérdida de integridad en el stream Se trató de leer despues del último byte La última operación falló No hubo error. Los anteriores están apagados Funciones de consulta de ios_base_iostate bool ios: : good() bool ios: : eof() bool ios: : bad() bool ios: : fail()

Manejo de errores Funciones para modificar el valor de ios_base_iostate ios: : rdstate() Devuelve el estado del stream void ios: : setstate(iostate) Establece los bit de iostate sin borrar los que ya se encuentren prendidos void ios: : clear(iostate=goodbit) Borra todos los bits de iostate y establece los nuevos valores

Procesos con archivos secuenciales . . . Viejo maestro Transacciones Ordenamiento Intercalación Actualización Nuevo Maestro

Algoritmo de intercalación de 2 vias Intercala A y B en C Abre A Abre B Lee. Registro. A Lee. Registro. B Repite Si llave. A = llave. B y llave. A = Valores. Altos Salir Si llave. A < llave. B Escribe Registro. A en C Lee. Registro. A sino Escribe Registro. B en C Lee Registro. B Cierra A, B y C Lee. Registro. A Lee A en registro A Si fin de archivo en A Mueve Valores. Altos a llave. A Lee. Registro. B Lee B en registro B Si fin de archivo en B Mueve Valores. Altos a llave. B

Algoritmo de intercalación de 2 vias Intercala A y B en C Abre A Abre B Lee. Registro. A Lee. Registro. B Mientras no ( A. eof() y B. eof()) Si B. eof() o (no A. eof() y llave. A < llave. B Escribe Registro. A en C Lee. Registro. A sino Escribe Registro. B en C Lee Registro. B Cierra A, B y C

Intercalación por heap (multi vias) x 0 x 1 x 2 x 3 x 7 x 4 x 8 x 9 x 5 x 10 x 11 x 6 x 12 x(i-1)/2 xi x 2 i+1 x 2 i+2

Algoritmos para el heap Insert (X, I, D) Mientras D >= 2*I + 1 k = 2*I + 1 Heap Inicial(X, n) Para i = (n-2) - 2 a 0 Insert(X, i, n-1) Si k < D y Xk > Xk+1 k = k+1 Si XI > Xk XI <-->Xk Sino Salir I = k Heap. Merge Para k = 0 a n-1 Abre archivo[k] Lee archivo[k] Heap Inicial(Archivo, n) Mientras !Archivo[0]. eof() Graba Registro[0] en salida Lee Archivo[0] Inserta(Archivo, 0, n-1)

Actualización de Archivos Viejo maestro Transacciones Actualización Nuevo Maestro Lectura Maestro Si llave_MV = llave_MN Lee Maestro Viejo Mueve Maestro Viejo a Maestro Nuevo Lee Transacción Mueve valores_bajos a llave_MN Mueve valores_bajos a llave_MV Lectura Maestro Mientras llave_MN != valores_altos Si llave_MN < llave_T Escribe Maestro Nuevo Lectura Maestro Sino Si llave_MN = llave_T De acuerdo al tipo de transaccion: cambio: Aplica Transacción a Maestro Nuevo baja: Lectura Maestro alta: Reporta “Error alta duplicada” Lee Transacción Sino Si Alta Arma Maestro Nuevo con Transacción Sino Error Cambio o baja que no existe Lee Transacción

Actualización de Archivos Actualizacion Abrea MV, T y MN MV T Lee T Lectura_Maestro Mientras no (MN. Fin y T. eof()) Si T. eof() o (no MN. Fin y MN. llave < T. llave) Actualización Escribe MN Lectura_Maestro Sino Si no MN. Fin y MN. llave = T. llave MN De acuerdo al tipo de transaccion: cambio: Aplica T a MV baja: Lectura_Maestro alta: Lectura_Maestro Error “alta duplicada” Lee T Si MN. llave = MV. llave Sino Lee MV Si Alta Arma MN con T Mueve MV a MN; Sino Mueve MV. eof() a MN. Fin Error “Cambio o baja que no existe” Lee T Cerra MV, T y MN

Ordenamientos l En Memoria – Burbuja, Inserción Directa, Selección Directa – Shell, Heap, Quick l Externos – Balanceado 2 vias – Polyphase

Intercalación balanceada en 2 vias Entrada Primer paso Ordenamiento Interno Corridas Ordenadas A Corridas Ordenadas B Ordenamiento Interno Corridas Ordenadas C Corridas Ordenadas D Se realizan ordenamientos en memoria y se graban alternadamente en las cintas A y B Segundo paso Se intercalan las secuencias de las cintas A y B y las corridas resultantes se mandan alternadamente a las cintas C y D. Las corridas resultantes tienen el doble de la longitud de las originales. El proceso se repite tomando como entrada C y D y de salida A y B hasta queda una sola corrida

Intercalación balanceada en 2 vias Supongamos que se ordenan 5, 000 registros y que caben solamente 1, 000 en memoria A 1 -1000 B 1001 -2000 C D 2001 -3000 4001 -5000 1 -2000 C D 4001 -5000 Segunda pasada 2001 -4000 A B Primera pasada 3001 -4000 Tercera pasada 4001 -5000 Cuarta pasada

Mejoría de Intercalación balanceada en 2 vias Supongamos que se ordenan 5, 000 registros y que caben solamente 1, 000 en memoria D A 1 -5000 1 -1000 3001 -4000 D B 1001 -2000 C 2001 -3000 A 1 -1000 4001 -5000 3001 -4000 C B D 1001 -2000 1 -3000 4001 -5000 1 -3000 1 -5000 A 1 -1000 3001 -4000 B 1001 -2000 4001 -5000 C 2001 -3000

Cálculo de operaciones E/S Intercalación Balanceada 2 vias Método Alterno

Intercalación Balanceada con t cintas Corridas Ordenadas 1 Entrada Ordenamiento Interno Corridas Ordenadas 1 Corridas Ordenadas 2 . . . Corridas Ordenadas p . . . Corridas Ordenadas t Intercalación de p vias . . . Corridas Ordenadas p+1 Corridas Ordenadas p+2

Árbol de ganadores 1 061 2 4 8 170 154 3 5 170 10 9 275 6 154 11 426 154 908 170 16 17 897 275 18 19 653 426 20 21 503 087 154 509 22 7 087 12 23 061 13 061 512 061 14 15

Árbol de Perdedores 0 061 1 154 2 3 170 4 8 5 275 9 908 10 897 6 426 653 11 509 908 170 16 17 897 275 18 19 653 426 20 21 503 087 154 509 22 7 503 12 23 087 13 512 061 14 15

Lóngitud de las corridas

Estructuras de datos para Selección por reemplazo 0 record rn record loser pe 1 record rn loser 2 record 3 rn record rn loser 4 5 rn 6 7 pi

Algoritmo Selección por Reemplazo R 1. - Inicialización R 4. - Lectura de registro R 5. - Preparación para actualizar rmax = 0; rc= 0; lastkey=hv; q = &x[0]; rq = 0 Para j = 0 a p - 1 loser[j] = j; rn = 0; fe[j] = &x[(p+j)/2] fi[j] = &x[j/2] Si fin de archivo rq = rmax+1 Sino Lee registro en record[q] Si key[q] < lasrkey rq = rq + 1 Si rq > rmax = rq t = fe[q] rmax número de la maxima corrida en la entrada de datos R 7. - Ascenso R 2. - Fin de corrida? Si rq = rc goto R 3 rq = rc+1; Si rq > rmax Fin Sino rc = rq R 3. - Escritura de la salida rc Número de corrida de la ultima entrada rq Número de corrida del registro de entrada y posteriormente del ganador q Índice del bloque externo que contiene el registro de entrada y posteriormente el ganador lastkey valor de la última llaave grabada en la salida Si rq != 0 Escribe registro[q] lastkey = key[q] R 6. - Determina perdedor Si rn[t] < rq o (rq != 0 y rn[t] = rq y llave[loser[t]] < llave[q] Intercambia loser[t] y q Intercambia rq y rn[t] Si t = &x[1] Ve a R 2 Sino t = fi[t] Ir a R 6

Algoritmo Selección por Reemplazo Principal Lectura de registro Inicializa Mientras rq <= rmax Mueve registro(q) a salida Mueve llave de registro(q) a lastkey Lectura de registro Ascenso Lee registro en record[q] Si fin de archivo rq = rmax+1 Sino Si llave[q] < lasrkey rq = rq + 1 Si rq > rmax = rq Inicializa Ascenso rmax = 0; rc= 0; lastkey=hv; q = &x[0]; rq = 0 Para j = 0 a p - 1 loser[j] = j; rn = 0; fe[j] = &x[(p+j)/2] fi[j] = &x[j/2] Mientras rq = 0 Lee registro Ascenso t = fe(q) whie t != &x[0] Si rn[t] < rq o (rq != 0 y rn[t] = rq y llave[loser[t]] < llave[q]) Intercambia loser[t] y q Intercambia rq y rn[t] t = pi(t)

Ordenamiento Polifase Idea: Eliminar los pasos de copiado que se presentan en el algoritmo del método balanceado

Números de Fibonacci en = an-1 dn = an-1 + en-1 = an-1 + an-2 cn = an-1 + dn-1 = an-1 + an-2 + an-3 bn = an-1 + cn-1 = an-1 + an-2 + an-3 + an-4 an = an-1 + bn-1 = an-1 + an-2 + an-3 + an-4 + an-5 Número de corridas de la cinta T 1 en paso n an = F(p)n+p-1 La cinta Tk contniene an = F(p)n+p-2 + F(p)n+p-3. . . + F(p)n+k-2 F(2)= 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, . . . F(5)= 0, 0, 1, 1, 2, 4, 8, 16, 31, 61, 120, . . . F(p)n= 0 para 0 <= n <= p-2 F(p)p-1= 1 F(p)n= F(p)n-1 + F(p)n-2 +. . . F(p)n-p para n >=p

D 1: Inicialización Para j = 1 a P Aj = Dj =1 TAPEj = j AT = D T = 0 TAPET = T l = j = 1 D 2 Lectura de la cinta Escribe una corrida en TAPEj Dj = Dj-1 Si se terminó el archivo Regresa TAPE 1 a TAPET Ir a D 5 D 3 Avanzar Si Dj < Dj+1 j = j + 1 Ir a D 2 Si Dj = 0 Ir a D 4 j = 1 Ir a D 2 D 4 Subir un nivel l = l + 1 a = A 1 Para j = 1 a P Dj = a + Aj+1 - Aj Aj = a + Aj+1 j = 1 Ir a D 2 Ordenamiento Polifase D 5 Intercalación Si l = 0 Terminar /* Salida en TAPE 1 Mientras haya corridas en TAPEP ó DP > 0 Intercalar TAPE 1 a TAPEP en TAPET La intercalación es como sigue: Si todas Dj>0 (1 <= j <= P) Decrementa todas las Dj Incrementa DT Sino Intercala todas TAPEj tales que Dj = 0 Decrementa todas las Dj > 0 D 6 Desciende un nivel l = l - 1 Rebobina TAPEP y TAPET Rota las cintas y D’s TAPE 1, TAPE 2 , . . . TAPET = TAPET, TAPE 1 , . . . TAPET-1 D 1, D 2 , . . . DT = DT, D 1 , . . . DT-1 Ir a D 5

Acceso aleatorio a los archivos Registros de longitud fija RRN 0 1 2 3 . . . n-2 n-1

Ejemplo de acceso directo #include "iostream. h" #include <fstream. h> #include <stdlib. h> typedefstruct { public: long mat; char nom[60]; char dom[60]; } alm_r; int main(int argc, char* argv[]) { ifstream alumnos(". . \alumnos. dat", ios: : in); int reclen = sizeof(alm_r); int pos = (atoi(argv[1])-1) * reclen; alumnos. seekg(pos); alm_r alumno; alumnos. read((char*)&alumno, reclen); cout << alumno. mat << " " << alumno. nom << " return 0; } " << alumno. dom << endl;

Búsqueda binaria busqueda_binaria(archivo, llave_busq, tot_registros) prim = 0 ultim = tot_registros-1 mientras(prim < ultim) medio = (prim+ultim) / 2 Lee registro(medio) Si (llave_busq < llave(registro_medio)) ultim = medio - 1 Sino Si (llave_busq > llave(registro_medio)) prim = medio + 1 Sino Regresa registro_medio Regresa no encontrado log n + 1 comparaciones Mantener el archivo ordenado es costoso Normalmente se desea acceso mas rápido

Uso de índices llave RRN 0 1 2 3 . . . n-2 n-1 Búsqueda binaria en memoria l Puede haber varios índices l Los registros no tienen que estar ordenados en disco l

Liberación de espacio en los archivos l Aumento de tamaño de un registro – Grabar un agregado al final del archivo y un apuntador en la primera parte del registro – Grabar el nuevo registro al final del archivo l Eliminación de un registro – Marcar el registro como eliminado – Utileria de compactación l Reutilización dinámica – Marcar los registro eliminados – Mecanismo para localizar regostros eliminados

Cadenas de registros libres Apuntador al primer registro libre Marca de libre * * * Apuntador al siguiente libre

Recuperación de espacio en un archivo Registros de longitud fija Una lista ligada con los registros que han sido eliminados proporciona un metodo eficiente para localizar espacio libre Lista de registros disponibles Record libre nil Record libre Puede funcionar como una pila

Espacio libre con registros variables Creación de una lista de espacio disponible l Asignación de un segmento disponible l Estrategias l – El primero que se encuentre – El que mejor se ajuste – El que peor se ajuste l La lista de espacio disponible debe contener – El tamaño de cada segmento disponible – Un algoritmo para agregar nuevos segmentos en la posición adecuada – Algoritmos para seleccionar un segmento disponible

Primero disponible La lista puede estar en cualquier orden l Los nuevos segmentos libres se agregan al principio de la lista l Para asignar un segmento a un nuevo registro l – La busqueda se hace desde el principio – Se asigna el primer semento en donde quepa el registro – Si no hay segemtos del tamaño adecuado la búsqueda es total

Primero que se encuentre Agregar segmentos libres al principio l Resulta costosa cuando no se encuentra ninguno l Favorece la fragmentación l

Mejor ajuste Se requiere mantener la lista ordenada por tamaño l Al asignar el primero que satisface es el que mejor se ajusta l Los remanentes l – Se pueden ignorar (desperdicio) – Incorporar a la lista (reducción de eficiencia) l Si no existen la búsqueda es exhaustiva

Peor ajuste Segmentos libres en orden descendente l Si existe algún segmento apropiado es el primero l El espacio remanente puede ser suficiente para otro registro l

Archivos secuenciales con índices k 4 k 8 . . . kn Indice de pistas k 1 k 2 k 3 k 5 k 6 k 7 k 8 Pistas de datos . . . kn-2 kn-1 kn Area de desbordamiento

Árboles B 100 31 64 90 121 167 200 184 300 211 256 285 301 320 355. . . 07 17 25 34 43 56 68 75 Orden m = número de descendientes Número máximo de llaves = m - 1 Numero mínimo de descendientes k = cielo(m/2) Número mínimo de llaves = k-1 82 94 97 98 m=4 Número maximo de llaves = 3 k = 2 Número mínimo de llaves = 1 . . .

Consulta Entrada: Llave. Buscada Salida: Bloque. Datos Número del bloque de datos del registro 0 si no se encontró Bloque. Numero = Número del bloque raíz Mientras Bloque. Numero != 0 Lee Bloque[Bloque. Numero] Busca. Llave. En. Bloque(Bloque, Llave. Buscada) salida encontrado, pos Si encontrado Regresa Bloque. Datos[pos] Sino Si Bloque es una hoja Regresa 0 Sino Bloque. Numero = Bloque. Indice[pos] Regresa 0 Busca. Lllave. En. Bloque Entrada: Bloque de índices Llave. Buscada Llave que se busca Salida: Encontrado Booleano Posicion Posición de la llave (está o debe estar) Para i = 0 a Bloque. Numero. Llaves – 1 Si Llave. Buscada == Bloque. llave[i] Regresa encontrado = true, Posicion = i Si Lllave. Buscada > Bloque. llave[i] Regresa encontrado = falso, Posición = i Regresa encontrado = falso, Posicion = i

Inserción Raíz Inserción de 34 0 Inserción de 12 a). - Se produce una division Raíz 12 12 24 56 Inserción de 56 b). - Se agrega la nueva llave Raíz 12 12 56 24 34 c). - Se promueve la llave 24 y el nuevo bloque Inserción de 24 Raíz 12 24 56 12 34 56 56

Estructura de los bloques de índices num_llaves . . . struct tag. Index { int num_llaves; long blq_ind[NUM_LLAVES+1]; int llave[NUM_LLAVES]; long blq_dat[NUM_LLAVES] }; . . . MAX_LLAVES + 1 números de bloque de índices MAX_LLAVES llaves MAX_LLAVES números de bloque de datos

Algoritmo de inserta Algoritmo inserta(root, llave) r = inserta_rec(root, llave) regresa (llave_prom, bloque_prom) Si r = error Regresa falso Si r = promovido Crea nuevo bloque NB NB. num_llaves=1 NB. blknr[0] = root NB. llave[0] = llave_prom NB. blknr[1] = bloque_prom root = RBN(NB) Regresa verdadero

Algoritmo inserta_rec(blknr, llave) regresa (llave_prom, bloque_prom, valor) Si blknr = 0 regresa llave_prom = key, bloque_prom = 0 valor = promovido Lee bloque(blknr) en BLK pos = busca_llave(BLK, key) Si existe_en_bloque Regresa error rv = inserta_rec(BLK. blknr[pos], llave) regresa (llave_prom, bloque_prom) Si rv != promovido Regresa (llave_prom, bloque_prom, valor = falso) Si hay espacio en BLK Agrega la llave en BLK Regresa (llave_prom=0, bloque_prom=0, valor=falso) Divide_bloque(BLK, llave_prom, bloque_prom) regresa (llave_prom, bloque_prom) Regresa = promovido

Division de bloques Se trata de insertar la llave 250 con el apuntador x que se han promovido del nivel inmediato inferior. Se tienen las siguientes condiciones: Las llaves que se localizan a partir de c son mayores que 200 y menores que 250. Las llaves que se localizan a partir de x son mayores de 250 y menores que 300 Bloque se va a dividir por falta de espacio para la nueva llave a 100 b 200 c 300 d 400 e

Proceso de División (split) Bloque a dividir BLK RBN = q a). - Se dividen los bloques y se reparten las llave. Note c duplicado. b). - Se recorren las llave y apuntadores. 350 x a 100 b 200 c 300 d 400 e Nuevo bloque NBLK RBN = r RBN = z z a 100 b 200 c c 300 d 400 e xd 400 e z c). - Se agrega la llave y el apuntador promovidos a 100 b 200 c c 250 300 dx 300 350 250 z 300 z d). - Se promueve la última llave del bloque original o la primera del nuevo bloque. z a 100 b 200 c dx 350 300 xd 400 e promoción

División de bloques Bloque a dividir BLK RBN = q 4 v 120 w 235 Llave x 411 y 480 blknr 135 z u Nuevo bloque NBLK RBN = r a). - Se dividen las llaves en dos bloques 2 v 120 w 235 x 2 x 411 y 480 z b). - Se inserta la llave en el bloque le corresponde 3 v 120 w 135 u 235 x c). - Se promueve la llave del bloque tiene mas llaves 2 v 120 w 135 u llave_prom d). - Valores de retorno 235 blknr_prom r

Algoritmo divide_bloque(BLK, llave, blknr) regresa (llave_prom, blknr_prom) Obten un nuevo bloque NBLK con RBN = blknr_prom Mueve la mitad de las llaves de BLK a NBLK Si llave < ultima llave en BLK Agrega llave y blknr a BLK Sino Agrega llave y blknr a NBLK Si numero de llaves en BLK > número de llaves en NBLK llave_prom = ultima llave en BLK Elimina ultima llave de BLK Sino llave_prom = primera llave de NBLK Elimina primera llave de NBLK Regresa llave_prom, blknr_prom=RBN de NBLK

Eliminación de llaves root 24 70 Eliminación de 18 root 85 34 70 85 Redistribución 12 18 22 34 56 61 61 24 56 Eliminación de 22 24 12 18 34 85 70 34 56 70 24 61 61 70 61 Eliminación de 24 root 24 85 61 Eliminación de 12 root 61 Eliminación de 56 root 61 70 85 85 Concatenación Bloque libre 18 34 56 61 61 34 61 61

Algoritmo elimina_llave Elimina_llave(llave) MBLK = BLK niv=0 Mientras MBLK no sea una hoja blknr[niv]=root blknr[niv+1]= MBLK. . blknr[pos[niv]] Si blknr[niv]=0 pos[niv+1]=0 Regresa falso Hacer niv = niv+1 Lee bloque(blknr[niv]) en MBLK Lee bloque número blknr[niv] en BLK Si BLK no es una hoja pos_int = busca_llave(BLK, llave) Mueve la MBLK. llave[0] a BLK. llave[pos_int] pos[niv] = pos_int Graba BLK Si existe_en_bloque salir blknr[niv+1] = BLK. blknr[pos_int] niv = niv+1 Mientras blknr[niv] != 0 Si blknr[niv]=0 Regresa falso Si BLK no es una hoja pos[niv] = pos[niv] + 1 Elimina MBLK. llave[pos_int]

Elimina llave (continua) min = cap / 2 Sino Si hay hermano derecho Mientras niv != 0 y MBLK. num_llaves < min Lee bloque PBLK. blknr[pos] + 1 en DBLK Lee el bloque blknr[niv-1] en PBLK Si DBLK. num_llaves + MBLK. num_llaves >= 2*min Si pos[niv-1] > 0 (hay hermano izquierdo) redestribuye (pos, PBLK, MBLK, DBLK) Lee bloque PBLK. blknr[pos-1] - 1 en IBLK Graba MBLK e DBLK Si IBLK. num_llaves + MBLK. num_llaves >= 2*min Sino redestribuye (pos, PBLK, IBLK, MBLK) concatena(pos , PBLK, MBLK, DBLK) Graba MBLK e IBLK Graba MBLK Sino Libera DBLK concatena(pos, PBLK, IBLK, MBLK) niv = niv-1; Graba IBLK Graba PBLK Libera MBLK = PBLK Si niv = 0 y MBLK. num_llaves = 0 raiz = MBLK. blknr[0] Libera MBLK

Redistribución Redistribuye (pos, PBLK, IBLK, DBLK) prom = (IBLK. num_llaves + DBLK. num_llaves) / 2 mover = capacidad - prom -1 Si IBLK. num_llaves < DBLK. num_llaves dest = IBLK. num_llaves IBLK. llave[des] = PBLK. llave[pos] dest = dest + 1 org = 0 Mientras org < mover IBLK. llave[des] = DBLK. llave[org] IBLK. blknr[des] = DBLK. blknr[org] incrementa org y des IBLK. blknr[des] = DBLK. blknr[org] PBLK. llave[pos] = DBLK. llave[org] des = 0; org = mover+1 Mientras org < DBLK. num_llaves DBLK. llave[des] = DBLK. llave[org] DBLK. blknr[des] = DBLK. blknr[org] incrementa org y des DBLK. blknr[des] = DBLK. blknr[org] IBLK. num_llaves = IBLK. num_llaves + mover+1 DBLK. num_llaves = DBLK. num_llaves - mover - 1 capacidad = 3 prom = (3)/2 = 1 mover = 3 -1 -1 = 1 PBLK 230 pos 323 540 IBLK DBLK 350 PBLK 230 389 540 IBLK 323 350 389 DBLK 405

Redistribución (cont) capacidad = 3 prom = 3/2 = 1 mover = 3 -1 -1 = 1 Sino org = DBLK. num_llaves des = org + mover +1 DBLK. blknr[des] = DBLK. blknr[org] Decrementa org y des Mientras org >= 0 DBLK. llave[des] = DBLK. llave[org] DBLK. blknr[des] = DBLK. blknr[org] Decrementa org y des DBLK. llave[des] = PBLK. llave[pos] org = IBLK. num_llaves DBLK. blknr[des] = IBLK. blknr[org] Decrementa org y des Mientras des >= 0 DBLK. llave[des] = IBLK. llave[org] DBLK. blknr[des] = IBLK. blknr[org] Decrementa org y des PBLK. llave[pos] = IBLK. llave[org] IBLK. num_llaves = IBLK. num_llaves - mover - 1 DBLK. num_llaves = DBLK. num_llaves+mover+ 1 PBLK 230 pos 323 540 IBLK 250 PBLK 265 DBLK 304 230 265 540 IBLK 250 DBLK 304 323

Redistribución Por underflow se redistribuyen las llaves 1 f 90 4 a 100 d 400 e 3 h 120 4 a 100 b 200 c 300 g 100 d 400 i h 4 a 120 b 200 c 300 d 400 e 2 i 145 j 170 k e 3 h 120 Se mueven apuntadores y llaves 2 f 90 c 300 g La llave del padre se pasa al hijo 2 f 90 b 200 j i 145 170 k j 170 k

Concatenación concatena(pos , PBLK, IBLK, DBLK) des = IBLK. num_llaves IBLK. llave[des] = PBLK. llave[pos] Incrementa des org = 0 Mientras org < DBLK. num_llaves IBLK. llave[des] = DBLK. llave[org] IBLK. blknr[des] = DBLK. blknr[org] Incrementa org y des IBLK. blknr[des] = DBLK. blknr[org] IBLK. num_llaves = IBLK. num_llaves + DBLK. num_llaves+1 des = pos org = pos+1 Mientras org < PBLK. num_llaves PBLK. llave[des] = PBLK. llave[org] PBLK. blknt[des+1] = PBLK. blknr[org+1] Incrementa org y des Decrementa PBLK. num_llaves pos PBLK 230 323 540 IBLK DBLK 250 402 pos PBLK 230 540 IBLK 250 323 Libre DBLK 402

El buffer de cache Vector de hash . . . Buff A Primero libre Último libre Buff B Buff C

Árboles B+ El conjunto secuencial (sequential set) 1 adela 2 alma benito 3 carlos carola daniela enrique graciela Insertando beatiz 1 adela 2 alma carlos 3 carola daniel 4 beatriz benito Pueden aplicarse los algoritmos de: Redistribución Concatenación Partición daniela enrique graciela

Contenido de los índices en árboles B+ b 1 c 4 adela alma beatriz 2 benito carlos daniela 3 daniela enrique graciela Algoritmo para calcular separadores separador(char *sep, char *llave 1, char *llave 2) { whiel((*sep++=*llave 2++) == *llave 1++) ; *sep = 0; } carola daniel

Formación del árbol de índices c b 1 daniela 4 adela alma beatriz benito 3 2 carlos carola daniela enrique graciela ï Si se elimina la el registro “daniela” no cambia la estructura de índices. El separador puede seguir siendo “daniela” ï Los índices solamente cambian cuando hay redistribución o concatenación ï La liberación de un bloque en el conjunto secuencial elimina un índice ï La división de un bloque en el conjunto secuencial provoca la adición de una entrada en la estructura de índices ï Los mecanismos de inserción y remoción son los mismos que en árboles B

Hashing

Dispersión 0 1 2 Llave 3 Número entre 0 y N-1

Doblado de llaves llave C A R L O S F U E N T Nota: En la última palabra de la llave Solamente se toma hasta byte cero que termina la cadena. E S 0 R T I N 0 4341534 C 4 F 532046 55454 E 54 45530000 1 C 043 D 5 E Doblado con o exclusiva

Metodo del producto k r 1 A r 2 P bits

Desbordamiento progresivo 0 1 Martínez Perez 2 Carmona 3 4 Jimenez 5 6 F(k) López 7 De la Fuente 8 9 10 11

Áreas de desbordamiento Martínez, Jimenez Contreras, Rodríguez López, Hernández N direcciones primarias Díaz Ibarra, Noriega . . . Maldonado, Zavala Garza, Garnica Areas de desborde Luna Ángeles

Hash Extendible Carlos r m a Camila e c Celia d Daniel Doris

Uso de una raíz binaria 0 A A 0 0 B 0 1 00 01 1 1 B 0 1 C A 10 B 11 C Arbol binario Completo Directorio equivalente

Desbordamiento sin división 0 0 A A 0 1 1 0 B 0 1 1 1 D B 0 1 C C 00 A 01 D 10 B 11 C

Desbordamiento con división 0 0 A 0 0 1 D 1 010 D 1 1 B 0 0 1 000 001 0 0 1 A 0 1 011 B B 101 E E 110 111 1 0 1 D 100 1 C A C C

Estructuras de Datos struct Directorio { int nivel; int RBN[2^^Nivel]; } struct Bloque { int nivel; int cuenta; Llave llave[FACTOR_BLOQUE]; }

Inserta /* Función Inserta Entradas: llave Valor: Verdadero Falso Llave que se va a insertar Si la llave se insertó correctamente De otra manera */ Función Inserta(Entrada llave; Valor bool) Si Busca(llave, bloque) Regresa FALSO Inserta. En. Bloque(llave, bloque) Regresa VERDADERO

Busca /* Función. Busca Entradas: llave La llave a buscar Salidas: bloque El bloque de datos que le corresponde a la llave Valor: VERDADERO La llave se encuentra en el bloque FALSE De otra manera */ Función Busca(Entrada llave; Salida bloque) direccion = Crea. Direccion(llave, Directorio. nivel) Lee. Bloque(bloque, Directorio[direccion]); Regresa Busca. Llave. En. Bloque(bloque, llave);

Crea. Direccion /* Función: Crea. Direccion Entradas: llave LLaven en base a la que se crea la dirección nivel Número de bits de la dirección Salida: direccion Dirección que le corresponde a la llave */ Función Crea. Direccion(Entrada llave, nivel; Salida direccion) direccion = Hash(llave) direccion = nivel bits más significativo de direcion Regresa direccion

Busca. Llave. En. Bloque /* Función Busca. Llave. En. Bloque Entradas: bloque Bloque en el que se busca la llave Llave buscada Salidas: N/A Valor: VERDADERO La llave se encuentra en el bloque FALSE De otra manera */ Función Busca. Llave. En. Bloque(Entrada bloque, llave) Para i = 0 a bloque. cuenta-1 Si bloque. llave[i] = llave Regresa VERDADERO Regresa FALSO

Inserta. En. Bloque /* Función: Inserta. En. Bloque Entradas: llave Llave que se va a insertar bloque Bloque en el que se va a insertar Salidas: N/A Valor: N/A */ Función Inserta. En. Bloque(Entrada llave, bloque) Si bloque. cuenta < FACTOR_BLOQUE Agrega llave en bloque Incrementa bloque. cuenta Sino Divide. Directorio Inserta(llave)

Divide. Bloque /* Función: Divide. Bloque Entradas: bloque Bloque se se va a dividir Salidas: N/A Proceso: 1. - Crea un nuevo bloque 2. - Divide las llaves entre el bloque actual y el nuevo bloque 3. - Si es necesario duplica el directorio para poder direccionar elnuevo bloque */

Divide. Bloque Función Divide. Bloque(bloque) Si bloque. nivel = Directorio. nivel Duplica. Directorio() Nuevo. Rango(bloque, inicio, fin) NRBN = Obtener. Bloque(nuevo_bloque) Para i=inicio a fin Directorio. RBN[i] = NRBN Incrementa bloque. nivel Org = 0 Dest 1 = 0 Dest 2 = 0 nuevo_bloque. cuenta = 0 Mientras Org < bloque. cuenta dir = Crea. Direccion(bloque. llave[Org], bloque. nivel) Si bit menos significativo de dir = 1 nuevo_bloque. llave[Dest 1] = bloque. llave[org] Incrementa nuevo_bloque. cuenta Incrementa Dest 1 Sino bloque. llave[Dest 2] = bloque. llave[org] Incrementa Dest 2 Incrementa Org bloque. cuenta = bloque. cuenta – nuevo_bloque. cuenta nuevo_bloque. nivel = bloque. nivel

Nuevo. Rango /* Función: Nuevo. Rango Entradas: bloque Bloque se va a dividir Salidas: inicio Primera entrada en el directorio que le corresponde a un eventual nuevo bloque. fin Ultima entrada en el directorio que le corresponde a un eventual nuevo bloque. Proceso: 1. - Esta función calcula el rango de direcciones que le corresponden a un nuevo bloque cuando se presenta una division de bloques. 2. - Si el bloque original tiene el mismo nivel que el directorio entonces el nuevo bloque tendrá un bit más que el bloque original con valor de uno. 3. - Si el nivel del bloque original es menor que el directorio, entonces al nuevo bloque le corresponden un conjunto de direcciones por lo que a inicio se le agregan ceros y a fin unos tantos hasta completar el nivel directorio. */

Nuevo. Rango Función Nuevo. Rango(Entrada bloque; Salida inicio, fin) inicio = Crea. Direccion(bloque. llave[0], bloque. nivel) Recorre inicio a la izquierda un bit Sustituye el bit menos significativa de inicio por un 1 Num. Bits = Directorio. nivel – (bloque. nivel +1) fin = inicio Repite Num. Bits veces Recorre inicio a la izquiera un bit Recorre fin a la izquierda un bit Sustituye el bit menos significativo de fin por 1

Duplica. Directorio /* Función: Duplica. Directorio Entradas: N/A Salidas: N/A Proceso: 1. - Se duplica el núemero de entradas en el directorio 2. - La direccion en la posición i se duplica en las direcciones 2*1 y 2*i+1 */ Función Duplica. Directorio Tamaño. Actual = 2 Directorio. nivel Nuevo. Tamaño = 2*Tamaño. Actual Solicita memoria para Nuevo. Directorio Para i = 0 a Tamaño. Actual – 1 Nuevo. Directorio. RBN[2*i] = Directorio. RBN[i] Nuevo. Directorio. RBN[2*i+1] = Directorio. RBN[i] Nuevo. Directorio. nivel = Directorio. nivel*2 Sustituye Directorio por Nuevo. Directorio

Encuentra. Hermano /* Función: Encuentra. Hermano Entradas: bloque Bloque del que se desea encontrar su hermano Salidas: hermano. El hermano de bloque Proceso: 1. - Un bloque tiene un hermano cuando su su nivel es el mismo que el directorio (su RBN se encuentra en una sola posición del directorio. 2. - El bloque hermano tiene la misma dirección del bloque original con el último bit invertido */ Función Encuentra. Hermano(Entrada bloque; Salida hermano) Si Directorio. nivel = 0 Regresa FALSO Si bloque. nivel < Directorio. nivel Regresa FALSE hermano = Crea. Direccion(bloque. llave[0], bloque. nivel) Invierte el bit menos significativo de hermano Regresa VERDADERO

Reduce. Directorio /* Función: Entradas: Salidas: Valor: Reduce. Directorio N/A VERDADERO El directorio se redujo FALSE El directorio no puede reducirse Proceso: 1. - Verifica que todas las direcciones por lo menos se encuentren duplicadas. 2. - Define un nuevo directorio con la mitad de entradas 3. - Asigna el valor a las entradas */

Reduce. Directorio Función Reduce. Directorio() Si Directorio. nivel = 0 Regresa FALSO Tamaño. Actual = 2 Directorio. nivel reducible = VERDADERO Para i = 0 a Tamaño. Actual – 2 paso 2 Si Directorio. RBN[i] != Directorio. RBN[i+1] reducible = FALSO Salir Si !reducible Regresa FALSO Tamaño. Nuevo = Tamaño. Actual / 2 Asigna memoria para Nuevo. Directorio Para i = 0 a Tamaño. Nuevo – 1 Nuevo. Directorio. RBN[i] = Directorio. RBN[i*2] Nuevo. Directorio. nivel = Directorio. nivel-1 Libera Directorio Asigna Nuevo. Directorio como Directorio Regresa VERDADERO

Elimina /* Función: Elimina Entradas: llave Llave que va a ser eliminada Salidas: N/A Valor: VERDADERO Se eliminó la llave FALSO No se eliminó porque ya no existía */ Función Elimina(Entrada llave) Si !Busca(llave, bloque) Regresa FALSO Elimina el llave de bloque Decrementa bloque. cuenta Intenta. Combinar(bloque) Regresa VERDADERO

Intenta. Combinar /* Función: Intenta. Combinar Entradas: bloque Bloque se intenta combinar Salidas: N/A Valor: VERDADERO El bloque se combinó con otro FALSO De otra manera */ Función Intenta. Combinar(Entrada bloque) Si !Encuentra. Hermano(bloque, hermano) Regresa FALSO Si bloque. cuenta + hermano. cuenta <= FACTOR_BLOQUE dest = bloque. cuenta Para org = 0 a hermano. cuenta-1 bloque. llave[dest] = hermano. llave[org] Incrementa dest Libera hermano dir = Crea. Direccion(hermano. llave[0]) Directorio. RBN[dir] = Directorio. RBN[dir-1] Si Reduce. Directorio() Intenta. Combinar(bloque)