Está en la página 1de 52

Estructura de Datos En C++

Dr. Romeo Sánchez Nigenda.


E-mail: romeo.sanchez@gmail.com
http://yalma.fime.uanl.mx/~romeo/
Oficina: 1er. Piso del CIDET. Oficina con Dr. Oscar Chacón
Horas de Tutoría: 10am-11am Martes y Jueves,
3:30pm-4:30pm Miércoles, 2:00pm-4:00pm Viernes.

Website: http://yalma.fime.uanl.mx/~romeo/ED/2011/
Sesiones: 48
Material de apoyo:
Estructura de Datos con C y C++.
Yedidyah Langsam, Moshe J. Augenstein, Aaron M. Tenenbaum, Brooklyn College
Segunda Edición, Prentice-Hall.

Algorithms. Third Edition.


Parts 1-4, Fundamentals Data Structures Sorting Searching
Robert Sedgewick.

Estructura de Datos.
Román Martínez, Elda Quiroga.
Thomson Learning.

Cualquier libro de Estructura de Datos!

Software:
Compiladores GCC (GNU Compiler Collection)

IDEs (Integrated Development Environment):


http://www.eclipse.org/downloads/
http://kdevelop.org/
http://www.bloodshed.net/devcpp.html
6. Árboles

 Objetivo: El alumno entenderá y aprenderá las estructuras


de datos no lineales y dinámicas más importantes en
computación.

 Temario:
◦ Árboles en general
◦ Árboles binarios
◦ Árboles balanceados
◦ Árboles multicaminos
Árboles
 En Informática, los árboles son abstracciones matemáticas que
juegan un rol central en el diseño y análisis de algoritmos, porque:
◦ Los usamos para describir propiedades dinámicas de los algoritmos
◦ Construimos estructuras de datos que son realizaciones concretas de
árboles.

 Podemos concluir que un árbol es entonces una estructura de


datos que mantiene un conjunto de nodos conectados (imitando la
forma de un árbol).

 Encontramos muchos ejemplos de árboles en nuestra vida diaria:


◦ Organización de torneos deportivos
◦ Árboles familiares (ascendientes y descendientes)
◦ Organigramas de corporaciones
◦ Procesamiento de lenguaje natural
◦ Organización de sistemas de archivos (directorios y archivos)
Árboles
 Existen diferentes tipos de árboles:
◦ Árboles en general
◦ Árboles binarios (AVL, Rojo-Negro, AA)
◦ Árboles balanceados
◦ Árboles multi-caminos (B, B+, B*)

 En general un árbol es un conjunto de vértices y aristas que satisfacen


ciertos requisitos.
◦ Un vértice es un objeto simple, también denominado nodo, que contiene información.
◦ Una arista (o arco) es una conexión entre dos vértices
◦ Un camino (o ruta) en un árbol es una lista de vértices distintos, en los que cada uno de
ellos se encuentran conectados sucesivamente por aristas en el árbol.

 La propiedad definitoria de un árbol es que existe solamente un camino o


ruta conectando un par de nodos. Si hay más de un camino entre dos
nodos, o si no hay un camino entre un par de nodos, entonces lo que
tenemos es un Grafo.
Árboles: Terminología
 Un nodo por lo tanto, es la unidad sobre la que se construye el árbol, y
puede tener cero o más nodos hijos conectados a él (por medio de
aristas) esta propiedad se le denomina grado.

 Se dice que un nodo a es padre de un nodo b (o b es hijo de a) si existe un


enlace desde a hasta b.

 Un árbol solo puede tener un único nodo sin padres, al cual se le


denomina raíz. En un árbol con raíz, cualquier nodo es la raíz de un
subárbol, el cual consiste de sí mismo y de los nodos descendientes de él

 Un nodo que no tiene hijos se le denomina hoja o terminal.

 El resto de los nodos se les conoce como rama, ya que tienen padre y
uno o varios hijos.
Árboles
 En computación, usualmente se usa el término árbol para referirse a un
árbol con raíz. Mientras que se asume el término árbol libre para
referirse a la estructura más general.

 Las aristas en un árbol no tienen dirección, usualmente se menciona que


se encuentran apuntando hacia la raíz o fuera de ella. Y usualmente se
coloca a la raíz en la cima del árbol.

 Un árbol ordenado es un árbol con raíz en el cual el orden de los nodos


descendientes (hijos) sigue un patrón determinado

 Si cada nodo debe tener un número determinado de hijos en un orden


específico, entonces tenemos un árbol de M-aristas. El árbol de M-aristas
más simple es el árbol binario.
Árboles: Definición General
 Caso base: Un árbol con un solo nodo, el cual es a la vez la raíz del árbol
y una hoja.

 Un árbol a partir de un nodo raíz R y k árboles A1, A2, A3,…, Ak con


raíces n1, n2, n3, …, nk respectivamente, y N1, N2, N3,…, Nk nodos cada
uno.

 El árbol resultante de N = 1 + N1 + N2 + N3 +…+Nk nodos tiene como


raíz al nodo R, por lo que los nodos n1, n2, n3, …, nk son los hijos de R.

 A cada uno de los árboles Ai se les denota como subárboles de la raíz.

 Un recorrido es una sucesión de nodos del árbol de tal forma que entre
cada dos nodos consecutivos de la sucesión hay una relación de
parentesco.
Árboles: Definición General
 Existen dos recorridos típicos para listar los nodos de un árbol: en
profundidad y en anchura.

 En profundidad (depth-first) listamos los nodos expandiendo primero


el hijo actual de cada nodo hasta llegar a una hoja, al llegar a una hoja
regresamos al nodo anterior probando el siguiente hijo, y así
sucesivamente.

 En anchura (breadth-first), antes de recorrer los nodos del nivel d+1


(profundidad de d+1 aristas desde la raíz), se listan todos los nodos del
nivel d.
Árboles: Ejemplos
Árboles Binarios
 Un árbol binario es un conjunto finito de elementos que está vacío o
dividido en tres subconjuntos:
1. El primer subconjunto contiene un elemento único, la raíz del árbol,
2. Un subárbol binario izquierdo que puede o no estar vacío
3. Un subárbol binario derecho equivalente al izquierdo

 En otras palabras, un árbol binario es un nodo externo, o un nodo


interno conectado a un par de árboles binarios, los subárboles izquierdo
y derecho. raíz
ancestro
izq der

descendiente hermanos

hoja
Árboles Binarios
 Nivel de un árbol binario: La raíz del árbol tiene el nivel 0, y el nivel de
cualquier otro nodo en el árbol es uno más el nivel de su padre.
Nivel = 0

Nivel = 1
Nivel = 2
Nivel = 3
Profundidad

Nivel = 0  Árbol binario completo: Es un árbol


1 binario que tiene todos sus nodos
Nivel = 1 completos en cada subárbol a una
nodos 2
profundidad d.
4 Nivel = 2
d  Si un árbol binario contiene m
2l nodos por nivel, por lo tanto la nodos en el nivel l, entonces
Cantidad de nodos en un árbol de contiene un máximo de 2m nodos
Profundidad d es igual a la suma de en el nivel l+1.
Los nodos por nivel:
N = 20 + 21 + … + 2d = ∑d 2j = 2d+1 - 1
j=0
Árboles Binarios: Operaciones
 Entre las aplicaciones más comunes tenemos:
◦ Dado un apuntador p a un nodo en un árbol binario

Null
father(p) : Retorna un info(p) : Retorna el contenido del
apuntador al padre del nodo nodo, en este ejemplo es a
p
a right(p) : Retorna un apuntador
left(p) : Retorna un apuntador
al hijo izquierdo del nodo b al hijo derecho del nodo
c

d e f g
isLeft(d) = true isLeft(e) = false isRight(g) = true

brother(p) : Retorna un apuntador al hermano del nodo.

Note que si no existe un nodo que satisfaga cualquiera de las funciones anteriores, se
retorna un nulo (null) entonces.

Las funciones lógicas isLeft(p) y isRight(p) retornan true si p se encuentra en el


lado izquierdo o derecho de algún otro nodo respectivamente, false sino es el caso.
Árboles Binarios: Operaciones
 Las funciones isLeft(p), isRight(p), y brother(p),
se implementan usando la funcionalidad de
left(p), right(p), y father(p). Ejemplo:

Bool isLeft(p) isLeft(a) ?


q = father(p) a

if(q == null) isLeft(b) ? b c isLeft(c) ?


return false;
d e f g
if(left(q) == p)
return true;
return false; Implementa isRight(p)!
Árboles Binarios: Operaciones
brother(p) father
a
if(father(p) == null)
b c brother(c) ?
return null;
if(isLeft(p)) d e f g

return right(father(p))
return left(father(p))

Operaciones adicionales:
-makeTree(p) : Crea un árbol binario con un nodo único (raíz)
- setLeft(p, x) : Establece un nodo x como hijo izquierdo de otro nodo p,
siempre y cuando p no tenga un hijo del lado izquierdo ya establecido.
- setRight(p, x) : Similar a la función anterior.
Árboles Binarios: Aplicación de Ejemplo
 Los árboles binarios son útiles cuando se toman decisiones en dos
sentidos en cada punto del proceso.
 Ejemplo: Encontrar todos los duplicados en una lista de números:
{15,4,8, 7, 4, 3, 19, 5, 7, 9, 16, 5,17}
 Algoritmo: Primer elemento es la raíz, subsecuentes elementos se
colocan a la izquierda si son menores o a la derecha si son mayores.
Si son duplicados no se insertan pero se reportan.

15 15 15 15 15

4 4 4 4 4

8 8 3 8

7 7
Árboles Binarios: Aplicación de Ejemplo
{15,4,8, 7, 4, 3, 19, 5, 7, 9, 16, 5,17}

15 15 15

4 19 4 19 4 19

3 8 3 8 3 8 16

7 7 7 9 17

5 5
Árboles Binarios: Aplicación de Ejemplo
Pseudocódigo:
15
int numbers[13] = {15,4,8, 7, 4, 3, 19, 5, 7, 9, 16, 5,17};
tree = makeTree(numbers[0]);
for(int i=1;i<length(numbers);i++){
4 19
p = q = tree;
while(numbers[i] !=info(p) && q!=NULL){
p = q;
if(numbers[i]<info(p)) 3 8 16
q = left(p);
else
q = right(p); 7 9 17
}
if(numbers[i] == info(p))
cout<<“Numero repetido”; 5
else if(numbers[i] < info(p))
setleft(p,numbers[i]);
else
setright(p, numbers[i]);
}
Ejemplo 2: Expresiones
 La raíz del árbol binario contiene un operador que se aplicará a la
evaluación de las expresiones representadas por sus subárboles
izquierdo y derecho.
 Los operandos son únicamente hojas en el árbol
+
$

A *
+ *

A+B*C B C
A * + C

B C A B

+ C
(A+B*C)$((A+B)*C)

A B (A+B)*C
Representación básica de un árbol binario
struct tnode {
int info;
struct tnode * father; //No necesario
struct tnode * left;
struct tnode * right; Info L F R
};
p
typedef struct tnode * TNODEPTR;

TNODEPTR createNode() {
TNODEPTR p = (TNODEPTR)
malloc(sizeof(struct tnode));
return p;
}

void freeNode(TNODEPTR P) {
free( p);
}
Representación básica de un árbol binario
TNODEPTR makeTree(int x) {
TNODEPTR root = createNode();
root->info = x;
root->father = NULL;
root->left = NULL; X NULL NULL NULL
root->right = NULL;
return root;
}
TNODEPTR father(TNODEPTR pNode) {
return pNode->father;
}

TNODEPTR leftChild(TNODEPTR pNode)


{
return pNode->left;
}

TNODEPTR rightChild(TNODEPTR pNode)


{
return pNode->right;
}
Representación básica de un árbol binario
void setLeftChild(TNODEPTR pNode, int x) {
if (pNode == NULL)
cout << "Error, padre es nulo!" << endl;
else if (leftChild(pNode) != NULL)
cout << "Error, hijo izquierdo presente!“;
else {
pNode ->left = makeTree(x);
pNode ->left ->father = pNode;
}
}
pNode pNode pNode
Y N N N X N N N Y N N Y N N
makeTree(x);

X N N N X N N

pNode->left=…

pNode ->left ->father = pNode;

void setRightChild(TNODEPTR pNode, int x){…} //Es similar


Representación básica de un árbol binario

bool isLeft(TNODEPTR pNode) {


if (pNode == NULL)
return false;
else if (father(pNode) == NULL)
return false;
else
return (leftChild(father(pNode)) == pNode);
}

bool isRight(TNODEPTR pNode) {


if (pNode == NULL)
return false;
else if (father(pNode) == NULL)
return false;
return (rightChild(father(pNode)) == pNode);
}
Representación básica de un árbol binario

TNODEPTR sibling(TNODEPTR pNode) {


if (pNode == NULL)
return NULL;
if (father(pNode) == NULL)
return NULL;
if (isLeft(pNode))
return rightChild(father(pNode));
else
return leftChild(father(pNode));
}

father
a

b c sibling(c) ?

d e f g
Árbol binario de búsqueda u ordenado
 El ejemplo anterior introdujo el árbol binario de búsqueda o
árbol binario ordenado

 Este tipo de árbol tiene todos sus nodos en orden, para cada
nodo X:
◦ Todos los elementos de su árbol izquierdo son menores o iguales a X,
◦ Mientras los nodos en su árbol derecho son mayores a X.

 En promedio, un árbol binario ordenado puede localizar un


nodo en un árbol de N nodos en tiempo log(N).
Búsqueda en un árbol binario ordenado 15

//Dado un árbol binario, retorna 4 19


//verdadero si el dato buscado se
//encuentra en el árbol, o falso si no
bool find(TNODEPTR pNode, int data){
//Caso base:arbol vacio 3 8 16
if(pNode==NULL){
return false;
} else{
7 9 17
//Dato es encontrado
if(pNode->info==data){
return true;
}else{ 5
if(data<pNode->info){
//Recursa a la izq si es menor
return find(pNode->left,data);
} else{
//Recursa a la derecha si es mayor
return find(pNode->right,data);
}
}
}
}
Inserción en un árbol binario ordenado 15

4 19
//Dado un árbol binario, inserta un
//nuevo nodo en el lugar correcto del arbol.
TNODEPTR insert(TNODEPTR pNode, int data){ 3 8 16
//1: Si el arbol esta vacio retorna
//un nodo unico
if(pNode==NULL){
return makeTree(data); 1 7 9 17
} else{
//Recursa hacia abajo del arbol
//Para encontrar el lugar correcto 5
if(data<=pNode->info){
pNode->left = insert(pNode->left, data);
}else{
pNode->right = insert(pNode->right, data);
}
//Retorna el nodo original sin cambiar
return(pNode);
}
}
Árbol binarios: Ejercicio simple
 Escribe código que implemente el siguiente árbol binario:
a) Llamando a makeTree tres veces
2 y usando tres variables puntero.
TNODEPTR build123(){
TNODEPTR one, two three;
one = makeTree(1);
1 3
two = makeTree(2);
three = makeTree(3);
two->left = one;
two->right = three;
b) Llamando a makeTree tres veces return two
y usando una variable puntero. }

TNODEPTR build123(){ b) Llamando a insert tres veces,


TNODEPTR two;
two = makeTree(2); pasándole la raíz del árbol.
two->left = makeTree(1);
TNODEPTR build123(){
two->right = makeTree(3);
TNODEPTR root=NULL;
return two
root = insert(root,2);
}
root = insert(root,1);
root = insert(root,3);
return root;
}
Árbol binarios: Ejercicio simple
 Implementa la función size que calcula el número de
nodos en un árbol binario.
int size(TNODEPTR pNode){
if(pNode==NULL){
return 0;
}else{
return (size(pNode->left)+
1 +
size(pNode->right));
}
}
 Dado un árbol binario ordenado no nulo, implementa
una función que retorne el valor mínimo en el árbol
int minimum(TNODEPTR pNode){
TNODEPTR current = pNode;
while(current->left!=NULL)
current = current->left
}
return current->info;
}
Recorrido de árboles binarios
 Recorrer un árbol binario significa visitar la raíz y recorrer sus
subárboles izquierdo y derecho de forma recursiva.
 Orden previo:
1. Visitar la raíz
2. Recorrer el subárbol izquierdo en orden previo
3. Recorrer el subárbol derecho en orden previo
void recorridoPreorden(TNODEPTR pNode){
1 A if(pNode!=NULL){
cout<<"Node: "<<pNode->info;
recorridoPreorden(pNode->left);
B C recorridoPreorden(pNode->right);
2 5 }
}

3 D 6 E F 9
ABDGCEHIF
4 G H I

7 8
Recorrido de árboles binarios
 Orden Simétrico/Inorden:
1. Recorrer el subárbol izquierdo en orden simétrico
2. Recorrer la raíz
3. Recorrer el subárbol derecho en orden simétrico

void recorridoInorden(TNODEPTR pNode){


if(pNode!=NULL){
recorridoPreorden(pNode->left);
4 A cout<<"Node: "<<pNode->info;
recorridoPreorden(pNode->right);
}
}
3 B 8 C

1 D 6 E F 9
DGBAHEICF

2 G H I

5 7
Recorrido de árboles binarios
 Orden Posterior:
1. Recorrer el subárbol izquierdo en orden posterior
2. Recorrer el subárbol derecho en orden posterior
3. Recorrer la raíz

void recorridoPostorden(TNODEPTR pNode){


if(pNode!=NULL){
A
recorridoPreorden(pNode->left);
9 recorridoPreorden(pNode->right);
cout<<"Node: "<<pNode->info;
}
3 B 8 C }

2 D 6 E F 7
GDBHIEFCA

1 G H I

4 5
Remoción en un árbol binario ordenado
15 15

 Se presentan tres casos:


◦ El nodo a suprimir no tiene hijos: Se elimina el 4 19 4 19

nodo del árbol sin mayores ajustes

3 8 16 8 16

15 15

◦ Si el nodo a suprimir sólo tiene un subárbol: Su 4 19 8 19

único hijo se mueve hacia arriba y ocupa su lugar


8 16 16

15

◦ El nodo a suprimir tiene dos subárboles: Su 4 23


19

sucesor de orden intermedio S (o


antecesor) debe ocupar su lugar. El sucesor
3 8 16 25
intermedio es el nodo hijo más a la izquierda en
su árbol derecho. Dicho nodo no puede tener
un subárbol izquierdo. El antecesor sería el nodo 18 23
24
hijo más a la derecha de su árbol izquierdo.

24
Remoción en un árbol binario ordenado
void deleteNode(TNODEPTR tree, int x) 15 15
{
TNODEPTR p = tree, q = NULL, rp;
4 19 4 19
while (p != NULL && p->info != x) {
q = p;
3 8 16 8 16
p = (x < p->info) ? p->left :
p-> right;
15 15
}
if (p == NULL) return;
4 19 8 19
if (p->left == NULL)
rp = p-> right;
8 16 16
else if (p-> right == NULL)
rp = p->left; 15

else { 4 23
19
TNODEPTR f = p;
rp = p-> right; 3 8 16 25
TNODEPTR s = rp->left;
while (s != NULL) {
18 23
24
f = rp;
rp = s; 24

s = rp->left;
Árboles Balanceados
 La altura (profundidad) de un árbol binario es el nivel
máximo de sus hojas

 Un árbol binario balanceado o árbol AVL es aquel en el


que las alturas de los dos subárboles de cada nodo nunca
difieren en más de 1.

 El balance de un nodo en un árbol binario se define como


la altura de su subárbol izquierdo menos la altura de su
subárbol derecho.

 Por lo tanto, cada nodo en un árbol AVL tiene un balance


de 1, -1 o 0, dependiendo de si la altura de su subárbol
izquierdo es mayor que, menor que o igual a la altura del
derecho.
Árboles Balanceados
-1

0
1

0 1 -1
0

0 0 0
0 0 0

0 0
0 0

Factor de Equilibrio (FE): Cada nodo en un árbol AVL tiene un balance de 1, -1 o


0, dependiendo de si la altura de su subárbol izquierdo es mayor que, menor que
o igual a la altura del derecho.

Si el FE>=2, es necesario reequilibrar el árbol.


Árbol AVL
 Debido a que los árboles están balanceados, la
complejidad de búsqueda de un elemento es del orden
O(log n).

 Las operaciones en un árbol AVL balanceado son las


mismas que en un árbol binario de búsqueda
desequilibrado, pero si al insertar o borrar elementos
el árbol pierde su balance entonces se rotan los nodos
para equilibrar de nuevo el árbol.

 El propósito de la rotación es que el recorrido de


orden intermedio del árbol rotado sea el mismo que
para el árbol original (es decir, el árbol rotado sigue
siendo un árbol de búsqueda binaria).
Árbol AVL: Representación
Cada nodo debe contener, además de los datos, su factor
de equilibrio y los punteros hacia sus hijos.

Por ejemplo:
P = {data=10, left=7, right=15, FE=2}

p
10

7 15

5 8

2 6
Árbol AVL: Rotaciones
7

5 10 2,5,6,7,8,10,15

2 6 8 15

10

7 15
2 7

5 8
6 10 2,5,6,7,8,10,15
Recorrido Inorder
8 15 2 6

Rotación derecha Rotación izquierda


Algoritmo de Rotación Izquierda
r
q = right(p); 10
p temp = left(q);
left(q) = p; p r’
7 right(p) = temp 7 15

l r l lr’
5 10 5 8

lr’ r’
2 6 8 15
2 6

Rotación izquierda

Dado un árbol de raíz p, y de hijo izquierdo l y derecho r, se forma un nuevo


árbol cuya raíz sea la raíz del hijo del lado derecho (es decir r), y como su hijo
derecho le colocamos el hijo derecho que tenía anteriormente (es decir r’).

Del lado izquierdo de la nueva raíz r, colocamos a la raíz anterior p, teniendo


como raíz de su subárbol derecho el hijo izquierdo lr’ de la nueva raíz r’.
Rotaciones Dobles 12
r

p r’
Si la inserción se produce en el hijo derecho (lr’) del 7 15

hijo izquierdo (p) del nodo desequilibrado (r) o


viceversa , se realizará una doble rotación. l lr’
5 9

Rotación Doble a la Derecha: Primero es


una rotación simple a la izquierda, y luego
rotación simple a la derecha. 2 6 8 10

12
Rotación a Rotación a
la izquierda la derecha 9
9 15

7 12
7 10

5 8 10 15
5 8

2 6
2 6
Casos de Inserción
 La inserción funciona como si fuera un árbol de búsqueda
binario desequilibrado, retrocediendo hacia la raíz y rotando
sobre cualquier nodo no balanceado.

Nuevo nodo

Caso 1: Izquierda Solución: Rotación Derecha

* Imágenes tomadas de Wikimedia bajo licencia de documentación libre GNU


Casos de Inserción
 Caso 2: Derecha

Nuevo nodo
Solución: Rotación Izquierda

* Imágenes tomadas de Wikimedia bajo licencia de documentación libre GNU


Casos de Inserción
 Caso 3: Izquierda-Derecha Solución: Rotación doble

Rotación Izquierda Rotación Derecha

* Imágenes tomadas de Wikimedia bajo licencia de documentación libre GNU


Casos de Inserción
 Caso 4: Derecha-Izquierda Solución: Rotación doble

Rotación Derecha Rotación Izquierda

* Imágenes tomadas de Wikimedia bajo licencia de documentación libre GNU


Árboles Multicaminos
 Un árbol multi-camino o multi-direccional de
orden n, es un árbol general en el cual cada nodo
tiene n o menos subárboles, y contiene una llave
(key) menos que subárboles.
 Sea A un árbol de n-caminos si y solo si:
I. A está vacío
II. A puede tener hasta n subárboles S0, S1, S2, …, Sn-1 en
cada nodo
III. Dado n subárboles para un nodo p de A; p tiene Kn-2
llaves en orden. Es decir, cada nodo contiene una llave
menos que subárboles
IV. Todas las llaves en el subárbol S0 son menores que o
iguales a K0, mientras todas las llaves en los subárboles
Sj (1<j<n-2) son mayores que Kj-1.
V. Todas las llaves en el subárbol Sn-1 son mayores que las
llaves kn-2.
Árboles Multicaminos: Nodos
Nodo A
Cantidad variable de apuntadores Cantidad variable de llaves

S0 K0 … Kj-1 Sj Kj … Kn-2 Sn-1

X X X

X < K0 Kj-1 < X < Kj X > Kn-2


Árboles Multicaminos: Ejemplos
Árbol multicamino de orden 4.
Máxima cantidad de llaves es 3
A
12 50 85

B C D E
6 10 37 60 70 80 100 120 150

F G H
25 62 65 69 110
Árboles Multicaminos: Operaciones Básicas
 numTrees(p): Dado un nodo multicamino p, retorna el número de hijos
(subárboles) de p (0<=numTrees(p)<=n). Donde n es el orden o grado del árbol.
 child(p,i): Retorna el i_ésimo hijo del nodo p. Donde 0<=i<numTrees(p)-1.
 key(p,j): Retorna la j_ésima llave del nodo p. Donde 0<=j<numTrees(p)-2 son las
llaves en orden ascendente

numTrees(A) => 4
A key(A,2)
key(A,0)
12 50 85

child(A,0) child(A,3)

B C D E

60 70 80 100 120 150


6 10 37
Árboles Multicaminos: Operaciones Básicas
child(p,i) para
1<=i<=numTrees(p)-2, contiene
todas las llaves en el árbol
entre key(p, i-1) y key(p,i).

A child(p, numTrees(p)-1) apunta


key(A,0) key(A,2)
child(p,0) apunta a un a un subárbol que contiene
subárbol cuyas llaves son 12 50 85 únicamente llaves mayores a
todas menores que la llave key(p, numTrees(p)-2).
key(p,0).

B C D E
60 70 80 100 120 150
6 10 37

child(A,0): Las child(A,3): Las


llaves de este llaves de este nodo:
nodo {6,10} < 12 {100,120, 150} > 85
Árboles Multicaminos: Operaciones Básicas
 Recorrido: Impresión de llaves en orden
ascendente.

traverse(T node){
if(node != NULL){
nt = numTrees(node); nt = 4
for(i = 0; i<nt-1; i++){ 0<=i<3
traverse(son(node,i));
key(A,0), Key(A,1), Key(A,2)
cout<<key(node, i); A
}
12 50 85
traverse(son(node,nt-1));
}
son(A,0) son(A,1) son(A,2) son(A,3)
}
B C D E
60 70 80 100 120 150
6 10 37
Árboles Multicaminos: Operaciones Básicas
 Acceso secuencial directo: Accede a la siguiente llave partiendo de
otra que se le conoce su posición en el árbol. Asumimos que la llave
que conocemos se encuentra en Key(node, index)

next(T node, int index){ succesor(T node, int index){


p = son(node, index+1); p = son(node, index+1);
q = null; if(p!=NULL && index<numTrees(node)-2)
while(p != NULL){ return (next(p,index));
q = p; f = father(node);
p = son(p,0); i = index(node);
} while(f != NULL&& i==numTrees(f) -1){
if (q!=NULL) i = index(f);
return key(q,0); f = father(f);
if(index < numTrees(node)-2) }
return key(node, index+1); if (f==NULL)
return (NULL); return (NULL);
} return (key(f,i));
}

También podría gustarte