Question

1) Given 2 arrays containing elements of a complete Binary tree(level by level), without actually reconstructing a tree(i.e. by only doing swaps in an array), how can I find whether those 2 arrays are isomorphic or not ?

2) A better solution if one isomorphic tree forms a Binary Search Tree.

update e.g.

     5 
    / \
    4  7
   /\  /\
  2  3 6 8

can be represented in array as 5 4 7 2 3 6 8

Isomorphic trees are trees which can be converted to one another by rotation about nodes

     5 
    / \
    4  7
   /\  /\
  2  3 6 8



     5 
    / \
    4  7
   /\  /\
  3  2 6 8



     5 
    / \
    4  7
   /\  /\
  3  2 8 6



     5 
    / \
    7  4
   /\  /\
  8  6 3 2

Answer 1

For the first problem:

A bit of notation:

• t0, t1 – trees
• value(t) – the number stored at node
• left(t) – the left subtree
• right(t) – the right subtree

t1 and t2 are isomorphic, iff
t1 and t2 are empty,

or value (t1) == value (t2)

and

either left(t1) is isomorphic to left(t2) and right(t1) is isomorphic to right(t2),

or left(t1) is isomorphic to right(t2) and right(t1) is isomorphic to left(t2)

Assuming the trees are stored in an arrays, such that element 0 is the root and and if t is an index of an internal node 2t+1 and 2t+2 are indices of its immediate children, straightforward implementation:

#include <stdio.h>

#define N 7

int a[] = { 5, 4, 7, 2, 3, 6, 8 };
int b[] = { 5, 7, 4, 6, 8, 2, 3 };

int
is_isomorphic (int t1, int t2)
{
  if (t1 >= N && t2 >= N)
    return 1;

  if (a [t1] != b [t2])
    return 0;

  return ((is_isomorphic (2*t1 + 1, 2*t2 + 1)
           && is_isomorphic (2*t1 + 2, 2*t2 + 2))
          || (is_isomorphic (2*t1 + 1, 2*t2 + 2)
              && is_isomorphic (2*t1 + 2, 2*t2 + 1)));
}

int main ()
{
  printf ("%s\n", (is_isomorphic (0, 0) ? "yes" : "no"));
  return 0;
}

For the second problem, at each step, we compare the subtree of a with the smaller root to the subtree of b with the smaller root and then the subtree of a with the bigger root to the subtree of b with the bigger root (smaller and bigger than the current roots of a and b).

int
is_isomorphic_bst (int t1, int t2)
{
  if (t1 >= N && t2 >= N)
    return 1;

  if (a [t1] != b [t2])
    return 0;

  int t1l, t1r, t2l, t2r;
  if (a [2*t1 + 1] < a [t1] && a [t1] < a [2*t1 + 2])
    {
      t1l = 2*t1 + 1;
      t1r = 2*t1 + 2;
    }
  else if (a [2*t1 + 1] > a [t1] && a [t1] > a [2*t1 + 2])
    {
      t1l = 2*t1 + 2;
      t1r = 2*t1 + 1;
    }
  else
    return 0;

  if (b [2*t2 + 1] < b [t2] && b [t2] < b [2*t2 + 2])
    {
      t2l = 2*t2 + 1;
      t2r = 2*t2 + 2;
    }
  else if (b [2*t2 + 1] > b [t2] && b [t2] > b [2*t2 + 2])
    {
      t2l = 2*t2 + 2;
      t2r = 2*t2 + 1;
    }
  else
    return 0;

  return is_isomorphic_bst (t1l, t2l) && is_isomorphic_bst (t1r, t2r);
}