Megtaláljuk-e 2 BST képviselik tömbök izomorfak-e vagy sem

Megteheted in-order fabejáró mindkettőre egyidejűleg és ellenőrizze, hogy az elemek azonosak.

Vesz részt (2) bekezdésének első, csere pontpárokat - és leszármazottaik - minden szinten, ahogy kell fordulni minden fa bináris kereső fa, bal csomópontok <= right csomópontokat. Ez időt vesz igénybe n log n. Miután ezt megtette, ha volt egy bináris keresési fa és a fa izomorf bináris kereső fába, akkor most két bináris keresés fák. Amint azt yi_H, ez azt jelenti, hogy a program érdekében fabejáró megmutatja ugyanazokat az elemeket ugyanabban a sorrendben, ha mind a fák izomorfak. De egy in-order fabejáró, egy fa tömb tárolja, mint amelyeket a példákban csak egy sajátos módon a látogató minden elemét a tömb, így ha a fák izomorf a két tömböt azonosnak kell lennie.

A legegyszerűbb módja annak, hogy kezelni egy részét az (1) ha megtalálja további helyet. A legalacsonyabb szintet az egyes fa, épít egy hash táblát fa tartja a levelek. Hasonlítsuk össze a két hash táblák és kilép, ha azok nem rendelkeznek ugyanazokkal a csomópontokat. Adj minden levél egy azonosító, amely azonosítja azt, ahol az azonosítók azonos, ha a levelek azonos. A szülők ezeket a leveleket, építeni egy hash tábla segítségével az értékeket minden szülő és a azonosítóit azokat a gyerekeket. Ismét ellenőrizze, hogy a két azonos és kilépés, ha nem. Rendeljen minden szülő olyan azonosító, amelyet ugyanaz, ha az érték a csomópont ugyanaz, és a azonosítóit a gyermekek azonos. Akkor folytatni ily módon a fát, amíg el nem éri a gyökér. Ha az összes halmazok azonos egészen, akkor két izomorf fák, és az azonosítókat megadja a lehetséges minden szinten. Ez sokkal bonyolultabb, mint része (1), és úgy extra helyet, de csak a lineáris időben.

For BST:

1. Vegyük az első elemeit egyaránt tömbök és a mérkőzés. Ha nem egyezik, akkor BST nem lehet azonos.
2. Keresse meg az első balra gyerekek , hogy nem ellenőrizte (a pozíciókban leftPos1 és leftPos2) és a mérkőzés. Ha nem egyezik, akkor BST nem ugyanaz.
3. Keresse meg az első jobbra gyerekek , hogy nem ellenőrizte (a pozíciókban rightPos1 és rightPos2) és a mérkőzés. Ha nem egyezik, akkor BST nem ugyanaz.
4. Ha mind a bal és a jobb oldali gyermek egyeznek, a ugyanazok a műveletek rekurzívan a két párt sublists / részfa (az leftPos1 és leftPos2) és (az rightPos1 és rightPos2). A szülő Ezeknek részfájának az első eleme a tömb.

Miközben keresi a bal és a jobb gyerekek a allista, lehet, hogy az elemeket, amelyeket már beszkennelt. Ahhoz, hogy megtudja, az ilyen elemeket, ellenőrizze, hogy eleme, hogy lehet a gyerekek a jelenlegi részfa. Ha az aktuális részfa van bal oldalon a szülő, majd hasonlítsa össze az elemet a szülő, ha tartozik a jobb oldali majd figyelmen kívül hagyni ezt az elemet.

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