ARBOLES PARCIALMENTE ORDENADOS

ESTRUCTURAS DE DATOS

CONCEPTOS

Arbol Binario Completo

Todos sus niveles estan completos

A excepcin del ultimo nivel,

Alli las hojas van apareciendo seguidas de izquierda a derecha

150

125
80 15 20 30 28 25

75
72

Arbol Parcialmente Ordenado

Es Binario Completo Con propiedad de orden

Entre raiz e hijos, la raiz contiene el mayor(o menor) de todos

UTILIDAD DE UN HEAP

Si el mayor valor esta siempre en la raiz

El heap presenta un cierto orden Al remover consecutivamente la raiz

Vamos consiguiendo valores ordenados

El heap se utiliza

Para el ordenamiento de elementos(HeapSort) Para implementar colas de prioridad

QDesencolarMax, es retirar el valor de la raiz

IMPLEMENTACION
2

150
5 6

Un heap no admite huecos,

125

75

C/nivel se va llenando de izq. A der Hay una secuencia

15
8

80
20
9

30
28
10

25

72

Podriamos numerar c/nodo

En el orden de llenado
i
1 2 3 4 5 6

i/2

Si lo vemos asi, dado un ndice

i z q ( i ) d e r ( i ) p a d r e ( i )
2 4 6 8 1 0 -

Podemos conocer los indices de los hijos y el padre de un nodo Ejemplo: Del nodo 4, hijos 8 y 9, padre 2

i*2

3 5 7 9 -

i*2+1

1 1 2 2 3

CONTANDO DESDE 0

Queremos usar un vector

150
4 5

En c/elemento almacenar la informacin Dirigirnos a hijos y padre calculando el ndice respectivo

125

75

80 15
7

30 20
8

25

72

Izq(i) = i*2
Der(i) = i*2+1 Padre(i) = i/2
0 1

28
9

Los vectores en C, empiezan desde 0

Cambia un poquito la regla Izq(i) = (i+1)*2-1 = i*2+1 Der(i) = (i+1)*2 = i*2+2 Padre(i) = (i+1)/2-1 = (i-1)/2

150 125 75
2

80
3

30
4

25
5

72
6

15
7

20
8

28
9

REGLAS

Vector V de tamao efectivo n

V[0] es la raiz Dado un nodo V[i]

Si 2i+1 < n, V[2i+1] es el hijo izq Si 2i+2 < n, V[2i+2] es el hijo der Si i != 0, v[(i-1)/2] es el padre

Si es heap

i : 1 i n : v [ i 1 /2 ] v [ i ]

DECLARACION: TDA HEAP

Tipo de Dato

Necesitamos un arreglo Llevar el tamao efectivo Llevar el mximo del arreglo typedef struct{ Generico *Elementos; int nefectivo; int max; Tipo_Orden tipo; }Heap;

OPERACIONES BASICAS: TDA HEAP

Desencolar y Encolar

Desencolar: Extraer el elemento mas grande/pequeo del heap(la raiz) Encolar: Insertar un valor al heap y ubicarlo en la posicion correcta Dado un Heap permite generar un arreglo/lista ordenado Ajustar
Reestablece la propiedad de orden de un subheap hacia abajo No a todo el arbol!

HeapSort

Operaciones Adicionales

Construir_heap
Dado un arreglo que no representa un heap Arregla el arreglo y lo convierte en un Heap

MAS OPERACIONES

int PosIzq(Heap H, int i);

Heap * Heap_Crear(int tmax, TipoOrden t);

Retorna el indice del nodo izq de i Si no cumple las reglas, retorna -1

Recibe un heap y lo inicializa para tener un

tamao maximo tmax y un orden t(ascendente o

descendente)

int PosDer(Heap H, int i);

bool EstaVacio(Heap P);

Retorna el ndice del nodo der de i

Recibe un Heap y determina si esta Vacio

Si no cumple las reglas, retorna -1

int PosPadre(Heap H, int i);

Retorna el ndice del nodo padre de i

Si no cumple las reglas, retorna -1

AJUSTAR

Recobra la propiedad de orden Desde un nodo de ndice pos

Dado un ndice pos, PosIzq y PosDer

Se compararan los tres para ver quien tiene el mayor Si el mayor lo tiene algun hijo

Intercambia Al hacer esto, el sub-heap afectado puede perder su propiedad de Orden. Ajustar el sub-heap afectado

AJUSTAR: EJEMPLO
0

Un heap puede perder su p.o.

Pos
3

150
4 5

Por un nodo

80 60

75

Ejemplo: Ejemplo:

Pos PosMayor

80 60 70 20
7

30
70 70 60
8

25

72

En el el nodo nodo 1 no no se se cumple cumple No En se puede 3 ajustar un nodo hoja Ajustar Ajustar
El mayor mayor es es el el nodo nodo 3 3 El Intercambiar Intercambiar Ajustar Ajustar Otra desde nodo Vez intercambiado(3)

28
9

PosMayor 25
5

150 80 60
0 1

75
2

80 70
3

30
4

72
6

20
7

70 60
8

28
9

AJUSTAR: IMPLEMENTACION
static void Heap_Ajustar(Heap *H, int posnodo, Generico_fnComparar comocomparar){ int pos_mayor, izq, der; pos_mayor = posnodo; izq = IdxIzquierdo(*H, posnodo); der = IdxDerecho(*H, posnodo); if(izq>=0 && Heap_CompararxTipo(H->tipo_orden,H->Elementos[izq], H->Elementos[posnodo],comocomparar) ) pos_mayor = izq; if(der>=0 && Heap_CompararxTipo(H->tipo_orden,H->Elementos[der], H->Elementos[pos_mayor], comocomparar)) pos_mayor = der; if(pos_mayor != posnodo){ Generico_Intercambiar(&(H->Elementos[pos_mayor]), &(H->Elementos[posnodo])); Heap_Ajustar(H,pos_mayor,comocomparar); } }

CONSTRUIR UN HEAP

La estructura de un heap

Puede almacenar un arreglo que no cumpla las propiedades de orden

15
0

Ejemplo:
Hay que arreglar la propiedad de orden

1
1

28
2

35
3

10
4

5
5
0

8
6

21
7

50
8

42
9

15
4 5

De cada raiz Ajustar c/raiz Desde la ultima a la primera

21
7

28

35 50
8

10 42
9

CONSTRUIR HEAP: EJEMPLO

Ajustar el ultimo nodo raiz

15 50
0

42 1
1

28
2

35
3

10 15
4

5
5
0

8
6

21
7

50 1
8

42 10
9

Los nodos raiz comienzan

desde 0 hasta n/2-1
1

50 15
4 5

Al ajustar cada nodo

50 42 15 1

28

De atrs hacia delante

Nos aseguramos que los valores mas altos suban!
21
7

50 35 1 50 35 1
8

10 42 15 42 10
9

CONSTRUIR HEAP: IMPLEMENTACION

void Construir_Heap(Heap *H, Generico_fncomparar comocomparar){

int i;
for(i = H->n/2-1; i >= 0; i--){ Heap_Ajustar(H,i,comocomparar);

}
}

DESENCOLAR

Que importancia tiene la raiz en el heap?

Es el mayor/menor elemento del mismo Sobre el resto de elementos no estamos seguros Pero de la raiz, es la mayor de todos

Desencolar es eliminar la raiz

Que valor se ubica en la nueva raiz? El ultimo reemplaza al primero El tamao efectivo del heap cambia

Se ajusta desde la raiz

El arbol queda bien otra vez

DESENCOLAR: EJEMPLO
0

Intercambiar valores

150 125 28
4
5

Raiz con ultimo

80 28 125

75

Aminorar tamao efectivo

Ajustar arbol
15
7

28 80 20
8

30 28
9

25

72

150 125 28 125 80 75

0 1 2

80 28
3

30
4

25
5

72
6

15
7

20
8

28
9

DESENCOLAR: IMPLEMENTACION
Generico Heap_DesEnColar(Heap *H, Generico_fnComparar comocomparar){ Generico gmax; if(!Heap_EstaVacio(*H)){ gmax = H->Elementos[0]; Generico_Intercambiar(&(H->Elementos[0]), &(H->Elementos[H->nefectiva-1])); H->nefectiva --; Heap_Ajustar(H, 0, comocomparar); return gmax; } return NULL; }

HEAPSORT

Uno de los usos de los heaps es ordenar Como?

Extraer el mayor elemento del heap(raiz) Ponerla al final de otro arreglo Repetir los dos ultimos pasos hasta que el Heap quede Vacio

El arreglo quedara ordenado

HEAPSORT: EJEMPLO
1

125 28 15 20 75 72 30 25 28 80 150
4 5

Desencolar y ponerlo al final del nuevo arreglo/lista

15
7

125 30 28 20 15 80

75 72 25 15

28 15 80
20
8

30 20
28
9

25 15

72 15

Repetir hasta que el arbol quede vacio

0 1

150 125 80 125 75 72 30 28 25 20 15 80 15 30 28 20 15 75 72 25

2

80 28 15
3

30 20
4

25 15
5

72 15
6

15
7

20
8

28
9

15
0

20
1

25
2

28
3

30
4

72
5

75
6

80 125 150
7 8 9

HEAPSORT: IMPLEMENTACION
LSE *HeapSort(LSE *Desordenada, Generico_fncomparar comocomparar){
Heap H; LSE_nodo *p; p = LSE_NodoPrimero(Desordenada); } while(Heap_EstaVacio(H)){ LSE_InsertarInicio(Desordenada, Heap_Desencolar(H, comocomparar); } return Desordenada; } while(!LSE_EstaVacia(Desordenada)) { Heap_Encolar(&H,LSE_SacarPrimerNodo(Desordenada),comocomparar)

ENCOLAR

Al aadir un nuevo elemento el Heap

DEBE conservar su propiedad de orden

Se aade al final del arreglo El elemento empieza a subir a su posicin ideal

Comparando siempre con el padre Hasta que el valor insertado sea menor que el del padre

ENCOLAR: EJEMPLO
0 1

Insertar al final Subir el valor hasta que ya no sea necesario

15
7

150
4 5

125 130

75

80 20
8

30 130 125 28
9

25 30 130

72

Nuevo valor: 130

150 125 75
0 1 2

80
3

30
4

25
5

72
6

15
7

20
8

28 130
9 10

ENCOLAR: IMPLEMENTACION
void Heap_EnColar(Heap *H, Generico G, Generico_fnComparar comocomparar){ int padre, i; if(H->nefectiva < H->max){ H->Elementos[H->nefectiva] = G; H->nefectiva++; i = H->nefectiva-1; padre = IdxPadre(*H,i); while((i>=0 && padre>=0) && Heap_CompararxTipo(H->tipo_orden, H->Elementos[i], H->Elementos[padre], comocomparar)){ Generico_Intercambiar(&(H->Elementos[i]), &(H->Elementos[padre])); i = padre; padre = IdxPadre(*H,i); } } }