Das Finden, ob 2 BST vertreten durch Arrays sind isomorph oder nicht

Sie könnten einen in Ordnung Baum zu Fuß auf beide gleichzeitig tun und prüfen Sie, ob die Elemente gleich sind.

Dabeisein (2) erster, Swap-Paare von Knoten - und ihre Nachkommen - auf jeder Ebene, wie notwendig, jeden Baum in einen binären Suchbaum zu drehen, mit dem linken Knoten <= rechte Knoten. Dies wird einige Zeit dauern n log n. Sobald Sie dies getan haben, wenn Sie einen binären Suchbaum und einen Baum isomorph mit einem binären Suchbaum haben, haben Sie jetzt zwei binäre Suchbäume. Wie durch yi_H wies darauf hin, bedeutet dies, dass ein in Ordnung wird Baum zu Fuß der gleichen Elemente in der gleichen Reihenfolge zeigen, wenn beiden Bäume isomorph sind. Aber ein in Ordnung Baum zu Fuß, in einem Baum in einem Array gespeichert, wie in Ihren Beispielen ist nur eine eigentümliche Art und Weise alle Elemente des Arrays zu besuchen, so dass, wenn die Bäume sind isomorph die beiden Arrays müssen identisch sein.

Der einfachste Weg, Teil (1) zu handhaben ist, wenn Sie zusätzlichen Platz finden können. Für die unterste Ebene jeden Baum, eine Hash-Tabelle für jeden Baum bauen, um die Blätter zu halten. Vergleichen Sie die beiden Hash-Tabellen und Ausgang, wenn sie den gleichen Satz von Knoten nicht halten. Geben Sie jedes Blatt eine Kennung, die sie identifiziert, wo die Kennungen sind die gleiche, wenn die Blätter gleich sind. Für die Eltern jener Blätter, bauen eine andere Hash-Tabelle, die Werte an jedem Elternteil und die Kennungen dieser Kinder verwenden. Wieder zu überprüfen, dass die beiden Sätze die gleiche und Ausfahrt sind, wenn nicht. Vergeben jeden Elternteil eine Kennung, die die gleiche, wenn der Wert an dem Knoten das gleiche ist und die Kennungen seiner Kinder sind gleich. Sie können auf den Baum auf diese Weise weitermachen, bis Sie die Wurzel erreichen. Wenn alle Sätze auf die gleiche ganzen Weg sind, haben Sie zwei isomorph Bäume, und die Kennungen geben Sie die Korrespondenz auf jeder Ebene. Dies ist komplexer als Teil (1) und nimmt besonders viel Platz, aber nur lineare Zeit.

Für BST:

1. Nimm die ersten Elemente beider Arrays und Spiel. Wenn nicht gleich dann BST sind nicht gleich.
2. Finden Sie die erste Straße links Kinder , die nicht gescannt wurde (an den Positionen leftPos1 und leftPos2) und Spiel. Wenn nicht übereinstimmen , dann ist BST nicht gleich.
3. Finden Sie die erste Straße rechts Kinder , die nicht gescannt wurde (an den Positionen rightPos1 und rightPos2) und Spiel. Wenn nicht übereinstimmen , dann ist BST nicht gleich.
4. Wenn beide linke und rechte Kinder entsprechen, führen die die gleichen Operationen rekursiv auf dem zwei Paar Sublisten / Teilbaum (von leftPos1 und leftPos2) und (von rightPos1 und rightPos2). Die Mutter dieser Unterstruktur ist das erste Element des Arrays.

Während die linken und rechten Kinder in der Unterliste suchen, kann es Elemente, die bereits gescannt werden. Um solche Elemente herausfinden, stellen Sie sicher, daß das Element, dass es die Kinder des aktuellen Unterbaum sein kann. Wenn der aktuelle Baum, der an der linken Seite des Mutter ist, zu vergleichen, dann das Element mit dem Elternteil, wenn es an der rechten Seite gehören, dann dieses Element ignorieren.

#include <stdio.h>

#define BOOL int
#define TRUE 1
#define FALSE 0

BOOL isLeft(int parent, int child) {
    return child <= parent;
}

BOOL isRight(int parent, int child) {
    return child > parent;
}

BOOL isBelongToChild(int parent, int child, int value) {
    if (isLeft(parent, child) && (isLeft(parent, value))) {
        return TRUE;
    }
    if (isRight(parent, child) && (isRight(parent, value))) {
        return TRUE;
    }
    return FALSE;
}

int getLeftPosition(int * array, int size, int parent, BOOL parentExists) {
    int i;

    int first = *array;
    for (i = 1; i < size; i++) {
        int value = *(array + i);
        if (! isBelongToChild(parent, first, value)) {
            continue;
        }
        if (isLeft(first, value)) {
            return i;
        }
    }
    return -1;
}

int getRightPosition(int * array, int size, int parent, BOOL parentExists) {
    int i;

    int first = *array;
    for (i = 1; i < size; i++) {
        int value = *(array + i);
        if (! isBelongToChild(parent, first, value)) {
            continue;
        }
        if (isRight(first, value)) {
            return i;
        }
    }
    return -1;
}

BOOL areSame(int * array1, int pos1, int * array2, int pos2) {
    if (pos1 == -1 && pos2 == -1) {
        return TRUE;
    } else if (*(array1 + pos1) == *(array2 + pos2)) {
        return TRUE;
    } else {
        return FALSE;
    }
}

BOOL isSameBst(int * array1, int size1, int * array2, int size2, int parent, BOOL parentExists) {
    if (0 == size1 && 0 == size2) {
        return TRUE;
    }
    if (*array1 != *array2) {
        return FALSE;
    }

    int leftPos1 = getLeftPosition(array1, size1, parent, parentExists);
    int leftPos2 = getLeftPosition(array2, size2, parent, parentExists);
    if (! areSame(array1, leftPos1, array2, leftPos2)) {
        return FALSE;
    }
    int rightPos1 = getRightPosition(array1, size1, parent, parentExists);
    int rightPos2 = getRightPosition(array2, size2, parent, parentExists);
    if (! areSame(array1, rightPos1, array2, rightPos2)) {
        return FALSE;
    }

    if (leftPos1 > -1) {
        int result = isSameBst((array1 + leftPos1), size1 - leftPos1, (array2 + leftPos2), size2 - leftPos2, *array1, TRUE);
        if (FALSE == result) {
            return FALSE;
        }
    }
    if (rightPos1 > -1) {
        int result = isSameBst((array1 + rightPos1), size1 - rightPos1, (array2 + rightPos2), size2 - rightPos2, *array1, TRUE);
        if (FALSE == result) {
            return FALSE;
        }
    }
    return TRUE;
}

int main ()
{
    int a[] = { 5, 6, 2, 7, 4 };
    int b[] = { 5, 6, 7, 2, 4 };
    printf ("%s\n", (isSameBst(a, 5, b, 5, 0, FALSE) ? "yes" : "no"));
    return 0;
}