Finn etterfølger uten å bruke foreldrepeker

Question

Finn etterfølger uten å bruke foreldrepeker

stemmer

1

Etterfølgeren til et element i en BST er elementet etterfølger i den sorterte orden som er bestemt ved den inorder traversering. Å finne den følgeren når hver node har en peker til sin foreldrenoden er presentert i CLRS algoritme lærebok (Introduction to Algoritmer av MIT Press).

Ideen om å finne etterfølgeren her er - hvis den rette treet av node xer ikke-tom, etterfølgeren xer minimum element i riktig treet. Ellers er etterfølgeren den laveste stamfar xsom venstre barn er også en stamfar x(forutsatt en node er en stamfar til seg selv).

Kan vi finne etterfølgeren uten å bruke pekeren til foreldrenoden?

Noen ganger vår treet node ikke har denne pekeren. Jeg slet et par timer, men kan ikke skrive riktig kode.

algorithm binary-search-tree

Publisert på 25/09/2010 klokken 23:39
kilden bruker szli

På andre språk...

5 svar

stemmer

0

Hvis du ikke har tilgang til pekeren til foreldrenoden så du trenger å vite hvem faren er. Hvis du ikke vet det, hvordan kunne du gå opp i treet?

Svarte 25/09/2010 kl. 23:55
kilden bruker Loïc Février

stemmer

6

Inspirert av Sheldon løsning, er dette ikke-rekursiv versjon av løsningen.


if (right[x]  != NIL)
    return min(right[x]);
else
{
    candidate = NIL;
    y = root; 
    while  (y!= x) // y is used as a probe

        if (key[x] < key[y])
            {
            candidate = y;
            y = y ->left;

             }
        else
            y = y->right;
}
return candidate;

Hvis kandidaten == NIL, er x maks i treet og ikke har en etterfølger.

Svarte 26/09/2010 kl. 17:17
kilden bruker szli

stemmer

1

Jeg fant en elegant løsning for i-order etterfølger uten foreldre peker her -> http://www.geeksforgeeks.org/archives/9999

Tanken er

1. Dersom noden har rett sub-treet, da dens etterfølger det minste element i den høyre sub-treet

Dersom noden rett sub-treet er tom, da dens etterfølger er et av dets forfedre, som kan finnes ovenfra og ned uten moder pekeren, med den følgende algoritme:

la innledning Aktuell_Node være rot, succ_node = null;

Tilfelle 1: Hvis søkeelementet er mindre enn Aktuell_Node, da det aktuelle elementet er en potensiell etterfølger - sted succ_node ved Aktuell_Node og bevege Aktuell_Node til dens venstre noden (fordi søkeelementet er i den venstre subtre)

Tilfelle 2: Hvis søket elementet er større enn Aktuell_Node, det er ikke en potensiell etterfølger (Hvordan kan et mindre element være etterfølgeren?). Så ingen grunn til å plassere succ_node her, men flytter Aktuell_Node til høyre.

terpe prosessen til du kommer null eller selve elementet og returnere succ_node.

Svarte 13/09/2012 kl. 00:17
kilden bruker Balaji

stemmer

0

En rekursiv Java løsning kunne se på følgende måte:

public Integer successor(Integer value) {
    Node n = succ(root, value, null);
    if (null != n) {
       return n.value;
    }
    return null;
}

private Node succ(Node n, Integer x, Node p) {
    if (null == n) {
        return null;
    }

    if (x < n.value) {
        return succ(n.left, x, n);
    } else if (x > n.value) {
        return succ(n.right, x, p);
    }
    if (null != n.right) {
        return min(n.right);
    }
    return p;
}

Som kunde vi bare passere i verdien av noden som vi ønsker å vite etterfølger. Da vi begynne å søke fra roten til vi fant verdien vi var ute etter. Nå er det to tilfeller:

Hvis gjeldende node har en rett barnet, da etterfølg det minste elementet i den aktuelle noden rett treet
Ellers var det noden p (forelder pekeren), som bare ble oppdatert når vi gikk igjen i treet

Svarte 09/09/2013 kl. 16:41
kilden bruker nastra

Sheldon L. Cooper · Accepted Answer · 2010-09-26 00:15

stemmer

3

Forfatteren merket dette svaret som det beste.

Dette bør fungere:

TREE-SUCCESSOR(T, x)
  if right[x] != NIL
    return TREE-MINIMUM(right[x])
  else
    return FIND-TREE-SUCCESSOR(root[T], x, NIL)

FIND-TREE-SUCCESSOR(y, x, c)
  if y = x
    return c
  if key[x] < key[y]
    return FIND-TREE-SUCCESSOR(left[y], x, y)
  else
    return FIND-TREE-SUCCESSOR(right[y], x, c)

FIND-TREE-SUCCESSORholder på c(kandidat) den siste noden der vi slått venstre.

Svarte 26/09/2010 kl. 00:15
kilden bruker Sheldon L. Cooper