BST के लिए:
- दोनों सरणियों और मैच के पहले तत्व है। अगर बराबर नहीं तो BST ही नहीं हो रहे हैं।
- पहले छोड़ दिया बच्चों का पता लगाएं कि स्कैन किया नहीं किया गया है और मैच (पदों leftPos1 और leftPos2 पर)। तो मिलान नहीं BST ही नहीं हैं।
- पहला अधिकार बच्चों का पता लगाएं कि स्कैन किया नहीं किया गया है और मैच (पदों rightPos1 और rightPos2 पर)। तो मिलान नहीं BST ही नहीं हैं।
- दोनों बाएँ और दाएँ बच्चों से मेल खाते हैं, तो एक ही आपरेशन उप-सूचियों / सबट्री (leftPos1 और leftPos2 से) और (rightPos1 और rightPos2 से) के दो जोड़ी पर पुनरावर्ती प्रदर्शन करते हैं। इन सबट्री की मूल सरणी के पहले तत्व है।
sublist में छोड़ दिया और सही बच्चों खोज, वहाँ तत्वों पहले से स्कैन कर रहे हैं हो सकता है। ऐसे तत्वों जानने के लिए, उस तत्व है कि यह वर्तमान सबट्री के बच्चों किया जा सकता है की पुष्टि करें। वर्तमान सबट्री माता पिता की बाएं हाथ की ओर पर है, तो, माता पिता के साथ तत्व की तुलना अगर यह दाहिने हाथ की ओर से संबंध रखते हैं तो उस तत्व की उपेक्षा।
#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;
}
