Practica 9 EDAII

Contenido
Objetivo: .............................................................................................................................................. 2
Introducción: ....................................................................................................................................... 2
Desarrollo: ........................................................................................................................................... 3
Actividad 1. ...................................................................................................................................... 3
Actividad 2 (Actividad extra). ........................................................................................................ 16
Conclusión: ........................................................................................................................................ 25
Referencias Bibliográficas: ................................................................................................................ 25
Objetivo:
El estudiante conocerá e identificará las características de los árboles B.
Introducción:
Los B-árboles surgieron en 1972 creados por R.Bayer y E.McCreight.El problema
original comienza con la necesidad de mantener índices en almacenamiento
externo para acceso a bases de datos, es decir, con el grave problema de la lentitud
de estos dispositivos se pretende aprovechar la gran capacidad de almacenamiento
para mantener una cantidad de información muy alta organizada de forma que el
acceso a una clave sea lo más rápido posible.
Como se ha visto anteriormente existen métodos y estructuras de datos que

permiten realizar una búsqueda dentro de un conjunto alto de datos en un tiempo
de orden O(log2n). Así tenemos el caso de los árboles binarios AVL.¿Por qué no
usarlos para organizar a través de ellos el índice de una base de datos? La
respuesta aparece si estudiamos más de cerca el problema de acceso a memoria
externa. Mientras que en memoria interna el tiempo de acceso a n datos situados
en distintas partes de la memoria es independiente de las direcciones que estos
ocupen(n*cte donde cte es el tiempo de acceso a 1 dato),en memoria externa es
fundamental el acceder a datos situados en el mismo bloque para hacer que el
tiempo de ejecución disminuya debido a que el tiempo depende fuertemente del
tiempo de acceso del dispositivo externo, si disminuimos el número de accesos a
disco lógicamente el tiempo resultante de ejecución de nuestra búsqueda se ve
fuertemente recortado. Por consiguiente, si tratamos de construir una estructura de
datos sobre disco es fundamental tener en cuenta que uno de los factores
determinantes en el tiempo de ejecución es el número total de accesos, de forma
que aunque dicho n&uacite;mero pueda ser acotado por un orden de eficiencia es
muy importante tener en cuenta el número real ya que el tiempo para realizar un
acceso es suficientemente alto como para que dos algoritmos pese a tener un
mismo orden, puedan tener en un caso un tiempo real de ejecución aceptable y en
otro inadmisible.
DEFINICION:
Los B-árboles son árboles cuyos nodos pueden tener un número múltiple de hijos
tal como muestra el esquema de uno de ellos en la figura 1.
Como se puede observar en la figura 1,un B-árbol se dice que es de orden m si sus
nodos pueden contener hasta un máximo de m hijos. En la literatura también
aparece que si un árbol es de orden m significa que el mínimo número de hijos que
puede tener es m+1(m claves). Nosotros no la usaremos para diferenciar el caso de
un número máximo par e impar de claves en un nodo.
El conjunto de claves que se sitúan en un nodo cumple la condición:
de forma que los elementos que cuelgan del primer hijo tienen una clave con valor
menor que K1,los que cuelgan del segundo tienen una clave con valor mayor que
K1 y menor que K2,etc...Obviamente, los que cuelgan del último hijo tienen una
clave con valor mayor que la última clave(hay que tener en cuenta que el nodo
puede tener menos de m hijos y por consiguiente menos de m-1 claves).
Desarrollo:
Actividad 1.
Código:
class Nodo:
def __init__(self, t):
self.hijos = list()
self.llaves = list()
self.hoja = 1
self.n = 0
for k in range(2*t):
self.llaves.append([None])
for k in range(2*t+1):
self.hijos.append([None])
class ArbolB:
def __init__(self, gradoMinimo):
self.t = gradoMinimo
self.raiz = None
def bTreeCreate(self):
if(self.raiz == None):
self.raiz = Nodo(self.t)
return self.raiz
def bTreeSplitShild(self, x, i):

z = Nodo(self.t)
y = x.hijos[i]
z.hoja = y.hoja
z.n = self.t-1
for j in range(1, self.t):
z.llaves[j] = y.llaves[j+self.t]
y.llaves[j+self.t] = None
if y.hoja ==0:
for j in range(1, self.t+1):
z.hijos[j] = y.hijos[j+self.t]
y.hijos[j+self.t] = None
y.n = self.t-1
for j in range(x.n+1, i, -1):
x.hijos[j+1]=x.hijos[j]
x.hijos[i+1]=z
for j in range(x.n, i-1, -1):
x.llaves[j+1] = x.llaves[j]
x.llaves[i] = y.llaves[self.t]
y.llaves[self.t] = None
x.n = x.n+1
def bTreeInsertNonFull(self, x, k):

i = x.n
if x.hoja ==1:
while (i>=1) and (ord(k)<ord(x.llaves[i])):
x.llaves[i+1] = x.llaves[i]
i = i-1
x.llaves[i+1]=k
x.n = x.n+1
else:
while (i>=1) and (ord(k)<ord(x.llaves[i])):
i=i-1
i=i+1
if x.hijos[i].n ==2*self.t-1:
self.bTreeSplitShild(x, i)
if ord(k)>ord(x.llaves[i]):
i=i+1
self.bTreeInsertNonFull(x.hijos[i], k)
def bTreeInsert(self, nodo, k):

r=self.raiz
if r.n == 2*self.t-1:
s = Nodo(self.t)
self.raiz = s
s.hoja = 0
s.n = 0
s.hijos[1] = r
self.bTreeSplitShild(s, 1)
self.bTreeInsertNonFull(s, k)
else:
self.bTreeInsertNonFull(r, k)
def imprimirNodo(self, nodo):

for i in range(1, 2+self.t, 1):
if (nodo.llaves[i] != None):
print(nodo.llaves[i])
class Controladora:
def main(self):
BT = ArbolB(2)
actual = BT.bTreeCreate()
print("Se insertara B")
BT.bTreeInsert(actual, "B")
print("Se insertara T")
BT.bTreeInsert(actual, "T")
print("Se insertara H")
BT.bTreeInsert(actual, "H")
print("Imprime raiz")
BT.imprimirNodo(BT.raiz)
print("Se insertara M")

BT.bTreeInsert(actual, "M")
print(BT.raiz.llaves)
print(BT.raiz.hijos[1].llaves)
print("Se insertara O")

BT.bTreeInsert(actual, "O")
print("Se insertara C")

BT.bTreeInsert(actual, "C")
print("Se insertara Z")
BT.bTreeInsert(actual, "Z")
print("Se insertara G")

BT.bTreeInsert(actual, "G")
print("Se insertara L")

BT.bTreeInsert(actual, "L")
print("Se insertara E")

BT.bTreeInsert(actual, "E")
print("Se insertara N")

BT.bTreeInsert(actual, "N")
print(BT.raiz.hijos[1].hijos[1].llaves)
print("Se insertara P")

BT.bTreeInsert(actual, "P")
print("Se insertara R")

BT.bTreeInsert(actual, "R")
print("Se insertara D")

BT.bTreeInsert(actual, "D")
print("Se insertara J")

BT.bTreeInsert(actual, "J")
print("Se insertara Q")
BT.bTreeInsert(actual, "Q")
print("Se insertara F")

BT.bTreeInsert(actual, "F")
print("Se insertara W")

BT.bTreeInsert(actual, "W")
print("Se insertara X")

BT.bTreeInsert(actual, "X")
obj = Controladora()
obj.main()
En las siguientes imágenes podemos ver el código en la consola.
En las siguientes tres capturas de pantalla podemos observar la ejecución de
nuestro código. Ahora se muestran los métodos que hay que ir agregando a la
clase Árbol B de acuerdo con el diagrama de clases.
Actividad 2 (Actividad extra).
Árbol puma Bus
Código:
class Nodo:
def __init__(self, t):
self.hijos = list()
self.llaves = list()
self.hoja = 1
self.n = 0
for k in range(2*t):
self.llaves.append([None])
for k in range(2*t+1):
self.hijos.append([None])
class ArbolB:
def __init__(self, gradoMinimo):
self.t = gradoMinimo
self.raiz = None
def bTreeCreate(self):
if(self.raiz == None):
self.raiz = Nodo(self.t)
return self.raiz
def bTreeSplitShild(self, x, i):
z = Nodo(self.t)
y = x.hijos[i]
z.hoja = y.hoja
z.n = self.t-1
for j in range(1, self.t):
z.llaves[j] = y.llaves[j+self.t]
y.llaves[j+self.t] = None
if y.hoja ==0:
for j in range(1, self.t+1):
z.hijos[j] = y.hijos[j+self.t]
y.hijos[j+self.t] = None
y.n = self.t-1
for j in range(x.n+1, i, -1):
x.hijos[j+1]=x.hijos[j]
x.hijos[i+1]=z
for j in range(x.n, i-1, -1):
x.llaves[j+1] = x.llaves[j]
x.llaves[i] = y.llaves[self.t]
y.llaves[self.t] = None
x.n = x.n+1
def bTreeInsertNonFull(self, x, k):
i = x.n
if x.hoja ==1:
while (i>=1) and ((k)<x.llaves[i]):
x.llaves[i+1] = x.llaves[i]
i = i-1
x.llaves[i+1]=k
x.n = x.n+1
else:
while (i>=1) and (k<x.llaves[i]):
i=i-1
i=i+1
if x.hijos[i].n ==2*self.t-1:
self.bTreeSplitShild(x, i)
if k>x.llaves[i]:
i=i+1
self.bTreeInsertNonFull(x.hijos[i], k)
def bTreeInsert(self, nodo, k):
r=self.raiz
if r.n == 2*self.t-1:
s = Nodo(self.t)
self.raiz = s
s.hoja = 0
s.n = 0
s.hijos[1] = r
self.bTreeSplitShild(s, 1)
self.bTreeInsertNonFull(s, k)
else:
self.bTreeInsertNonFull(r, k)
def imprimirNodo(self, nodo):
for i in range(1, 2+self.t, 1):
if (nodo.llaves[i] != None):
print(nodo.llaves[i])
def bTreeSearch(self, x, k):
i=1
while (i <= x.n) and (k > x.llaves[i]):
i = i+1
if (i <= x.n) and (k >= x.llaves[i]):
return i
else:
if x.hoja == True:
return None
else:
return self.bTreeSearch(x.hijos[i], k)
class Controladora:
def main(self):
BT = ArbolB(2)
actual = BT.bTreeCreate()
for i in range(1,70):
BT.bTreeInsert(actual, i)
print(BT.raiz.hijos[1].hijos[1].hijos[1].llaves)
print(BT.raiz.hijos[1].hijos[1].hijos[1].hijos[1].llaves)
print(BT.raiz.hijos[1].hijos[1].hijos[1].hijos[1].hijos[1].llaves)
print("Nodo a buscar, FI: 35")
print("El nodo a buscar se encontró en la posición: ",BT.bTreeSearch(BT.raiz, 35))
obj = Controladora()
obj.main()
En estas capturas de pantalla podemos ver nuestro codigo ya antes escrito, pero
ahora en Sublime Tex.
En las siguientes capturas de pantalla podemos ver como se implementa la
ejecución del código anterior con árboles, pero ahora con el Puma bus de ciudad
universitaria.
Conclusión:
La práctica me pareció un tanto interesante. Aunque también algo difícil de entender
el concepto de árboles ya que se utilizan cuando la cantidad de datos que se está
trabajando es demasiado grande que no cabe toda en memoria principal. Así que,
son árboles de búsqueda balanceados diseñados para trabajar sobre discos
magnéticos u otros accesos o dispositivos de almacenamiento secundario.
Finalmente podemos decir que el objetivo se cumplió.
Referencias Bibliográficas:
Cuadernillo de prácticas del laboratorio de practicas de Estructura de Datos y Algoritmos II.

Practica 9 EDAII

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Practica 9 EDAII

Cargado por

Copyright:

Formatos disponibles

Contenido

Como se ha visto anteriormente existen métodos y estructuras de datos que

El conjunto de claves que se sitúan en un nodo cumple la condición:

def bTreeSplitShild(self, x, i):

def bTreeInsertNonFull(self, x, k):

def bTreeInsert(self, nodo, k):

def imprimirNodo(self, nodo):

print("Se insertara M")

print("Se insertara O")

print("Se insertara C")

print("Se insertara G")

print("Se insertara L")

print("Se insertara E")

print("Se insertara N")

print("Se insertara P")

print("Se insertara R")

print("Se insertara D")

print("Se insertara J")

print("Se insertara F")

print("Se insertara W")

print("Se insertara X")

def __init__(self, t):

def __init__(self, gradoMinimo):

def bTreeSplitShild(self, x, i):

for j in range(1, self.t):

for j in range(1, self.t+1):

for j in range(x.n+1, i, -1):

for j in range(x.n, i-1, -1):

def bTreeInsertNonFull(self, x, k):

while (i>=1) and ((k)<x.llaves[i]):

while (i>=1) and (k<x.llaves[i]):

def bTreeInsert(self, nodo, k):

def imprimirNodo(self, nodo):

for i in range(1, 2+self.t, 1):

def bTreeSearch(self, x, k):

while (i <= x.n) and (k > x.llaves[i]):

print("Nodo a buscar, FI: 35")

print("El nodo a buscar se encontró en la posición: ",BT.bTreeSearch(BT.raiz, 35))

También podría gustarte

def init(self, t):

def init(self, gradoMinimo):