Găsirea dacă 2 BST reprezentat de matrice sunt izomorfe sau nu

Ai putea face o plimbare copac în ordine pe ambele simultan și să verifice dacă elementele sunt aceleași.

A lua parte (2) prima, perechile de swap de noduri - și descendenții acestora - la fiecare nivel, după cum este necesar pentru a transforma fiecare copac într-un arbore binar de căutare, cu noduri din stânga <= noduri dreapta. Acest lucru va avea nevoie de timp n log. După ce ați făcut acest lucru, dacă ați avea un arbore binar de căutare și un copac izomorf cu un arbore binar de căutare, aveți acum doi arbori de căutare binare. După cum a subliniat yi_H, acest lucru înseamnă că o plimbare copac în ordine va arăta aceleași elemente în aceeași ordine în cazul în care ambii arbori sunt izomorfe. Dar o plimbare copac în ordine, într-un copac stocate într-o matrice ca în exemplele tale, este doar un mod aparte de a vizita toate elementele de matrice, astfel încât în ​​cazul în care copacii sunt izomorfe cele două matrice trebuie să fie identice.

Cel mai simplu mod de a gestiona o parte (1), este dacă puteți găsi un spațiu suplimentar. Pentru cel mai scăzut nivel al fiecărui copac, să construiască un tabel hash pentru fiecare copac exploatație frunze. Comparați cele două tabele de dispersie și de ieșire în cazul în care nu dețin același set de noduri. Dă fiecare frunză un identificator care identifică, în cazul în care identificatorii sunt aceleași în cazul în care frunzele sunt aceleași. Pentru părinții acestor frunze, a construi un alt tabel hash, folosind valorile de la fiecare părinte și identificatorii acelor copii. Din nou, verificați dacă cele două seturi sunt aceleași și ieșire în cazul în care nu. Atribuie fiecărui părinte un identificator care este același în cazul în care valoarea de la nodul este aceeași și identificatorii copiilor săi sunt aceleași. Puteți continua în acest fel până copac, până când ajunge la rădăcină. În cazul în care toate seturile sunt aceleași tot drumul în sus, aveți doi copaci izomorfe, iar identificatorii da corespondența la fiecare nivel. Acest lucru este mult mai complexă decât o parte (1) și are spațiu suplimentar, dar numai timpul liniar.

Pentru BST:

1. Ia primele elemente ale ambelor tablouri și potrivire. În cazul în care nu este egal, atunci BST nu sunt fie aceleași.
2. Găsiți primii copii rămași , care nu a fost scanată (la pozițiile leftPos1 și leftPos2) și meciul. În cazul în care nu se potrivesc , atunci BST nu sunt aceleași.
3. Găsiți primii copii dreapta care nu a fost scanate (la pozițiile rightPos1 și rightPos2) și meciul. În cazul în care nu se potrivesc , atunci BST nu sunt aceleași.
4. În cazul în care se potrivesc atât cu copii stânga și dreapta, efectuați aceleași operații recursiv pe cele două perechi de subliste / subarborelui (de la leftPos1 și leftPos2) și (de la rightPos1 și rightPos2). Părintele acestor subramificație este primul element al șirului.

În timp ce caută copiii stânga și dreapta în sublista, pot exista elemente care sunt deja scanate. Pentru a afla astfel de elemente, verificați dacă acel element care poate fi copiii subarborelui curent. În cazul în care subarborele curent este la partea stanga a părintelui, apoi comparați elementul cu părintele, în cazul în care fac parte din partea dreaptă, apoi ignora acel 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;
}