Het onderzoek of 2 BST vertegenwoordigers reeksen isomorf indien

Je zou een in-order boom gang te doen op hen beiden tegelijk en controleer of de elementen zijn hetzelfde.

Deelnemers (2) eerste, swap paren knooppunten - en hun nakomelingen - op elk niveau, dit tot alle boom zetten in een binaire zoekboom, met links nodes <= rechts nodes. Dit zal enige tijd duren n log n. Zodra je dit hebt gedaan, als je een binary search boom en een boom isomorf met een binaire zoekboom, je hebt nu twee binaire zoekboom. Zoals opgemerkt door yi_H, betekent dit dat een in-order boom lopen dezelfde elementen in dezelfde volgorde zal uitwijzen of beide bomen zijn isomorf. Maar een in-orde boom gang, in een boom opgeslagen in een array als in uw voorbeeld, is slechts een eigenaardige manier van het bezoeken van alle elementen van de array, dus als de bomen zijn isomorf de twee arrays moeten identiek zijn.

De eenvoudigste manier om deel te behandelen (1) is als u extra ruimte kan vinden. Voor het laagste niveau van elke boom, het bouwen van een hash-tabel voor elke boom die de bladeren. Vergelijk de twee hash tabellen en uitstappen als ze niet dezelfde set van knooppunten houden. Geef elk blad een identificatie die het identificeert, waarbij de identifiers zijn hetzelfde als de bladeren zijn hetzelfde. Voor de ouders van die bladeren, het bouwen van een andere hash tafel, met behulp van de waarden bij elke ouder en de identifiers van die kinderen. Nogmaals, controleer dan of de twee groepen zijn hetzelfde en exit, zo niet. Wijs elke ouder een identificator die hetzelfde als de waarde bij de knoop is hetzelfde en de identificaties van de kinderen zijn gelijk. U kunt doorgaan op deze manier de boom tot aan de wortel te bereiken. Als alle sets zijn gelijk helemaal naar boven, heb je twee isomorfe bomen, en de identifiers geven u de correspondentie op elk niveau. Dit is ingewikkelder dan (1) en neemt extra ruimte, maar alleen lineaire tijd.

Voor BST:

1. Neem de eerste elementen van beide arrays en match. Indien niet gelijk vervolgens BST niet hetzelfde zijn.
2. Vind de eerste straat links kinderen die nog niet is gescand (op de posities leftPos1 en leftPos2) en matchen. Zo niet dan geëvenaard BST zijn niet hetzelfde.
3. Vind de eerste straat rechts kinderen die nog niet is gescand (op de posities rightPos1 en rightPos2) en matchen. Zo niet dan geëvenaard BST zijn niet hetzelfde.
4. Indien links en rechts kinderen passen, het uitvoeren van dezelfde bewerkingen recursief aan beide paar sublijsten / deelboom (van leftPos1 en leftPos2) en (uit rightPos1 en rightPos2). De ouder van deze substructuur is het eerste element van de array.

Tijdens het zoeken links en rechts kinderen in de sublijst, kunnen er elementen die al zijn gescand. Dergelijke elementen informatie, controleert element dat u de kinderen van de huidige subboom. Als de huidige subboom is links van de ouder, vergelijk het element met de ouder, als deze behoort tot de rechterkant dan negeren element.

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