Come riempire una matrice con elementi nodo da un albero binario di ricerca, in ordine crescente?

Question

Come riempire una matrice con elementi nodo da un albero binario di ricerca, in ordine crescente?

voti

0

In un compito scolastico dovrei completare un metodo che deve restituire un array di elementi di nodo in ordine ascendig. I nodi sono assemblati in un albero binario di ricerca, in modo per ordinare loro corretta, ho avuto una punta per creare un metodo ricorsivo per fare il lavoro.

Il problema è che questo non ha nemmeno cede tutti gli elementi dell'insieme secondo l'uscita di test (java.lang.AssertionError:. ToArray () non restituisce tutti gli elementi della collezione)

Non ho potuto trovare un altro modo per affrontare con l'array, e io non sono del tutto sicuro se la ricorsione funziona anche. Ogni aiuto è molto apprezzato. Qui di seguito è il mio codice:

public class BinarySearchTree<E extends Comparable<E>> implements
    IfiCollection<E> {

    Node root;
    Node current;
    int size = 0;
    int i = 0;

    public class Node {
    E obj;
    Node left, right;

    public Node(E e) {
        obj = e;
    }

    } // END class Node

    [...]

    public E[] toArray(E[] a) {

    Node n = root;

    a = sort(n, a);
    return a;

    }

    public E[] sort(Node n, E[] a) { //, int idx, E[] a) {

    if (n.left != null) {
        current = n.left;
        sort(current, a);
    }


    a[i] = current.obj;
    i++;

    if (n.right != null) {
        current = n.right;
        sort(current, a);
        }

    return a;

    } // END public Node sort

    [...]

} // END class BinarySearchTree

uscita di test:

java.lang.AssertionError: toArray () non restituisce tutti gli elementi della collezione .: Testperson ( Bender) compareTo (Testperson ( Fry)) == 0 previsto:. vero, ma era: false a inf1010.assignment .IfiCollectionTest.assertCompareToEquals (IfiCollectionTest.java:74) a inf1010.assignment.IfiCollectionTest.assertCompareToEquals (IfiCollectionTest.java:83) a inf1010.assignment.IfiCollectionTest.assertCompareToEqualsNoOrder (IfiCollectionTest.java:100) a inf1010.assignment.IfiCollectionTest.toArray ( IfiCollectionTest.java:202)

protected void assertCompareToEquals(TestPerson actual,
        TestPerson expected, String msg) {
            assertTrue(actual.compareTo(expected) == 0, String.format( // l:74
            %s: %s.compareTo(%s) == 0, msg, actual, expected));
}

    [...]

protected void assertCompareToEquals(TestPerson[] actual,
        TestPerson[] expected, String msg) {
    for (int i = 0; i < actual.length; i++) {
        TestPerson a = actual[i];
        TestPerson e = expected[i];
        assertCompareToEquals(a, e, msg); // l:83
    }
}

    [...]

protected void assertCompareToEqualsNoOrder(TestPerson[] actual,
        TestPerson[] expected, String msg) {
    assertEquals(actual.length, expected.length, msg);

    TestPerson[] actualElements = new TestPerson[actual.length];
    System.arraycopy(actual, 0, actualElements, 0, actual.length);

    TestPerson[] expectedElements = new TestPerson[expected.length];
    System.arraycopy(expected, 0, expectedElements, 0, expected.length);

    Arrays.sort(expectedElements);
    Arrays.sort(actualElements);

    assertCompareToEquals(actualElements, expectedElements, msg); // l:100
}

    [...]

@Test(dependsOnGroups = { collection-core },
    description=Tests if method toArray yields all the elements inserted in the collection in sorted order with smallest item first.)
public void toArray() {
    TestPerson[] actualElements = c.toArray(new TestPerson[c.size()]);

    for (int i = 0; i < actualElements.length; i++) {
        assertNotNull(actualElements[i],
                toArray() - array element at index  + i +  is null);
    }

    TestPerson[] expectedElements = allElementsAsArray();
    assertCompareToEqualsNoOrder(actualElements, expectedElements, // l:202
            toArray() does not return all the elements in the collection.);

    Arrays.sort(expectedElements);
    assertCompareToEquals(actualElements, expectedElements,
            toArray() does not return the elements in sorted order with 
                    + the smallest elements first.);


    TestPerson[] inArr = new TestPerson[NAMES.length + 1];
    inArr[NAMES.length] = new TestPerson(TEMP);
    actualElements = c.toArray(inArr);
    assertNull(actualElements[NAMES.length],
            The the element in the array immediately following the 
            + end of the list is not set to null);
}

Non so se devo inviare più del codice di test, è piuttosto esteso, e potrebbe essere un po 'troppo per un posto?

java binary-search-tree

È pubblicato 18/03/2011 alle 13:02
fonte dall'utente Aksel Mathias

In altre lingue...

4 risposte

voti

0

Credo che dove si sono confusi è che se si controlla come una ricerca binaria opere d'albero, è che si è sempre ordinata. Si inizia al vostro nodo principale, e poi come si inserisce un nuovo nodo, si inserisce nella posizione appropriata (cioè a sinistra oa destra) in base ai valori. Quindi non si dovrebbe avere a chiamare sorta per cominciare. Quindi vorrei cominciare da lì, e leggere su alberi binari di ricerca. Per esempio Wikipedia ha un articolo decente.

Aggiornamento: ignorare il mio commento non dovrebbe essere necessario fare nemmeno questo. Diciamo che si inserisce 8, 3, 7, 9, 12, 2, 10, 1 contro l'albero in questo ordine. Dovrebbe finire per assomigliare a questo:

Se si guarda questo significa per farli in ordine, avviare alla radice, quindi se ha un nodo alla sinistra avuto modo di sinistra, se non, per sé ritornare, e andare a destra se si ha un valore. Ripetendo questo per ogni nodo si incontrano.

Risposto il 18/03/2011 a 13:30
fonte dall'utente Jacob Schoen

voti

1

Vedo che hai il codice

if (n.left != null) {
        current = n.left;
        sort(current, a);
  }

ma io non riesco a trovare a quel punto si imposta di nuovo corrente al nodo corrente in modo che quando si fa

a[i] = current.obj;

si ottiene il risultato corretto. Probabilmente è per questo che non stai ricevendo tutti i risultati. In ogni caso non vedo (almeno dai frammenti di codice che hai postato) il motivo per cui le esigenze attuali di essere una variabile di classe e non solo dichiarati nel metodo di ordinamento. In generale, non dovrebbe essere l'utilizzo di variabili di classe, se non si ha realmente bisogno di loro.

Edit: È possibile sia corrente al nodo set si elaborano dopo aver chiamato sorta sul figlio sinistro come questo

current = n;
a[i] = current.obj;
i++;

O non corrente utilizzare a tutti, nel qual caso si avrebbe qualcosa di simile

if (n.left != null)
    sort(n.left, a);
a[i] = n.obj;
i++;
if (n.right != null)
    sort(n.right, a);

Risposto il 18/03/2011 a 13:57
fonte dall'utente Christina

voti

0

http://cs.armstrong.edu/liang/intro8e/html/BinaryTree.html

Il modo più semplice per fare quello che stai cercando è per attraversare l'albero simmetrico e aggiungere a un ArrayList. Per ottenere l'array è possibile chiamare il metodo .toArray () del ArrayList.

Se non è possibile utilizzare un ArrayList, dichiarare un indice e una serie di fuori del inordertraversal e l'incremento, è necessario sapere quanti elementi sono nella struttura di dichiarare l'array.

pseudo codice:

variables:
arraysize = root.count()
E[] inOrderNodeArray = new E[arraysize]
int index = 0

inorder traversal:
void inorder(Node n) {
    if (n) {
        inorder(n.left)
        inOrderNodeArray[index] = n
        index++
        inorder(n.right)
    }
}

Risposto il 18/03/2011 a 14:01
fonte dall'utente DTing

RoToRa · Accepted Answer · 2011-03-18 14:07

Ok, penso che il problema è l'utilizzo della variabile "globale" current. Il modo in cui è impostato, non ha molto senso. Non è necessario in ogni caso, perché la "corrente" Nodeè quello che viene fornito nei parametri.

Inoltre si dovrebbe prendere in considerazione rinominare la funzione. Non sei ordinamento nulla qui, basta raccogliere i contenuti della struttura, in modo da un nome come collectsarebbe più adatto.

public E[] toArray(E[] a) {
  Node n = root;
  a = collect(n, a);
  return a;
}

public E[] collect(Node n, E[] a) {

  if (n.left != null) {
    // If there is a left (smaller) value, we go there first
    collect(n.left, a);
  }


  // Once we've got all left (smaller) values we can
  // collect the value of out current Node.
  a[i] = n.obj;
  i++;

  if (n.right != null) {
    // And if there is a right (larger) value we get it next
    collect(n.right, a);
  }

  return a;
}

(Disclaimer: non ho ancora testato questo)

implementazione alternativa senza l'indice globale:

public E[] toArray(E[] a) {
  Node n = root;
  collect(n, a, 0);
  return a;
}

public int collect(Node n, E[] a, int i) {

  if (n.left != null) {
    // If there is a left (smaller) value, we go there first
    i = collect(n.left, a, i);
  }


  // Once we've got all left (smaller) values we can
  // collect the value of out current Node.
  a[i] = n.obj;
  i++;

  if (n.right != null) {
    // And if there is a right (larger) value we get it next
    i = collect(n.right, a, i);
  }

  return i;
}