Dizilerin ile temsil 2 BST izomorf olup olmadıklarını Bulma

Aynı anda her ikisi üzerinde bir in-sipariş ağaç yürüyüş yapmak ve elementler aynı olup olmadığını kontrol edebilir.

parçası olmak (2) ilk olarak, değiştirilebilir düğüm çifti - ve bunların soyundan - gerektiğinde her seviyede, sol düğüm <= doğru düğümü ile, bir ikili arama ağacına her ağaç açın. Bu zaman alacak n log n edecektir. Eğer bir ikili arama ağacı ve ikili arama ağacı bulunan ağaç izomorf olsaydı, Bunu yaptıktan sonra, artık iki ikili arama ağaçları var. yi_H işaret ettiği gibi, bu her iki ağaçlar izomorf ise bir in-sipariş ağaç yürüyüş aynı sırada aynı unsurları görüneceği anlamına gelir. Ama bir in-sipariş ağaç yürüme, sizin örneklerde olduğu gibi bir dizi saklanan bir ağaçta, sadece dizinin bütün elemanları ziyaret tuhaf bir yoludur, böylece ağaçlar izomorf ise iki diziler aynı olmalıdır.

Eğer ek alan bulabilirse parçasını işlemek için en kolay yolu (1) 'dir. Her ağacın en düşük düzeyi için yaprakları tutan her ağaç için bir karma tablo oluşturmak. onlar düğümler aynı set tutun yoksa iki hash tabloları ve çıkış karşılaştırın. Her yaprağı yaprak aynı olup olmadığını tanımlayıcılar aynıdır şekilde tanımlayan bir tanımlayıcı, verin. Bu yaprakların ebeveynler için her ebeveyn de değer ve bu çocukların tanımlayıcılar kullanılarak, başka karma tablo oluşturmak. Yine iki kümesi aynı ve çıkış eğer olmadığını kontrol edin. Her bir faj görüntüleme düğüm değeri aynıdır ve çocuk tanımlayıcıları, aynı ise aynı olan bir tanımlayıcı atama. Eğer kök ulaşana kadar ağacın yukarı bu şekilde devam edebilir. Tüm setleri yukarı aynı tüm yol varsa, iki izomorf ağaçlar ve tanımlayıcılar size her düzeyde yazışmalar verir. Bu (1) kısmı daha karmaşıktır ve ekstra alan, ancak yalnızca lineer zaman alır.

BST için:

1. Dizilerin ve maçın hem ilk elemanlarını atın. Eşit Değilse o zaman BST aynı değildir.
2. İlk sola çocukları bulun taranmış edilmemiştir ve maçın (pozisyonlara leftPos1 ve leftPos2 at). Sonra eşleşti Değilse BST aynı değildir.
3. İlk sağ çocukları bulun taranmış edilmemiştir ve maçın (pozisyonlara rightPos1 ve rightPos2 at). Sonra eşleşti Değilse BST aynı değildir.
4. hem sol ve sağ çocuklar eşleşirse, / (leftPos1 ve leftPos2 itibaren) alt ağaç ve (rightPos1 ve rightPos2 itibaren) sublists iki çifti üzerinde ardışık aynı işlemleri gerçekleştirmek. Bu ağacın üst dizisinin birinci elemandır.

alt liste içinde sol ve sağ çocukları araştırırken, zaten taranır unsurları olabilir. Böyle unsurları öğrenmek için, geçerli altağacın çocukları olabilir o öğeyi olun. Geçerli alt ağaç ebeveyn sol tarafında ise o zaman o öğeyi görmezden sağ tarafta aitse, o zaman, ebeveyn ile eleman karşılaştırın.

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