Hogyan kell kitölteni egy tömb elemeit csomópont bináris kereső fába, növekvő sorrendben?

Question

Hogyan kell kitölteni egy tömb elemeit csomópont bináris kereső fába, növekvő sorrendben?

szavazat

0

Egy iskolai feladat kéne befejezni a módszer, amely vissza kell adnia egy sor csomópont elemek ascendens érdekében. A csomópontok vannak összeállítva egy bináris keresési fa, így rendezni, helyes, kaptam egy fülest, hogy hozzon létre egy rekurzív eljárás, hogy a munkát.

A probléma az, hogy ez nem is így az összes elem van a gyűjteményben teszt szerinti kimeneti (java.lang.AssertionError: toArray () nem adja vissza az összes elem van a gyűjteményben.)

Nem tudtam felér bármely más módon kell kezelni a tömb, és nem vagyok egészen biztos, ha a rekurziót is működik. Minden segítséget előre is köszönjük. Az alábbiakban a kód:

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

Teszt kimenet:

java.lang.AssertionError: toArray () nem tér vissza az összes elemet a gyűjtemény .: TestPerson ( Bender). compareTo (TestPerson ( Fry)) == 0 várható: igaz, de volt: hamis is inf1010.assignment .IfiCollectionTest.assertCompareToEquals (IfiCollectionTest.java:74) at inf1010.assignment.IfiCollectionTest.assertCompareToEquals (IfiCollectionTest.java:83) at inf1010.assignment.IfiCollectionTest.assertCompareToEqualsNoOrder (IfiCollectionTest.java:100) at 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);
}

Nem tudom, ha én kell küldeni nagyobb a vizsgált kód, elég kiterjedt, és lehet, hogy egy kicsit túl sok egy bejegyzést?

java binary-search-tree

A kérdést 18/03/2011 13:02
a forrás felhasználó Aksel Mathias

Más nyelveken...

4 válasz

szavazat

0

Azt hiszem, hol vannak zavarodva, hogy ha nézd meg, hogy egy bináris keresési fa munkák, az, hogy mindig rendezve. Akkor kezdődik a gyökér csomópontot, majd ahogy be egy új csomópontot, akkor beilleszti azt a megfelelő pozícióba (azaz a bal vagy a jobb oldalon) értékétől függően. Tehát akkor nem kell hívni a fajta kezdeni. Szóval kezdeném ott, és olvassa fel a bináris keresés fák. Például wikipedia egy tisztességes cikket.

Frissítés: Ignore én comment akkor nem kell tennie, hogy vagy. Tegyük fel, hogy helyezze 8, 3, 7, 9, 12, 2, 10, 1 a fába, ebben a sorrendben. Meg kell a végén néz ki, mint ez:

Ha megnézzük, hogy ez azt jelenti, hogy őket annak érdekében, hogy indítsa el a gyökér, akkor, ha van egy csomópont balra van, hogy a bal oldalon, ha nem, vissza is, és menj jobbra, ha annak értéke is van. Megismételve ezt minden egyes csomóponthoz találkozik.

Válaszolt 18/03/2011 13:30
a forrás felhasználó Jacob Schoen

szavazat

1

Látom a kódot

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

de nem úgy tűnik, hogy ezen a ponton beállított áram vissza az aktuális csomópont úgy, hogy ha nem

a[i] = current.obj;

kapsz a helyes eredményt. Ez valószínűleg miért nem kapok az összes eredményt. Mindenesetre nem látom (legalábbis a kódrészletek küldtél), hogy miért a jelenlegi igényeket, hogy egy osztály változó és nem csak deklarált a fajta módszer. Általában akkor nem kellene segítségével osztály változók, ha nem igazán szükség van rájuk.

Edit: Akkor sem aktuálissá vissza a csomópontján feldolgozása hívása után sort a bal gyerek, mint ez

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

Vagy nem használhatja aktuális egyáltalán ebben az esetben azt valami hasonló

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

Válaszolt 18/03/2011 13:57
a forrás felhasználó Christina

szavazat

0

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

A legegyszerűbb módja annak, hogy mit keres, hogy áthalad a fa inorder és csatolja egy ArrayList. Ahhoz, hogy a tömb akkor hívja a .toArray () metódus a ArrayList.

Ha nem tudja használni ArrayList állapítsa index és egy sor kívüli inordertraversal és növekmény, akkor meg kell tudni, hogy hány elem van a fán, hogy állapítsa meg a tömb.

pszeudo-kód:

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)
    }
}

Válaszolt 18/03/2011 14:01
a forrás felhasználó DTing

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

Ok, azt hiszem, a probléma a használata a „globális” változó current. Ez úgy van beállítva, nem sok értelme van. Nem kell, hogy amúgy is, mert az „aktuális” Nodeaz, amely el van látva a paramétereket.

Azt is meg kell vizsgálni átnevezés a funkciót. Nem válogatás itt semmit, csak gyűjtő tartalmát a fa, így a név, mint például collectalkalmasabb lenne.

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: én még nem teszteltem ezt)

Alternatív végrehajtása nélkül a globális index:

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;
}