1

Captulo 20

Skew heaps. Seleccionar.

Un skew heap es una representacin de un rbol binario tal que los hijos tienen claves mayores
o iguales a las del padre y que mantiene las trayectorias derechas lo ms cortas que sea posible.
Es un algoritmo de seleccin que puede agregar tems en forma dinmica, a diferencia del heap
implcito, rbol binario embebido en un arreglo, que utiliza memoria esttica.
Es un algoritmo derivado de los rboles izquierdistas, leftist, pero que no almacena informacin
de los trayectos derechos en cada nodo. Su caracterstica es que es auto ajustable o
autoorganizado, en el sentido de que en cada operacin de actualizacin se efecta una
modificacin sencilla de la estructura, tal que esto reduzca el costo de las operaciones futuras. Si
bien esto incurre en un costo mayor de las operaciones, en promedio se logra un
comportamiento eficiente. Esto lo logra no intentando optimizar el peor caso de una operacin
individual, sino que el peor caso de una secuencia de operaciones.
La codificacin resulta ms sencilla que los algoritmos que garantizan el balance de la
estructura, y demandan menos espacio para almacenar cada nodo.

20.1. Mezcla de dos skew heaps.

En forma similar a un leftist, las operaciones estn basadas en la mezcla de los trayectos
derechos de los dos heaps, pero con la modificacin de que en lugar de mantener distancias
derechas ms cortas, se efecta directamente un intercambio de los hijos derecho e izquierdo de
cada nodo en el trayecto de la mezcla; salvo en el ltimo nodo.
1
3

4
3

6
8

10

Figura 20.1. Mezcla de trayectos derechos de dos heaps.

Profesor Leopoldo Silva Bijit

20-01-2010

Estructuras de Datos y Algoritmos

La Figura 20.1 muestra dos heaps. La trayectoria derecha del ubicado a la izquierda est
formada por los nodos: 1, 4 y 6. La trayectoria derecha del heap ubicado a la derecha est
formada por los nodos: 2, 5, y 8. Las trayectorias derechas se recorren de arriba hacia abajo.
En la Figura 20.2, a la izquierda se muestra la mezcla de los dos trayectos derechos, se forma
una ruta derecha ms larga, formada por la secuencia: 1, 2, 4, 5, 6 y 8. Luego a la derecha se
muestra el intercambio de los hijos de cada nodo del trayecto derecho; lo cual deja un skew
heap con trayecto derecho de un nodo.
1

1
2

3
3

5
9

7
8

10

8
9

10

Figura 20.2. Mezcla e intercambio de hijos en el trayecto.

El algoritmo puede realizar simultneamente la mezcla y el intercambio de los hijos, para esto
se recorren los dos trayectos derechos de arriba hacia abajo (top-down) y cuando se llega al final
de uno de los trayectos, el resto del otro se enlaza al final y el proceso termina.
Slo los nodos visitados en el trayecto tienen sus hijos intercambiados, el ltimo nodo que tiene
intercambio de hijos es el ltimo nodo del trayecto que se recorre totalmente; el nodo con valor
6 en la Figura 20.2.

20.2. Operacin Mezcla con intercambio. Top-down.

Se tienen que h1 apunta al heap cuya raz tiene prioridad menor, y h2 al heap con raz con
prioridad mayor, y h al heap con la mezcla, que inicialmente tiene valor nulo.
h1

h2

a
b

d
c

Figura 20.3. Mezcla e intercambio de hijos en el trayecto.

Profesor Leopoldo Silva Bijit

20-01-2010

Seleccionar. Skewheap.

El siguiente segmento inicia el heap h con la mezcla, e intercambia los hijos; al mismo tiempo
inicia la variable y, que recuerda al ltimo nodo agregado al heap con la mezcla:
h = h1;
y = h1;
// apunta al ltimo agregado
h1 = y->right;
//desciende en trayecto derecho
y->right = y->left; //intercambia hijos
h
a

h1
c

Figura 20.4. Inicio de la mezcla con intercambio.

Luego debe repetirse un procesamiento similar hasta agotar uno de los trayectos:
while (h1 != NULL)
{ if (h1->prioridad > h2->prioridad) /* selecciona menor */
{ temp = h1;
h1 = h2;
h2 = temp;
} //ahora h1 apunta al con prioridad menor
y->left= h1; //lo pega por la izquierda
y = h1;
// apunta al ltimo agregado
h1 = y->right; //desciende
y->right = y->left; //intercambia hijos del ltimo agregado
}
y->left= h2; //pega el resto del trayecto
Para insertar se colocan los nuevos datos en un nodo, en un heap con un elemento, y se mezcla
con el rbol existente.
n

Figura 20.5. Heap con un elemento.

Para descartar el mnimo, se remueve la raz, y se mezclan los subrboles izquierdo y derecho.
Las operaciones son de costo amortizado O(log(n)).

Profesor Leopoldo Silva Bijit

20-01-2010

Estructuras de Datos y Algoritmos

20.3. Definicin de tipos.

Se tiene la siguiente definicin para la estructura del nodo:
typedef struct bintree
{ struct bintree * left;
struct bintree * right;
int prioridad;
} nodo, *pnodo;
typedef pnodo queue;

20.4. Creacin de nodo y de cola.

pnodo getnodo(int prioridad)
{ pnodo p=NULL;
if ( (p= (pnodo) malloc(sizeof(nodo))) ==NULL)
{ printf("Error: Memoria. \n"); exit(1);}
else
{ //forma heap de un elemento
p->prioridad=prioridad; p->left=NULL; p->right=NULL;
}
return(p);
}
void initqueue( queue* q )
/* inicia una variable de tipo queue */
{ *q = NULL;
} /* initqueue */

20.5. Test de cola vaca.

int emptyqueue( queue q )
/* test para determinar si la cola est vaca */
{ return (q == NULL);
} /* emptyqueue */

20.6. Insertar. Encolar. Top-down.

Se pasa la cola por referencia.
void enqueue( pnodo n, queue* q )
{ *q = meld( n, *q );
} /* enqueue */

Profesor Leopoldo Silva Bijit

20-01-2010

Seleccionar. Skewheap.

skew
*q
raz

Figura 20.6. Paso por referencia a la cola de prioridad skew.

20.7. Seleccionar el mnimo. Desencolar. Top-down.

Se pasa la cola por referencia. Retorna el nodo con valor de prioridad mnimo.
pnodo dequeue( queue* q )
{
pnodo result= *q;
*q = meld( (*q)->left, (*q)->right );
return result;
} /* dequeue */

20.8. Funcin mezclar. Top-down.

pnodo meld( queue h1, queue h2 )
/* mezcla dos skew heaps de arriba hacia abajo. top down */
{ pnodo temp, y;
pnodo h;
if (h1 == NULL) { h = h2;}
else if (h2 == NULL) {h = h1;}
else {
if (h1->prioridad > h2->prioridad) { /* selecciona menor */
temp = h1;
h1 = h2;
h2 = temp;
} //ahora h1 apunta al con prioridad menor
h = h1;
//inicia h
y = h1;
// apunta al ltimo agregado
h1 = y->right;
//desciende por la derecha
y->right = y->left; //intercambia
while (h1 != NULL) {
if (h1->prioridad > h2->prioridad) {
/* selecciona menor */
temp = h1;
h1 = h2;
h2 = temp;
}
y->left= h1;
//lo pega por la izquierda
y = h1;
// apunta al ltimo agregado
h1 = y->right; //desciende
Profesor Leopoldo Silva Bijit

20-01-2010

Estructuras de Datos y Algoritmos

y->right = y->left;
//intercambia hijos del ltimo agregado
}
y->left= h2; //pega el resto del trayecto

}
return h;
} /* meld */

20.9. Test de las funciones.

//listas izquierda y derecha a partir de la raz
int prtskew(pnodo p)
{ pnodo t;
if (p!=NULL) printf("rn=%d ri->", p->prioridad);
else {printf("Skewheap nulo\n"); return (0);}
for(t=p->right; t!=NULL ; t=t->right) printf("%d ", t->prioridad);
printf(" le->");
for(t=p->left; t!=NULL ; t=t->left) printf("%d ", t->prioridad);
putchar('\n');
return(1);
}
queue skewheap=NULL;
int main (void)
{ pnodo t;
int i;
srand(1);
for(i=0; i<20; i++)
{ enqueue(getnodo(rand()%100), &skewheap );
prtskew(skewheap); //muestra los largos derechos
}
for(i=0; i<20; i++)
{ prtskew(skewheap);
t=dequeue(&skewheap);
//printf("%d ", t->prioridad);
free(t);
};
putchar('\n');
}

Profesor Leopoldo Silva Bijit

20-01-2010

Seleccionar. Skewheap.

20.10. Mezcla ascendente (bottom-up).

Pueden lograrse mejores resultados para las operaciones de mezcla e insercin, si las mezclas e
intercambios de hijos de los trayectos derechos se efecta de abajo hacia arriba.
Se inicia la mezcla e intercambio de hijos en los nodos ms derechistas de los heaps, cuando se
llega al tope de uno de los trayectos, la raz de uno de los heaps que se estn mezclando, se pega
como hijo derecho del ltimo nodo del otro trayecto, el que an no ha participado de la mezcla.
El intercambio de hijos se realiza incluyendo el nodo raz del heap que se agot primero, luego
no se sigue con el intercambio.
1
3

4
5

7
8

6
9

10

Figura 20.7. Mezcla de trayectos derechos de dos heaps.

En el caso del ejemplo que se muestra en la Figura 20.7, se deben mezclar los nodos 8, 5 con los
nodos 6, 4, 1, en ese orden. El ltimo nodo que intercambia sus hijos es el con valor 5, luego
ste se pega como hijo derecho del nodo con valor 4, que an no se ha considerado en la
mezcla. El resultado de la mezcla de abajo hacia arriba, se muestra en la Figura 20.8.
1
4

7
8

10
0

Figura 20.8. Mezcla bottom-up de los heaps de la Figura 20.7.

La realizacin eficiente de esta operacin requiere tener punteros al padre y referencias a los
nodos ms derechistas de ambos heaps. Sin embargo, en forma similar a las pagodas, pueden
emplearse punteros al padre y al nodo ubicado ms a la derecha del hijo izquierdo. La raz
Profesor Leopoldo Silva Bijit

20-01-2010

Estructuras de Datos y Algoritmos

apunta a los dos descendientes de ms a la derecha de ambos hijos, lo que facilita la mezcla
hacia arriba. Un nodo sin subrbol izquierdo apunta a s mismo.
La estructura es cclica y permite el descarte de cualquier elemento con complejidad O(log n).
La Figura 20.9, a la izquierda, muestra un heap mediante un rbol binario con punteros a los
hijos. A la derecha se muestra con los punteros derechos la referencia al padre, el puntero
derecho de la raz referencia al hijo ms derechista. Con los punteros izquierdos se apunta al
hijo ms derechista del subrbol izquierdo, o a s mismo si no tiene descendientes izquierdos.
1

6
8

Figura 20.9. rbol de prioridad y skew bottom-up equivalente.

Puede redibujarse como un rbol binario, lo cual se muestra en la Figura 20.10, a la izquierda.
Pero una mejor representacin es mediante listas circulares o anillos, en la cual se tienen listas
ordenadas descendentes con los punteros derechos y listas ordenadas ascendentes hacia abajo, lo
cual se muestra a la derecha de la Figura 20.10.
De acuerdo a la Figura 20.10, a la derecha, es preferible denominar down al puntero usualmente
denominado left en un nodo binario.
1

h
7

8
9

2
8

Figura 20.10. Enderezando punteros y representacin por listas.

Puede resumirse las propiedades notando que en cada nodo el puntero derecho apunta a un nodo
con menor prioridad, y que hacia abajo se apunta a uno con mayor prioridad. La raz es la
excepcin ya que hacia la derecha apunta a una lista circular ordenada descendentemente y
hacia abajo a una lista ascendente. Desde cualquier nodo pueden seguirse rutas descendentes
Profesor Leopoldo Silva Bijit

20-01-2010

Seleccionar. Skewheap.

hasta la raz, mediante los punteros derechos; y rutas ascendentes hasta las hojas, mediante los
punteros hacia abajo.

20.11. Anlisis de insercin bottom up.

Si el elemento que se inserta es menor o igual que la raz, se coloca el nuevo elemento como la
raz; y se coloca el primer elemento de la lista, el mayor de sta, como descendiente ascendente
de la nueva raz. Notar que la raz antigua ya estaba ligada al elemento mayor. Efectuando tres
asignaciones se logra la Figura 20.11, a partir de la insercin de un nodo con valor 0, en el heap
que se muestra a la derecha de la Figura 20.10. Si se insertan secuencias de nodos con
prioridades descendentes, crecer la lista ascendente hacia abajo.
h
0

8
6

Figura 20.11. Insercin de elemento con menor prioridad que la raz.

Si el elemento que se inserta es mayor o igual que el primero de la lista descendente derecha se
lo coloca como el primero de la lista. La Figura 20.12, muestra la insercin del elemento con
prioridad 9, en el heap de la Figura 20.10 a la derecha. Su realizacin se logra con la escritura de
dos punteros. Si se insertan secuencias de nodos con prioridades ascendentes, crecer la lista
derecha.
h
1

Figura 20.12. Insercin de elemento mayor o igual que el primero de la lista derecha.

Profesor Leopoldo Silva Bijit

20-01-2010

10

Estructuras de Datos y Algoritmos

Si el elemento que se inserta es mayor que la raz y menor que el primero de la lista descendente
derecha se recorre la lista descendentemente ordenada hasta encontrar el lugar de insercin, al
mismo tiempo que se van colocando los elementos mayores en las listas ascendentes hacia
abajo.
Esto se logra con dos punteros auxiliares, y que busca la posicin para insertar; y el puntero z
que apunta al descendiente hacia abajo.
Al inicio ambos punteros auxiliares apuntan al primero de la lista derecha. Donde n es el nodo
que se insertar, y h apunta a la raz del heap.
y = z = h->right;
while (n->prioridad < y->right->prioridad)
{ y=y->right; //avanza en la lista descendente.
t=z; z=y->down; y->down=t; // swap(z, y->down)
}
n->right=y->right; n->down=z; //enlaza lista ascendente y descendente.
y->right=h->right=n; // cambia inicio lista y encadena el nuevo nodo
La Figura 20.13 ilustra la insercin del nodo con prioridad 6, en la Figura 20.10, a la derecha.
En este caso no se efecta el cdigo del while.
h
1

Figura 20.13. Insercin de elemento 6, menor que el primero de la lista derecha.

La Figura 20.14, muestra la insercin de un nodo con valor 4, en el heap de la Figura 20.10, a la
derecha. En este caso se efecta el cdigo del while, al salir de ste z apunta al nodo con valor 8,
y el puntero y al elemento inmediatamente mayor que el que se insertar, al 5 en este caso.

Profesor Leopoldo Silva Bijit

20-01-2010

Seleccionar. Skewheap.

11
h
4

8
6

Figura 20.14. Insercin de elemento 4, menor que el primero de la lista derecha.

Debe notarse que en el caso de insercin en medio de la lista, el largo de sta tiende a acortarse.
Si bien el costo de esta operacin es ms compleja, las siguientes inserciones resultarn ms
simples. Equivale a un pago por adelantado, con el fin de disminuir el costo total de la deuda; es
realmente una amortizacin.

20.12. Anlisis de descartar el mnimo: bottom up.

Si se desea borrar la raz del heap que se muestra a la derecha de la Figura 20.10, deben
reescribirse los punteros derechos de los nodos 2 y 3, que son los finales de las listas principales
que derivan de la raz. Se mezclan los trayectos derechos de las listas, intercambiado los hijos a
travs del trayecto de mezcla, y se detiene la mezcla cuando se llega a la raz en ambos
trayectos.
Se tratan como casos especiales que el heap est vaco, y que una de las listas est vaca. En el
primer caso se retorna un puntero nulo; en el segundo, no es necesario realizar la mezcla, sino
que encontrar el nodo con prioridad mnima, recorriendo la lista descendente hasta el final.
En un caso general, se requieren tres variables auxiliares: mayor y menor que apuntan a los
elementos de las listas que deben mezclarse, next se emplea para escoger el mayor de los
elementos, y si es preciso se cambian los punteros mayor y menor:
h = mayor;
//inicia raz para la mezcla con el mayor (bottom)
h->right = h; //sin lista derecha. Se apunta a s mismo
mayor = mayor->right; //avanza y selecciona el siguiente: next
if (mayor->prioridad < menor->prioridad)
{ next = menor; menor = mayor;}
else { next = mayor; }
Luego de esto se procede a un lazo de mezcla, el cual agrega el nodo next al nuevo heap, el que
debe repetirse hasta encontrar la raz. Sea r la raz que apunta al elemento mnimo que se desea
descartar.
La Figura 20.15, muestra un ejemplo de las variables y sus relaciones:
En el nuevo heap h, que est en formacin, los elementos cumplen: b > > c > a.
Profesor Leopoldo Silva Bijit

20-01-2010

12

Estructuras de Datos y Algoritmos

Los elementos a la derecha del nodo next cumplen: d > e, por pertenecer a uno de los trayectos
que forman una lista descendente; y d < f por formar parte de una lista ascendente.
La lista derecha de f, cumple > g > d > f.
El proceso de abajo hacia arriba garantiza que d es menor que a.
h
a

next
d

Figura 20.15. Lazo de mezcla e intercambio.

El siguiente lazo de mezcla, describe la actualizacin mediante la escritura de cinco punteros.
Luego de esto se obtiene la Figura 20.16, y el proceso contina.
while (next != r)
{ mayor = next->right;
next->right = next->down;
next->down = h->right;
h->right = next;
h = next;

//avanza en lista mayor

//intercambia hijos de next
//agrega nodos con prioridades mayores
//enlaza a con el padre d
//la nueva raz absorbe nodo next

//selecciona siguiente
if (mayor->prioridad < menor->prioridad)
{ next = menor; menor = mayor;}
else {next = mayor;}
}
h
d

g
mayor
e

Figura 20.16. Despus de la actualizacin de cinco punteros.

20.13. Tipos y obtencin de nuevo nodo.

Se emplea ahora down, en lugar de left.

Profesor Leopoldo Silva Bijit

20-01-2010

Seleccionar. Skewheap.

13

typedef struct bintree

{ struct bintree * down;
struct bintree * right;
int prioridad;
} nodo, *pnodo;
pnodo getnodo(int prioridad)
{ pnodo p=NULL;
if ( (p= (pnodo) malloc(sizeof(nodo))) ==NULL)
{ printf("Error: Memoria. \n"); exit(1);}
else
{ p->prioridad=prioridad; p->down=p; p->right=p;} //inicia listas
return(p);
}
La creacin de una nueva cola de prioridad, y el test de cola vaca, resultan idnticas a las
funciones para el caso top-down.

20.13. Insertar. Bottom-up.

void insert (pnodo n, queue * q)
{ pnodo t, y, z;
if (*q == NULL) {*q =n; }
else if (n->prioridad <= (*q)->prioridad) //insercin en lista descendente. Figura 20.12
{n->down=(*q)->right ; *q=(*q)->right=n; }
//n es el menor nodo de trayecto mayor
else if (n->prioridad >= (*q)->right->prioridad)
//insercin en el tope. Figura 20.11.
{n->right=(*q)->right; (*q)->right=n;}
//n es la nueva raz
else
{ y =z=(*q)->right;
//Al inicio ambos punteros auxiliares apuntan al primero de la lista derecha
while (n->prioridad < y->right->prioridad)
{ y=y->right;
//avanza en la lista descendente.
t=z; z=y->down; y->down=t;
// swap(z, y->down)
}
n->right=y->right; n->down=z; //enlaza lista ascendente y descendente.
y->right=(*q)->right=n; //cambia inicio lista y encadena el nuevo nodo
}
}

20.14. Descartar. Bottom-up.

pnodo dequeue( queue* q )
{ pnodo mayor, menor, next, newq;
pnodo minimo= *q; /* selecciona el mnimo */
if (*q != NULL)
{ /* descarta slo si el heap no est vaco */
mayor = (*q)->right;
Profesor Leopoldo Silva Bijit

20-01-2010

14

Estructuras de Datos y Algoritmos

menor = (*q)->down;
if (mayor->prioridad < menor->prioridad)
{ mayor = menor; /* intercambia mayor y menor */
menor = (*q)->right;
}
if (mayor == *q)
{ /* la lista apuntada por mayor est vaca. */
if (menor == *q)
{ *q = NULL; } /* la cola tena un solo elemento */
else
{ /* se busca nueva raz en lista apuntada por menor. */
next = menor;
while (menor->right != *q) menor = menor->right;
//menor apunta a la nueva raz. next pasa a ser el primero de la lista derecha
menor->right = next;
*q = menor;
}
}
else
{ /* realiza la mezcla de listas derechas apuntadas por mayor y menor */
newq = mayor; //inicia raz para la mezcla con el mayor (bottom)
newq->right = newq; //sin lista derecha. Se apunta a s mismo
mayor = mayor->right; //avanza y selecciona el siguiente: next
if (mayor->prioridad < menor->prioridad)
{ next = menor; menor = mayor;}
else { next = mayor; }
//lazo de mezcla: agrega next al nuevo heap.
while (next != *q)
{ mayor = next->right; //avanza
next->right = next->down; //intercambia hijos de next
next->down = newq->right; //agrega nodos con prioridades mayores
newq->right = next; //enlaza con el padre
newq = next; //la nueva raz absorbe nodo next
//selecciona siguiente
if (mayor->prioridad < menor->prioridad)
{ next = menor; menor = mayor;}
else {next = mayor;}
}
/* se agot lista apuntada por mayor */
if (menor == *q) {*q = newq;} /* si se agotan ambas, la mezcla termina */
else
{ /* busca la nueva raz en la lista menor */
next = menor;
while (menor->right != *q) menor = menor->right;

Profesor Leopoldo Silva Bijit

20-01-2010

Seleccionar. Skewheap.

15

//menor apunta a la nueva raz

menor->right = newq->right; //le pega lista descendente
newq->right = next; //pega el resto de los nodos que no participaron en la mezcla
*q = menor;
}
}
}
return minimo;
} /* dequeue */

20.15. Test de las funciones.

//Muestra listas a partir de la raz. Bottom.up.
int prtskew(pnodo p)
{ pnodo t;
if (p!=NULL) printf("r=%d ri->", p->prioridad);
else {printf("Skewup nulo\n"); return (0);}
for(t=p->right; t!=p ; t=t->right) printf("%d ", t->prioridad);
printf(" dw->"); //lista ascendente hacia abajo
for(t=p->down; t!=p ; p=t, t=t->down)
{printf("%d ", t->prioridad);}
putchar('\n');
return(1);
}
queue skewup=NULL;
#define N 10
int main (void)
{ pnodo t;
int i;
srand(1);
for(i=1; i<=N; i++)
{ enqueue(getnodo(rand()%100), &skewup);
//prtskew(skewup);
}
putchar('\n');
for(i=1; i<=N; i++)
{ t= dequeue(&skewup);
//prtskew(skewup);
printf(" %d ", t->prioridad);
free(t);
}
putchar('\n');
return(0);
}
Profesor Leopoldo Silva Bijit

20-01-2010

16

Estructuras de Datos y Algoritmos

Ejercicios.
E20.1.
Para el procesamiento top-down:
Comprobar que la insercin de la secuencia: 5, 6, 4, 7, 3, 8, 2, 9, 1, 10 deja un trayecto derecho
de 5 elementos de un total de 10. Lo cual es un ejemplo de secuencia de insercin de peor caso.
Comprobar que al descartar el mnimo, la estructura recobra un largo derecho razonable, de
largo uno en este caso.

Referencias.
D. D. Sleator, R.E. Tarjan., Self-adjusting Heaps, SIAM J. Comput. Vol 15, N 1, Feb 1986.

Profesor Leopoldo Silva Bijit

20-01-2010

Seleccionar. Skewheap.

17

ndice general.
CAPTULO 20 ........................................................................................................................................... 1
SKEW HEAPS. SELECCIONAR. ........................................................................................................... 1
20.1. MEZCLA DE DOS SKEW HEAPS. ......................................................................................................... 1
20.2. OPERACIN MEZCLA CON INTERCAMBIO. TOP-DOWN. .................................................................... 2
20.3. DEFINICIN DE TIPOS. ...................................................................................................................... 4
20.4. CREACIN DE NODO Y DE COLA. ...................................................................................................... 4
20.5. TEST DE COLA VACA. ...................................................................................................................... 4
20.6. INSERTAR. ENCOLAR. TOP-DOWN. ................................................................................................... 4
20.7. SELECCIONAR EL MNIMO. DESENCOLAR. TOP-DOWN. .................................................................... 5
20.8. FUNCIN MEZCLAR. TOP-DOWN...................................................................................................... 5
20.9. TEST DE LAS FUNCIONES. ................................................................................................................. 6
20.10. MEZCLA ASCENDENTE (BOTTOM-UP). ............................................................................................ 7
20.11. ANLISIS DE INSERCIN BOTTOM UP. ............................................................................................ 9
20.12. ANLISIS DE DESCARTAR EL MNIMO: BOTTOM UP....................................................................... 11
20.13. TIPOS Y OBTENCIN DE NUEVO NODO. ......................................................................................... 12
20.13. INSERTAR. BOTTOM-UP. .............................................................................................................. 13
20.14. DESCARTAR. BOTTOM-UP. ........................................................................................................... 13
20.15. TEST DE LAS FUNCIONES. ............................................................................................................. 15
EJERCICIOS. ............................................................................................................................................ 16
E20.1. ................................................................................................................................................ 16
REFERENCIAS. ........................................................................................................................................ 16
NDICE GENERAL. ................................................................................................................................... 17
NDICE DE FIGURAS................................................................................................................................. 17

ndice de figuras.
FIGURA 20.1. MEZCLA DE TRAYECTOS DERECHOS DE DOS HEAPS. ............................................................... 1
FIGURA 20.2. MEZCLA E INTERCAMBIO DE HIJOS EN EL TRAYECTO.............................................................. 2
FIGURA 20.3. MEZCLA E INTERCAMBIO DE HIJOS EN EL TRAYECTO.............................................................. 2
FIGURA 20.4. INICIO DE LA MEZCLA CON INTERCAMBIO. ............................................................................. 3
FIGURA 20.5. HEAP CON UN ELEMENTO. ...................................................................................................... 3
FIGURA 20.6. PASO POR REFERENCIA A LA COLA DE PRIORIDAD SKEW. ....................................................... 5
FIGURA 20.7. MEZCLA DE TRAYECTOS DERECHOS DE DOS HEAPS. ............................................................... 7
FIGURA 20.8. MEZCLA BOTTOM-UP DE LOS HEAPS DE LA FIGURA 20.7. ....................................................... 7
FIGURA 20.9. RBOL DE PRIORIDAD Y SKEW BOTTOM-UP EQUIVALENTE. .................................................... 8
FIGURA 20.10. ENDEREZANDO PUNTEROS Y REPRESENTACIN POR LISTAS. ................................................ 8
FIGURA 20.11. INSERCIN DE ELEMENTO CON MENOR PRIORIDAD QUE LA RAZ. ......................................... 9
FIGURA 20.12. INSERCIN DE ELEMENTO MAYOR O IGUAL QUE EL PRIMERO DE LA LISTA DERECHA. ........... 9
FIGURA 20.13. INSERCIN DE ELEMENTO 6, MENOR QUE EL PRIMERO DE LA LISTA DERECHA. ................... 10
FIGURA 20.14. INSERCIN DE ELEMENTO 4, MENOR QUE EL PRIMERO DE LA LISTA DERECHA. ................... 11
FIGURA 20.15. LAZO DE MEZCLA E INTERCAMBIO. .................................................................................... 12
FIGURA 20.16. DESPUS DE LA ACTUALIZACIN DE CINCO PUNTEROS. ...................................................... 12

Profesor Leopoldo Silva Bijit

20-01-2010