Encontrando ya sea 2 BST representado por matrices son isomorfos o no

Se podría hacer un recorrido del árbol en el orden de los dos al mismo tiempo y comprobar si los elementos son los mismos.

Tomando la parte (2) primero, los pares de intercambio de nodos - y sus descendientes - en cada nivel, según sea necesario para activar cada árbol en un árbol de búsqueda binario, con nodos izquierda <= nodos adecuados. Esto tomará tiempo n log n. Una vez hecho esto, si usted tenía un árbol de búsqueda binaria y una isomorfo árbol con un árbol de búsqueda binaria, que ahora tiene dos árboles binarios de búsqueda. Como ha señalado yi_H, esto significa que un paseo árbol en orden se muestran los mismos elementos en el mismo orden si ambos árboles son isomorfos. Sin embargo, un recorrido del árbol en orden, en un árbol almacenada en una matriz como en sus ejemplos, es sólo una forma peculiar de visitar todos los elementos de la matriz, por lo que si los árboles son isomorfos las dos matrices deben ser idénticos.

La forma más fácil de manejar parte (1) es si se puede encontrar un espacio adicional. Para el nivel más bajo de cada árbol, construir una tabla hash para cada árbol que sostiene las hojas. Compare las dos tablas hash y de salida si ellos no tienen el mismo conjunto de nodos. Dé a cada hoja un identificador que identifica, donde los identificadores son los mismos si las hojas son los mismos. Para los padres de esas hojas, construir otra tabla hash, utilizando los valores en cada uno de los padres y los identificadores de esos niños. Una vez más, comprobar que los dos conjuntos son los mismos y de salida si no. Asignar cada padre un identificador que es la misma si el valor en el nodo es el mismo y los identificadores de sus hijos son los mismos. Puede continuar en este camino hasta el árbol hasta llegar a la raíz. Si todos los conjuntos son los mismos todo el camino hasta, tiene dos árboles isomorfos, y los identificadores de darle la correspondencia en cada nivel. Esto es más compleja que la parte (1) y toma más espacio, pero sólo el tiempo lineal.

Para BST:

1. Dar los primeros elementos de ambas matrices y fósforo. Si no iguales, entonces no están BST ser el mismo.
2. Encuentra los primeros niños que quedan que no ha sido escaneados (en las posiciones leftPos1 y leftPos2) y fósforo. Si no coinciden, BST no son iguales.
3. Encuentra los primeros niños derecha que no ha sido escaneados (en las posiciones rightPos1 y rightPos2) y fósforo. Si no coinciden, BST no son iguales.
4. Si los dos hijos izquierdo y derecho coinciden, la realizan las mismas operaciones de forma recursiva en el doble par de sublistas / subárbol (de leftPos1 y leftPos2) y (desde rightPos1 y rightPos2). El padre de estos sub-árbol es el primer elemento de la matriz.

Si bien la búsqueda de los hijos izquierdo y derecho en la lista secundaria, puede haber elementos que ya se han escaneado. Para averiguar tales elementos, comprobar que el elemento que puede ser los hijos del subárbol actual. Si el subárbol actual está al lado izquierdo de la matriz, a continuación, comparar el elemento con el padre, si pertenecen a la derecha y luego ignorar ese elemento.

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