Estructura de Datos En C++ Dr. Romeo Sánchez Nigenda. E-mail: [email protected] romeo/...

Estructura de Datos En C++

Dr. Romeo Sánchez Nigenda.E-mail: [email protected]://yalma.fime.uanl.mx/~romeo/Oficina: 1er. Piso del CIDET. Oficina con Dr. Oscar ChacónHoras 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

http://yalma.fime.uanl.mx/~romeo/




http://yalma.fime.uanl.mx/~romeo/ED/2011/

Material de apoyo:Estructura de Datos con C y C++. Yedidyah Langsam, Moshe J. Augenstein, Aaron M. Tenenbaum, Brooklyn CollegeSegunda Edición, Prentice-Hall.

Algorithms. Third Edition.Parts 1-4, Fundamentals Data Structures Sorting SearchingRobert 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)

ÁrbolesExisten 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.

izq der

hoja

descendiente

ancestro

hermanos

raíz

Á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 = 3Profundidad

Nivel = 0

Nivel = 1

Nivel = 2

Árbol binario completo: Es un árbol binario que tiene todos sus nodos completos en cada subárbol a una profundidad d.

Si un árbol binario contiene m nodos en el nivel l, entonces contiene un máximo de 2m nodos en el nivel l+1.

4

2

1

nodos

2l nodos por nivel, por lo tanto la Cantidad de nodos en un árbol de Profundidad d es igual a la suma de Los nodos por nivel:N = 20 + 21 + … + 2d = ∑d 2j = 2d+1 - 1

j=0

d

Árboles Binarios: Operaciones Entre las aplicaciones más comunes tenemos:

◦ Dado un apuntador p a un nodo en un árbol binario

a

b c

fed g

p

info(p) : Retorna el contenido del nodo, en este ejemplo es a

right(p) : Retorna un apuntadoral hijo derecho del nodo

left(p) : Retorna un apuntadoral hijo izquierdo del nodo

father(p) : Retorna un apuntador al padre del nodo

Null

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.

isLeft(d) = trueisLeft(e) = falseisRight(g) = true

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)q = father(p)if(q == null)

return false;if(left(q) == p)

return true;return false;

Árboles Binarios: Operaciones

a

b c

fed g

isLeft(a) ?

isLeft(b) ? isLeft(c) ?

Implementa isRight(p)!

brother(p)if(father(p) == null)

return null;if(isLeft(p))

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

Árboles Binarios: Operaciones

a

b c

fed g

brother(c) ?

father

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.

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.

Árboles Binarios: Aplicación de Ejemplo

15

15

4

15

4

8

15

4

8

7

4

15

4

8

7

3

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

15

4

8

7

3

19

15

4

8

7

3

19

5

…

15

4

8

7

3

19

5

9

16

17

Árboles Binarios: Aplicación de Ejemplo

15

4

8

7

3

19

5

9

16

17

Pseudocódigo:

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++){ p = q = tree; while(numbers[i] !=info(p) && q!=NULL){

p = q;if(numbers[i]<info(p)) q = left(p);else q = right(p);

} if(numbers[i] == info(p))

cout<<“Numero repetido”; 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

C

*

BA+B*C

*

C

B

+

A (A+B)*C

$

+

*

B

A

*

C

+

A B

C

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

Representación básica de un árbol binariostruct tnode {int info;struct tnode * father; //No necesariostruct tnode * left;struct tnode * right;};

typedef struct tnode * TNODEPTR;

TNODEPTR createNode() {TNODEPTR p = (TNODEPTR)

malloc(sizeof(struct tnode));return p;

}

void freeNode(TNODEPTR P) {free( p);}

Info

L F R

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;root->right = NULL;return root;

}

X NULL NULL NULL

TNODEPTR father(TNODEPTR pNode) {return pNode->father;

}

TNODEPTR leftChild(TNODEPTR pNode) {

return pNode->left;}

TNODEPTR rightChild(TNODEPTR pNode) {

return pNode->right;}


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

X N N NY N N N

makeTree(x);

pNode->left=…

Y N N

X N N N

pNode

Y N N

X N N

pNode

pNode ->left ->father = pNode;

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


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);

}


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));}

a

b c

fed g

sibling(c) ?

father

Árbol binario de búsqueda u ordenadoEl 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

4

8

7

3

19

5

9

16

17

//Dado un árbol binario, retorna//verdadero si el dato buscado se //encuentra en el árbol, o falso si nobool find(TNODEPTR pNode, int data){

//Caso base:arbol vacioif(pNode==NULL){ return false;} else{ //Dato es encontrado if(pNode->info==data){

return true; }else{

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

8

7

3

19

5

9

16

17

//Dado un árbol binario, inserta un //nuevo nodo en el lugar correcto del arbol. TNODEPTR insert(TNODEPTR pNode, int data){

//1: Si el arbol esta vacio retorna//un nodo unicoif(pNode==NULL){ return makeTree(data);} else{ //Recursa hacia abajo del arbol //Para encontrar el lugar correcto 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);}

}

1

Árbol binarios: Ejercicio simpleEscribe código que implemente el siguiente árbol binario:

2

1 3

a) Llamando a makeTree tres veces

y usando tres variables puntero.

b) Llamando a makeTree tres veces

y usando una variable puntero.

b) Llamando a insert tres veces,

pasándole la raíz del árbol.

TNODEPTR build123(){ TNODEPTR two; two = makeTree(2); two->left = makeTree(1); two->right = makeTree(3); return two}

TNODEPTR build123(){ TNODEPTR one, two three; one = makeTree(1); two = makeTree(2); three = makeTree(3); two->left = one; two->right = three; return two}

TNODEPTR build123(){ TNODEPTR root=NULL; root = insert(root,2); root = insert(root,1); root = insert(root,3); return root;}

Implementa la función size que calcula el número de nodos en un árbol binario.

Árbol binarios: Ejercicio simple

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íz2. Recorrer el subárbol izquierdo en orden previo3. Recorrer el subárbol derecho en orden previo

A

B

G

D

C

H

E

I

F ABDGCEHIF

1

2

3

4

5

6

7 8

9

void recorridoPreorden(TNODEPTR pNode){if(pNode!=NULL){cout<<"Node: "<<pNode->info;recorridoPreorden(pNode->left);recorridoPreorden(pNode->right);}

}

Recorrido de árboles binarios Orden Simétrico/Inorden:

1. Recorrer el subárbol izquierdo en orden simétrico2. Recorrer la raíz3. Recorrer el subárbol derecho en orden simétrico

A

B

G

D

C

H

E

I

F DGBAHEICF

4

3

1

2

8

6

5 7

9

void recorridoInorden(TNODEPTR pNode){if(pNode!=NULL){recorridoPreorden(pNode->left);cout<<"Node: "<<pNode->info;recorridoPreorden(pNode->right);}

}

Recorrido de árboles binarios Orden Posterior:

1. Recorrer el subárbol izquierdo en orden posterior2. Recorrer el subárbol derecho en orden posterior3. Recorrer la raíz

A

B

G

D

C

H

E

I

F GDBHIEFCA

9

3

2

1

8

6

4 5

7

void recorridoPostorden(TNODEPTR pNode){if(pNode!=NULL){recorridoPreorden(pNode->left);recorridoPreorden(pNode->right);cout<<"Node: "<<pNode->info;}

}

Remoción en un árbol binario ordenado15

4

83

19

16

Se presentan tres casos:◦ El nodo a suprimir no tiene hijos: Se

elimina el nodo del árbol sin mayores ajustes

◦ Si el nodo a suprimir sólo tiene un subárbol: Su único hijo se mueve hacia arriba y ocupa su lugar

◦ El nodo a suprimir tiene dos subárboles: Su sucesor de orden intermedio S (o antecesor) debe ocupar su lugar. El sucesor 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 hijo más a la derecha de su árbol izquierdo.

15

4

8

19

16

15

4

8

19

16

15

819

16

15

4

83

19

16

25

18

23

24

23

24

Remoción en un árbol binario ordenado15

4

83

19

16

15

4

8

19

16

15

4

8

19

16

15

819

16

15

4

83

19

16

25

18

23

24

23

24

void deleteNode(TNODEPTR tree, int x) {

TNODEPTR p = tree, q = NULL, rp;

while (p != NULL && p->info != x) {

q = p;

p = (x < p->info) ? p->left : p-> right;

}

if (p == NULL) return;

if (p->left == NULL)

rp = p-> right;

else if (p-> right == NULL)

rp = p->left;

else {

TNODEPTR f = p;

rp = p-> right;

TNODEPTR s = rp->left;

while (s != NULL) {

f = rp;

rp = s;

s = rp->left;

}

if (f != p) {

f->left = rp->right;

rp->right = p->right;

}

rp->left = p->left;

}

if (q == NULL) tree = rp;

else

(p == q->left) ? q->left = rp : q->right = rp;

freeNode(p);

}

Árboles BalanceadosLa 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

1

0

0

1 -1

00 0

0

00 0

0000

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 AVLDebido 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ónCada 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}

5

2

15

8

7

6

10

p

Árbol AVL: Rotaciones7

5

62

10

8 15

5

2

158

7

6 10

5

2

15

8

7

6

10

Rotación derecha Rotación izquierda

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

Recorrido Inorder

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

Algoritmo de Rotación Izquierda

Rotación izquierda

q = right(p);temp = left(q);left(q) = p;right(p) = temp

p

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, teniendocomo raíz de su subárbol derecho el hijo izquierdo lr’ de la nueva raíz r’.

7

5

62

10

8 15

5

2

15

8

7

6

10

l r

r

r’

r’p

l

lr’

lr’

Rotaciones DoblesSi la inserción se produce en el hijo derecho (lr’) del hijo izquierdo (p) del nodo desequilibrado (r) o viceversa , se realizará una doble rotación.

Rotación Doble a la Derecha: Primero es una rotación simple a la izquierda, y luego rotación simple a la derecha.

5

2

15

9

7

6

12

r

r’p

l lr’

10

5

2

15

9

7

6

12

10

8

5

2

15

9

7

6

12

10

88

Rotación ala izquierda

Rotación ala derecha

Casos de InserciónLa 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.

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

Nuevo nodo

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

Casos de InserciónCaso 2: Derecha

Solución: Rotación Izquierda


Nuevo nodo

Casos de InserciónCaso 3: Izquierda-Derecha Solución:

Rotación doble

Rotación Izquierda


Rotación Derecha

Casos de InserciónCaso 4: Derecha-Izquierda Solución:

Rotación doble

Rotación Izquierda


Rotación Derecha

Árboles MulticaminosUn á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íoII. A puede tener hasta n subárboles S0, S1, S2, …, Sn-

1 en cada nodoIII. 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

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

Sn-1

Nodo A

X X X

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

Cantidad variable de apuntadores Cantidad variable de llaves

Árboles Multicaminos: Ejemplos

12 50 85

6 10 3760 70

80100 120

150

2562 65

69110

A

B C D E

F G H

Árbol multicamino de orden 4. Máxima cantidad de llaves es 3

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

Árboles Multicaminos: Operaciones Básicas

12 50 85

6 10 3760 70

80100 120

150

A

B C D E

numTrees(A) => 4

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

key(A,2)key(A,0)


child(p,0) apunta a un subárbol cuyas llaves son todas menores que la llave key(p,0).

12 50 85

6 10

37

60 70 80

100 120 150

A

B C D E

child(A,0): Las llaves de este nodo {6,10} < 12

key(A,0)child(p, numTrees(p)-1) apunta a un subárbol que contiene únicamente llaves mayores a key(p, numTrees(p)-2).

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).

child(A,3): Las llaves de este nodo: {100,120, 150} > 85

key(A,2)

Recorrido: Impresión de llaves en orden ascendente.

traverse(T node){

if(node != NULL){

nt = numTrees(node);

for(i = 0; i<nt-1; i++){

traverse(son(node,i));

cout<<key(node, i);

}

traverse(son(node,nt-1));

}

}


12 50 85

6 10

37

60 70 80

100 120 150

A

B C D E

nt = 40<=i<3

key(A,0), Key(A,1), Key(A,2)

son(A,0) son(A,1) son(A,2) son(A,3)

Á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){ p = son(node, index+1); q = null; while(p != NULL){

q = p;p = son(p,0);

} if (q!=NULL)

return key(q,0); if(index < numTrees(node)-2)

return key(node, index+1); return (NULL);}

succesor(T node, int index){ p = son(node, index+1); if(p!=NULL && index<numTrees(node)-2)

return (next(p,index)); f = father(node); i = index(node); while(f != NULL&& i==numTrees(f) -1){ i = index(f);

f = father(f); } if (f==NULL)

return (NULL); return (key(f,i));}

Estructura de Datos En C++ Dr. Romeo Sánchez Nigenda. E-mail: [email protected] romeo/...

Documents

Transcript of Estructura de Datos En C++ Dr. Romeo Sánchez Nigenda. E-mail: [email protected] romeo/...