UNIVERSIDAD NACIONAL DE SAN AGUSTIN

ESCUELA PROFESIONAL DE INGENIERIA DE

SISTEMAS






ESTRUCTURA DE DATOS-QUADTREE

PRESENTADO POR:
APAZA CONDORI JEFERSON JOEL
PACHECO LLACHO WILMER ALBERTO


AREQUIPA-PERU
2013



QUADTREE

Definicin.-

El trmino Quadtree se utiliza para describir clases de estructuras de datos
jerrquicas cuya propiedad comn es que estn basados en el principio de
descomposicin recursiva del espacio.

Caractersticas.-
Los QUADTREES son un tipo de estructura de datos en el que cada nodo
tiene a su vez cuatro nodos hijos, sera algo similar a un rbol binario, pero
en vez de dos ramas con cuatro ramas.
La familia Quadtree se usa para representar puntos, reas, curvas,
superficies y volmenes.
La descomposicin puede hacerse en las mismas partes en cada nivelado
(la descomposicin regular), o puede depender de los datos de la entrada.
La resolucin de la descomposicin, en otros trminos, el nmero de
tiempos en que el proceso de descomposicin es aplicado, puede tratarse
de antemano, o puede depender de las propiedades de los datos de la
entrada.
El primer ejemplo de un Quadtree se relaciona a la representacin de un
rea bidimensional.
La regin Quadtree que representa las reas es el tipo ms estudiado.
Este ejemplo es basado en la subdivisin sucesiva del espacio en cuatro
cuadrantes del mismo tamao. El sub cuadrante que contiene datos
simplemente se denomina rea Negra, y los que no contienen datos se
denominan rea Blanca. Un sub cuadrante que contiene partes de ambos se
denomina rea Ceniza. Los sub cuadrantes Ceniza, que contienen
areas Blancas y Negras (Vaco y Datos), deben subdividirse sucesivamente
hasta que solo queden cuadrantes Negros Y Blancos. (Datos y Vacos).
Cada cuadrante representa un nodo del Quadtree, los espacios negros y
blancos siempre estn en las hojas, mientras todos los nodos interiores
representan los espacios grises.






REPRESENTACIN RBOL






REPRESENTACIN ESPACIAL O MATRIZ BINARIA




OPERACIONES

INSERCIN.- Determinar el tipo de puntos en relacin al nodo padre.
Si esta vacio
Solo agregar
Sino
Insertar valor cuadrante correspondiente
ELIMINACIN.-La eliminacin se da en relacin a los nodos adyacentes
Si posee ms de un nodo adyacente en su sector.
Eliminar nodo individual
Sino
Mesclar los nodos en uno













ALGORITMO DE INSERCION
El algoritmo est basado en la subdivisin sucesiva del espacio en cuatro
cuadrantes del mismo tamao. El subcuadrante que contiene datos simplemente
se denomina ara Negra, y los que no contienen datos se denominan rea Blanca.
Un subcuadrante ceniza (gris), que contienen reas Blancas y Negras deben
subdividirse posteriormente hasta que solo queden Cuadrantes Negros y Blancos
Al final de todo el proceso de insercin cada cuadrante representa un nodo del
QuadTree, los espacios negros y blancos siempre estn en las hojas, mientras
todos los nodos interiores representan los espacios grises
LA CLASE NODO-QUAD
Cada nodo se guarda en una clase con seis campos. Los cuatro primeros campos
estn representados en el rbol como sus cuatro hijos (esto se puede interpretar
como los cuatro cuadrantes posibles que puede hacer un solo nodo), el quinto
parmetro est dado por el color del Nodo (blanco, Negro o ceniza) y el Ultimo
campo est representado como el punto (coordenada) hacia el cual se procede la
subdivisin.











IMPLEMENTACION C++ ESTRUCTURA QUADTREE

#include<iostream>
usingnamespacestd;
template<class E>
classNodoQuad{
public:
NodoQuad<E>*NW;/*NorOeste*/
NodoQuad<E>*SW;/*SurOeste*/
NodoQuad<E>*NE;/*NorEste*/
NodoQuad<E>*SE;/*SurEste*/
int color; /*blanco=0,gris=1,black=2*/
intx,y;
public:
NodoQuad();
};
template<class E>NodoQuad<E>::NodoQuad(){
NW=NULL;SW=NULL;
NE=NULL;SE=NULL;
}




INSERCION
Descripcin en seudocdigo, pas a paso, de la insercin de un punto P
1.-Si la raz es nula, P se vuelve la raz
2.-Si la raz no es GRIS, significa que hay simplemente un nodo
3.-Se realiza una bsqueda a partir de la raz para encontrar el cuadrante al cual P
pertenece









EJEMPLO DE UNA INSERCION









#include<iostream>
#includeNodoQuad.h"
usingnamespacestd;

template<class E>
class QuadTree{
private:
NodoQuad<E>*root;

public:
QuadTree();
boolisLeaf(NodoQuad<E>*);
voidinsertar(int,int,NodoQuad<E>*);
intobtenerHijo(int,int,NodoQuad<E>*);
void eliminar();
intretornar_cuadrante(NodoQuad<E>*,int,int);
};
template<class E> QuadTree<E>::QuadTree();
template<class E>boolisLeaf(NodoQuad<E>*current)
{
if(current->NE || current->NW || current->SE
|| current->SW)
returntrue;
elsereturnfalse;
}
template<class
E>intobtenerHijo(intpx,intpy,NodoQuad<E>*current)
{
if((current->x)<px){
if((current->y)<py)
return 1;
elsereturn 2;
}
else{
if((current->y)<py)
return 3;
elsereturn 4;
}
}


template<class E>voidQuadTree<E>::insertar(intpx,intpy,NodoQuad<E>*current)
{
if(isEmpty(current))
{
current->x=px;
current->y=py;
current->NW=newNodoQuad<E>();
current->SW=newNodoQuad<E>();
current->NE=newNodoQuad<E>();
current->SE=newNodoQuad<E>();

}
elseif(isLeaf(current))
{
int hijo=obtenerHijo(px,py);
switch(hijo)
{
case 1:
{
current->SE=newCQuadTree<T>(px, py);
};break;
case 2:
{
current->NE=newCQuadTree<T>(px, py);
};break;
case 3:
{
current->SW=newCQuadTree<T>(px, py);
};break;
case 4:
{
current->NW=newCQuadTree<T>(px, py);
};break;
}
}
else
{
int hijo=ObtenerHijo(px, py,current);
switch(hijo)
{
case 1:
{
insertar(px, py,current->SE);
};break;
case 2:
{
insertar(px, py,current->NE);
};break;
case 3:
{
insertar(px, py, current->SW);
};break;
case 4:
{
insertar(px, py,current->NW);
};break;
}
}
}
ALGORITMO PARA OBTENER EL CUADRANTE
Este algoritmo me devuelve un entero que representa el hijo de dicho nodo
representado por los puntos cardinales























template<class E>
intQuadTree<E>::cuadrante(NodoQuad<E>*current,intpx,intpy){
if(current->x<px){
if(current->y<py) return 3;
elsereturn 0;
}
else {
if(current->y<<py)
return 2;
elsereturn 1;
}
}

ALGORITMO DE ELIMINACION
Funcin que remueve una coordenada de la imagen














Funcin que dado una respectiva coordenada me devuelve el nodo pertenece a
dicha coordenada















publicObjectremove(doublex,doubley){
Nodenode=this.find(this.root_,x,y);
if(node!=null){
Objectvalue=node.getPoint().getValue();
node.setPoint(null);
node.setNodeType(NodeType.EMPTY);
this.balance(node);
this.count_--;
returnvalue;
}else{
returnnull;
}
}

publicNodefind(Nodenode,doublex,doubley){
Noderesposne=null;
switch(node.getNodeType()){
caseEMPTY:
break;

caseLEAF:
resposne=node.getPoint().getX()==x&&node.getPoint(
).getY()==y?node:null;
break;

casePOINTER:
resposne=this.find(this.getQuadrantForPoint(node,x
,y),x,y);
break;

default:
thrownewQuadTreeException("Invalid nodeType");
}
returnresposne;
}


Funcion que balancea el arbol una vez eliminado una coordenada





privatevoidbalance(Nodenode){
switch(node.getNodeType()){
caseEMPTY:
caseLEAF:
if(node.getParent()!=null){
this.balance(node.getParent());
}
break;
casePOINTER:{
Nodenw=node.getNw();
Nodene=node.getNe();
Nodesw=node.getSw();
Nodese=node.getSe();
NodefirstLeaf=null;
if(nw.getNodeType()!=NodeType.EMPTY){
firstLeaf=nw;
}
if(ne.getNodeType()!=NodeType.EMPTY){
if(firstLeaf!=null){
break;
}
firstLeaf=ne;
}
if(sw.getNodeType()!=NodeType.EMPTY){
if(firstLeaf!=null){
break;
}
firstLeaf=sw;
}
if(se.getNodeType()!=NodeType.EMPTY){
if(firstLeaf!=null){
break;
}
firstLeaf=se;
}

if(firstLeaf==null){
node.setNodeType(NodeType.EMPTY);
node.setNw(null);
node.setNe(null);
node.setSw(null);
node.setSe(null);
}elseif(firstLeaf.getNodeType()==NodeType.POINTER){
break;
}else{
node.setNodeType(NodeType.LEAF);
node.setNw(null);
node.setNe(null);
node.setSw(null);
node.setSe(null);
node.setPoint(firstLeaf.getPoint());
}
if(node.getParent()!=null){
this.balance(node.getParent());
}
}
break; }
}