UNIVERSIDAD NACIONAL DE SAN

AGUSTÍN

CIENCIA DE LA COMPUTACIÓN
EDA

RTree

Integrantes:
RTree

Índice
1. Introducción 2

2. RTree 2
2.1. Aplicaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

3. Implementación 3
3.1. Insert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3.2. Resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.3. Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1
RTree

1. Introducción
En este documento implementaremos una estructuras de datos de árbol utilizadas
para métodos de acceso espacial en la cual podremos indexar información multidi-
mensional como coordenadas gráficas , rectángulos y polı́gonos.
Esta estructura fue ´propuesta por Antonin Guttman en 1984 [1] y ha encontrado
un uso significativo tanto en contextos teóricos como aplicados.

2. RTree
R-tree es una estructura de datos de árbol utilizada para almacenar ı́ndices de da-
tos espaciales de manera eficiente. Los árboles R son muy útiles para consultas y
almacenamiento de datos espaciales. Algunas de las aplicaciones de la vida real se
mencionan a continuación:

Figura 1: RTree Bidimencioanl

2
 RTree

2.1. Aplicaciones
Alguna aplicaciones útiles que podemos encontrar a nuestro estructura:
Indización de información multidimensional.
Manejo de coordenadas geoespaciales.
Implementación de mapas virtuales.
Manejo de datos del juego.

3. Implementación
3.1. Insert
Buscar posición para nuevo registro Invoque ChooseLeaf para seleccionar un
nodo hoja L en el que colocar E.
[Agregar registro al nodo hoja] Si L tiene espacio para otra entrada, inserte
E De lo contrario, invoque SplitNode para obtener L y LL que contengan E y
todas las entradas antiguas de L.
Si la propagación de la división del nodo causó la división de la raı́z, cree una
nueva raı́z cuyos hijos sean los dos nodos resultantes
Seleccionamos un nodo hoja en el que colocar una nueva entrada de ı́ndice E.
Establecer N para ser el nodo raı́z.
Si N es una hoja, devuelva N..
Si N no es una hoja, deje que F sea la entrada en N cuyo rectángulo FI necesita
menos ampliación para incluir vı́nculos de resolución EI eligiendo la entrada
con el rectángulo del área más pequeña
Establezca N como el nodo hijo señalado por Fp y repita desde el segundo
paso

Listing 1: Insert
1 R e c t a n g l e ∗ nuevo = new R e c t a n g l e ( top , lower , OBJECT, a c t u a l I d )
2 a c t u a l I d ++;
3 Rectangle ∗ i t e r = root ;
4 // cout<<i t e r <<e n d l ;
5 i f ( r o o t == n u l l p t r ){

3
 RTree

6 t h i s −>r o o t = new R e c t a n g l e ( top , lower , LEAF, a c t u a l I d ) ;

7 // cout<<r o o t <<e n d l ;
8 a c t u a l I d ++;
9 r o o t −>i n s e r t ( nuevo ) ;
10 return ;
11 }
12 w h i l e ( t r u e ){
13
14
15 i f ( i t e r −>i s L e a f ( ) ) break ;
16 i t e r = getMinArea ( i t e r , nuevo ) ;
17 }
18 i t e r −>i n s e r t ( nuevo ) ;
19 R e c t a n g l e ∗ r 2 = nuevo ;
20 w h i l e ( i t e r != n u l l p t r ){
21
22 i f ( overflow ( i t e r )){
23 // s o r t ( i t e r −>r e g i o n s . b e g i n ( ) , i t e r −>r e g i o n s . end ( ) , funC
24
25
26 v e c t o r <R e c t a n g l e ∗> v1 ;
27 v e c t o r <R e c t a n g l e ∗> v2 ;
28 i n t tam = i t e r −>r e g i o n s . s i z e ( ) ;
29 v1 . r e s i z e ( tam / 2 ) ;
30 v2 . r e s i z e ( tam−tam / 2 ) ;
31
32 memcpy(&( v1 [ 0 ] ) , & ( i t e r −>r e g i o n s [ 0 ] ) , s i z e o f ( R e c t a n g l e
33
34 memcpy( v2 . data () ,& i t e r −>r e g i o n s [ tam / 2 ] , s i z e o f ( R e c t a n
35
36 R e c t a n g l e ∗ r 1 = g e n e r a t e R e g i o n ( g e n e r a t e P o i n t s ( v1 ) ) ;
37
38 r 2 = g e n e r a t e R e g i o n ( g e n e r a t e P o i n t s ( v2 ) ) ;
39 r1−>r e g i o n s = v1 ;
40 r2−>r e g i o n s = v2 ;
41
42 i f ( i t e r −>i s L e a f ( ) ) {
43 r1−>f l a g = LEAF;
44 r2−>f l a g = LEAF;
45

4
 RTree

46 }
47 i f ( i t e r −>padre == n u l l p t r ){
48 v e c t o r <R e c t a n g l e ∗> temp = { r1 , r 2 } ;
49 r o o t = g e n e r a t e R e g i o n ( g e n e r a t e P o i n t s ( temp ) ) ;
50 r o o t −>i n s e r t ( r 1 ) ;
51 r o o t −>i n s e r t ( r 2 ) ;
52 r1−>padre = r o o t ;
53 r2−>padre = r o o t ;
54 changePadre ( r 1 ) ;
55 changePadre ( r 2 ) ;
56 break ;
57 }
58
59 else{
60 R e c t a n g l e ∗ tempP = i t e r −>padre ;
61
62 i t e r −>cpy ( r 1 ) ;
63 tempP−>i n s e r t ( r 2 ) ;
64 r2−>padre = tempP ;
65 i t e r −>padre = tempP ;
66 changePadre ( i t e r ) ;
67 changePadre ( r 2 ) ;
68 i t e r = tempP ;
69 resizeRegion ( i t e r );
70
71 }
72 }
73 else{
74 resizeRegion ( i t e r );
75 i t e r = i t e r −>padre ;
76 }
77 }

5
 RTree

3.2. Resultados
Utilizando los puntos :

Listing 2: Puntos
1 RTree tree ;
2 Punto p1 ( ”p1” , 2 , 4 ) ;
3 Punto p2 ( ”p2” , 4 , 2 ) ;
4 Punto p3 ( ”p3” , 6 , 6 ) ;
5 Punto p4 ( ”p4” , 8 , 6 ) ;
6 Punto p5 ( ”p5” , 1 0 , 1 0 ) ;
7 Punto p6 ( ”p6” , 1 0 , 2 ) ;
8 Punto p7 ( ”p7” , 1 4 , 6 ) ;
9 Punto p8 ( ”p8” , 1 6 , 1 6 ) ;
10 Punto p9 ( ”p9” , 4 , 9 ) ;
11 Punto p10 ( ” p10 ” , 1 2 , 5 ) ;
12 Punto p11 ( ” p11 ” , 9 , 1 ) ;

Figura 2: RTree Bidimencioanl

3.3. Conclusiones
Tiene un coste computacional de O(logm n).
Los árboles R son más rápidos que los árboles Quad para las consultas de
vecinos más cercanos, mientras que para las consultas de ventana, los árboles
Quad son más rápidos que los árboles R.

6
RTree

La creación del ı́ndice espacial en los árboles cuádruples es más rápida en

comparación con los árboles R.