Facebook Interview Question for

Catherine

You can solve this using a stack and a root value.


You initialize the root as Integer.MIN_VALUE

for each number:
if number less than root -> return false;

if number greater than root -> pop stack until the peek value of the stack is greater than the number, make the last popped value the root, the other popped values are the leafes

push the number on the stack

Ursula@CA

With BST pre-order array, leaf node seems to be the element that smaller than next element. Is this assumption correct? If so, we can use this to write two loops for each of the array.

透明

From a pre-order traversal array of a BST, we can detect leaves by doing a sequential scan of the array with a helper stack (see code below for finding the next leaf). - \: s. w7 V9 X+ l
From there, we can just keep on finding the next leaf in each tree and compare until we find leaves that don't match (or we run out of leaves in one tree before the other; or we just find no mismatches).

A binary tree with pre-order traversal array of 1,2,3 can be a root of 1 with left child 2 and right child 3, or it could be a linked list (e.g. 1 with right child 2, and 2 with right child 3) " o; g' ~1 [4 V8 n$ ^
- a: }% {1 l! S& }1 {* X
Runtime: O(n). Space complexity: O(log n)

static int? NextLeaf(int[] preOrderTraversal, int offset, Stack<int> stack)
        {
            if (offset == preOrderTraversal.Length - 1)
3 w+ e& f2 u6 y) e  X            {
4 M8 C$ `' [2 f9 V" w0 b                return offset;
            }

            if (offset > preOrderTraversal.Length - 1)
            {
                return null;
  q$ @0 _$ z  K- ]7 }# S3 x. L            }

( b, M, `$ {7 B2 q$ _  J            var current = preOrderTraversal[offset];
" A1 ]) p7 g4 F( A  l6 A+ t; U            var next = preOrderTraversal[offset + 1];
6 [& D1 U8 g+ w1 n3 b
            // Next is smaller? Then it is the left sub-tree root
            // Next item is bigger. Is it bigger than my ancestor?
            // No - then current is the parent, and the next item is the root of the right sub-tree
/ ?  y6 k/ X8 F8 A+ y7 f* U( Q: |            // Yes - then current is a leaf. Pop ancestors until you get to the common ancestor (and pop that one too)
            if (current > next || stack.Count == 0 || next < stack.Peek())
) o7 Y. i$ ?* E4 m) F( ^            {
                stack.Push(current);
3 U2 ~0 m) ~1 Y2 }1 y$ k                return NextLeaf(preOrderTraversal, offset + 1, stack);
+ R7 Z1 t! w  a7 O- A            }
7 s* F5 \3 N) q9 R4 P( }8 I
            // The stack is empty, or the next is not bigger than the immediate ancestor. 
' Q! m' `! ?" k  C+ m            while (stack.Count > 0 && stack.Peek() < next) stack.Pop();
, u; T; M+ J. Z: O  H# }5 @            return offset;
        }
# ]1 x% ?7 {! K6 c  b
; U* d2 c- Z) A/ j: F9 a; V0 A# V/ w            if (preOrderTraversal1.Length == 0 || preOrderTraversal2.Length == 0)
            {
) x1 @7 M0 i/ t& \4 k) f0 Y5 ?  g& o2 e                return;
            }
2 ~& @( {4 P- S! J8 f4 d3 U% Q
8 n3 @# a% v- n  P( P7 s            var iStack = new Stack<int>();
! p" V+ o9 a. u3 \1 y0 U, \8 c6 f3 d7 a            var jStack = new Stack<int>();
" q4 q8 z* p6 j* Q) Q( H, p            var i = NextLeaf(preOrderTraversal1, 0, iStack);
            var j = NextLeaf(preOrderTraversal2, 0, jStack);
' b+ X# t! p5 u4 Q1 z
            Console.WriteLine("Leaves: i {0}, j {1}", i, j);
6 J- c( c. _3 c% B- D            while (i.HasValue && j.HasValue && preOrderTraversal1[i.Value] == preOrderTraversal2[j.Value])
( M4 Q9 I2 [( |! Q& _7 }- |! n5 S            {
                i = NextLeaf(preOrderTraversal1, i.Value + 1, iStack);
                j = NextLeaf(preOrderTraversal2, j.Value + 1, jStack);
            }

            Console.WriteLine("First mismatching leaves {0}, {1}", i, j);
# y" J; e7 ]' I        }

This can't be done for a generic tree, since there's no way to determine the leaves based on a pre-order traversal array.