Click here to load reader

Tipos Arbóreos - lcc.uma.es jmmb/ttaadd/temaV.pdf · PDF file 2 Nociones de Árbol Los árboles son conjuntos de nodos con un estructura jerárquica que parte de un nodo principal

  • View
    2

  • Download
    0

Embed Size (px)

Text of Tipos Arbóreos - lcc.uma.es jmmb/ttaadd/temaV.pdf · PDF file 2 Nociones de...

  • Tipos Arbóreos

  • 2

    Nociones de Árbol

    Los árboles son conjuntos de nodos con un estructura jerárquica que parte de un nodo principal o raíz. Cada nodo de un árbol junto con todos sus descendientes constituye otro árbol. Los árboles se pueden definir como estructuras recursivas que presentan recursión múltiple. Según la ramificación que presenten los nodos, fija o variable, aparecen distintos tipos de árboles: árboles de orden N o árboles generales.

  • Árboles Binarios

  • 4

    Árboles binarios: ArbolB[X] = {vacio} | ArbolB[X] × Elt.X × ArbolB[X]

    (fmod ARBOLB [X :: TRIV] is protecting MACHINE-INT . sorts ArbolB[X] ArbolBNv[X] . subsort ArbolBNv[X] < ArbolB[X] . op vacio : -> ArbolB[X] [ctor] . op _’[_’]_ : ArbolB[X] Elt.X ArbolB[X] -> ArbolBNv[X] [ctor] . op raiz : ArbolBNv[X] -> Elt.X . ops ri rd : ArbolBNv[X] -> ArbolB[X] . op altura : ArbolB[X] -> MachineInt . op n-nodos : ArbolB[X] -> MachineInt . ...

    endfm)

  • 5

    Recorridos

    (fmod RECORRIDOS [X :: TRIV] is protecting LISTA[X] . protecting ARBOLB[X] .

    op preorden : ArbolB[X] -> Lista[X] . op inorden : ArbolB[X] -> Lista[X] . op postorden : ArbolB[X] -> Lista[X] .

    ...

    endfm)

  • 6

    Árboles binarios etiquetados ArbolBEt[N,H] = Elt.H | ArbolBEt[N,H] × Elt.N × ArbolBEt[N,H]

    (fmod ARBOLBEt[N :: TRIV, H :: TRIV] is protecting MACHINE-INT . sorts ArbolBEt[N,H] ArbolBEtNh[N,H] . subsort Elt.H < ArbolBEt[N,H] . subsort ArbolBEtNh[N,H] < ArbolBEt[N,H] . op _‘[_’]_ : ArbolBEt[N,H] Elt.N ArbolBEt[N,H]

    -> ArbolBEtNh[N,H] [ctor] . op raiz : ArbolBEtNh[N,H] -> Elt.N . ops ri rd : ArbolBEtNh[N,H] -> ArbolBEt[N,H] . op altura : ArbolBEt[N,H] -> MachineInt . op n-nodos : ArbolBEt[N,H] -> MachineInt . op n-hojas : ArbolBEt[N,H] -> MachineInt . op n-nodosNivel : MachineInt ArbolBEt[N,H] -> MachineInt . ...

    endfm)

  • 7

    Árboles de expresiones (I)

    (fmod OP is sort Op . ops + * - / : -> Op .

    endfm)

    (view Op from TRIV to OP is sort Elt to Op

    endv)

    (view IntM from TRIV to MACHINE-INT is sort Elt to MachineInt .

    endv)

  • 8

    Árboles de expresiones (II)

    (fmod ARBOLEXP is protecting ArbolBEt[Op, IntM] . sort MachineInt? . subsort MachineInt < MachineInt? . op valor : ArbolBEt[Op, IntM] -> MachineInt? . var N : MachineInt . var O : Op . var Ri Rd : ArbolBEt[Op, IntM] . eq valor(N) = N . eq valor(Ri [+] Rd) = valor(Ri) + valor(Rd) . eq valor(Ri [-] Rd) = valor(Ri) - valor(Rd) . eq valor(Ri [*] Rd) = valor(Ri) * valor(Rd) . ceq valor(Ri [/] Rd) = valor(Ri) / valor(Rd)

    if valor(Rd) =/= 0 . endfm)

  • 9

    Propiedades

    var A : ArbolBEt[N H] . var N : MachineInt .

    n-hojas(A) == 1 + n-nodos(A) n-hojas(A)

  • 10

    Árboles completos y llenos

    sorts ArbBCompleto[N H] ArbBLleno[N H] . subsorts Elt.H < ArbBCompleto[N H] < ArbBLleno[N H]

    < ArbolBEtq[N H] . vars Ac1 Ac2 : ArbBCompleto[N H] . var R : Elt.N . cmb Ac1[R]Ac2 : ArbBCompleto[N H]

    if altura(Ac1) == altura(Ac2) .

    vars A1 A2 : ArbBLleno[N H] . cmb A1[R]Ac2 : ArbBLleno[N H]

    if altura(A1) == 1 + altura(Ac2)) . cmb Ac1[R]A2 : ArbBLleno[N H]

    if altura(Ac1) == altura(A2) .

  • 11

    Árboles equilibrados en altura

    sorts ArbBheq[N H] . subsorts Elt.H < ArbBheq[N H] < ArbolBEtq[N H] .

    vars Ah1 Ah2 : ArbBheq[N H] . var R : Elt.N .

    cmb Ah1[R]Ah2 : ArbBheq[N H] if altura(Ah2)

  • 12

    Árboles equilibrados en peso

    sort ArbBpeq[N H] . subsorts Elt.H < ArbBpeq[N H] < ArbolBEtq[N H] .

    vars Ap1 Ap2 : ArbBpeq[N H] . var R : Elt.N .

    cmb Ap1[R]Ap2 : ArbBpeq[N H] if n-nodos(Ap2)

  • 13

    Propiedades especiales

    var Ac : ArbBCompleto[N H] . n-hojas(Ac) == 2 ** altura(Ac) . n-nodosNivel(N,Ac) == 2 ** N si 0 < N

  • Árboles Binarios Ordenados

  • 15

    Pares Ordenados

    (fth PARORD is including ORDTOT . sorts ParOrd Cont Cont? . subsort Cont < Cont? . op : Elt Cont -> ParOrd . op clave : ParOrd -> Elt . op contenido : ParOrd -> Cont . op actualizar : Cont Cont -> Cont . op no-encontrado : -> Cont? . var K : Elt . var C : Cont . eq clave() = K . eq contenido() = C .

    endfth)

  • 16

    Árboles binarios ordenados (I) (view Par from TRIV to PARORD is

    sort Elt to ParOrd . endv)

    (fmod ABB[X :: PARORD] is protecting ARBOLB[Par][X] . sorts Abb[X] AbbNv[X] . subsorts AbbNv[X] < Abb[X] < ArbolB[Par][X] . subsort AbbNv[X] < ArbolBNv[Par][X] . op insertar : ParOrd.X Abb[X] -> AbbNv[X] . op eliminar : Elt.X Abb[X] -> Abb[X] . op consulta : Elt.X Abb[X] -> Cont?.X . op esta? : Elt.X Abb[X] -> Bool . ops min max : AbbNv[X] -> Par.X .

  • 17

    Árboles binarios ordenados (II)

    vars P Q : ParOrd.X . var K : Elt.X . var C : Cont.X . var A : Abb[X] . vars Ai Ad : AbbNv[X] .

    mb vacio : Abb[X] . mb vacio [P] vacio : AbbNv[X] . cmb vacio [P] Ad : AbbNv[X] if clave(P) < clave(min(Ad)) . cmb Ai [P] vacio : AbbNv[X] if clave(max(Ai)) < clave(P) . cmb Ai [P] Ad : AbbNv[X] if clave(max(Ai)) < clave(P) and

    clave(P) < clave(min(Ad)) . eq min(Ai) = if ri(Ai) == vacio

    then raiz(Ai) else min(ri(Ai)) fi . eq max(Ai) = if rd(Ai) == vacio

    then raiz(Ai) else max(rd(Ai)) fi .

  • 18

    Árboles binarios ordenados (III)

    eq insertar(P,A) = if A == vacio then vacio [P] vacio else if clave(P) == clave(raiz(A))

    then *** actualizar ri(A) [] rd(A) else *** insertar en una rama

    if clave(P) < clave(raiz(A)) then insertar(P,ri(A)) [raiz(A)] rd(A) else ri(A) [raiz(A)] insertar(P,rd(A)) fi

    fi fi .

  • 19

    Eliminación en un Abb

  • 20

    Árboles binarios ordenados (IV)

    eq eliminar(K,A) = if A == vacio then vacio else if K == clave(raiz(A))

    then if ri(A) == vacio then rd(A) else if rd(A) == vacio then ri(A)

    else eliminar(clave(max(ri(A))),ri(A)) [max(ri(A))] rd(A)

    fi fi

    else if K < clave(raiz(A)) then eliminar(K,ri(A)) [raiz(A)] rd(A) else ri(A) [raiz(A)] eliminar(K,rd(A)) fi

    fi fi .

  • 21

    Árboles binarios ordenados (V)

    eq esta?(K,A) = if A == vacio then false else if K == clave(raiz(A)) then true

    else if K < clave(raiz(A)) then esta?(K,ri(A)) else esta?(K,rd(A)) fi fi fi .

    eq consulta(K,A) = if A == vacio then no-encontrado else if K == clave(raiz(A)) then contenido(raiz(A))

    else if K < clave(raiz(A)) then consulta(K,ri(A)) else consulta(K,rd(A)) fi fi fi .

  • 22

    Árboles binarios ordenados equilibrados en altura (AVL)

    (fmod AVL[X :: PARORD] is protecting MACHINE-INT . protecting ABB[X] . sort Avl[X] AvlNv[X] . subsorts AvlNv[X] < Avl[X] < Abb[X] . subsort AvlNv[X] < AbbNv[X] . op insertarEq : ParOrd.X Avl[X] -> AvlNv[X] . op eliminarEq : Elt.X Avl[X] -> Avl[X] . op equilibrar : Abb[X] -> Abb[X] . ops rotIzq rotDer : AbbNv[X] -> AbbNv[X] . op pendiente : ArbolB[X] -> MachineInt .

  • 23

    Avl (II)

    vars P Q : ParOrd.X . var T:ArbolBNv[X] . var A:Avl[X] . vars A1 A2 : AvlNv[X] .

    mb vacio : Avl[X] . cmb A [P] A2 : Avl[X] if clave(P)

  • 24

    Avl (III)

    eq pendiente(vacio) = 0 . eq pendiente(T) = altura(rd(T)) - altura(ri(T)) .

    vars B B1 B2 B3 : ABB[X] . ceq rotIzq(B1 [P] vacio) = B1 [P] vacio

    if B1 [P] vacio : Abb[X] . ceq rotIzq(B1 [P] (B2[Q]B3)) = (B1[P]B2) [Q] B3

    if B1 [P] (B2[Q]B3) : Abb[X] . ceq rotDer(vacio [P] B2) = vacio [P] B2

    if vacio [P] B2 : Abb[X] . ceq rotDer((B1[P]B2) [Q] B3) = B1 [P] (B2[Q]B3)

    if (B1[P]B2) [Q] B3 : Abb[X] .

  • 25

    Consideraciones

    En un avl todos los subárboles tendrán pendientes comprendidas entre –1 y 1. Una inserción sólo puede modificar la pendiente de los subárboles con raíz en el camino de acceso al nodo insertado. Esta modificación sólo puede dar lugar a pendientes con valores –2 o 2 en el peor caso. El árbol se equilibra a partir del nodo más próximo al punto de inserción que haya quedado desequilibrado. En el caso de la eliminación de un nodo, la situación es parecida.

  • 26

    Equilibrado (I)

    rotDer

  • 27

    Equilibrado (II)

    rotIzq

    rotDer

  • 28

    Avl : equilibrar

    eq equilibrar(B) = if B == vacio then vacio else if pendiente(B) == -2

    then if pendiente(ri(B)) == 1 then rotDer(rotIzq(ri(B)) [raiz(B)] rd(B)) else rotDer(B) fi

    else if pendiente(B) == 2 then if pendiente(rd(B)) == -1

    then rotIzq(ri(B) [raiz(B)] rotDer(rd(B))) else rotIzq(B) fi

    else B fi fi

    fi .

  • 29

    Avl : insertar en equilibrio

    eq insertarEq(P,A) = if A == vacio then vacio [P] vacio else if clave(P) == clave(raiz(A)) then *** actualizar

    ri(A) [] rd(A)

    else *** insertar en una rama if clave(P) < clave(raiz(A)) then equilibrar(insertarEq(P,ri(A)) [raiz(A)] rd(A)) else equilibrar(ri(A) [raiz(A)] insertarEq(P,rd(A))) fi

    fi fi .

  • 30

    Avl : eliminar en equilibrio var K : Elt.X . eq eliminarEq(k,A) =

    if A == vacio