# Binary Search Tree : Lowest Common Ancestor

### Problem Statement :

```You are given pointer to the root of the binary search tree and two values v1 and v2. You need to return the lowest common ancestor (LCA) of v1  and v2  in the binary search tree.

In the diagram above, the lowest common ancestor of the nodes 4 and 6 is the node 3. Node 3 is the lowest node which has nodes  and  as descendants.

Function Description

Complete the function lca in the editor below. It should return a pointer to the lowest common ancestor node of the two values given.

lca has the following parameters:
- root: a pointer to the root node of a binary search tree
- v1: a node.data value
- v2: a node.data value

Input Format

The first line contains an integer, n , the number of nodes in the tree.
The second line contains n  space-separated integers representing node.data values.
The third line contains two space-separated integers, v1 and v2 .

To use the test data, you will have to create the binary search tree yourself. Here on the platform, the tree will be created for you.

The tree will contain nodes with data equal to v1 and v2.

Output Format

Return the a pointer to the node that is the lowest common ancestor of  and .```

### Solution :

```                            ```Solution in C :

In C++ :

/*
Node is defined as

typedef struct node
{
int data;
node * left;
node * right;
}node;

*/
bool isPresent(struct node* tree, int k)
{
if(tree==NULL)
return false;
if(tree->data==k)
return true;
return isPresent(tree->left,k) || isPresent(tree->right,k);
}

node * lca(node * tree, int m,int n)
{

if(tree==NULL)
return NULL;
if(tree->data>m && tree->data>n)
return lca(tree->left,m,n);
if(tree->data<m && tree->data<n)
return lca(tree->right,m,n);
if(tree->data<m && tree->data>n)
{
if(isPresent(tree->left,n) && isPresent(tree->right,m))
{
return tree;
}
else
return NULL;
}
if(tree->data>m && tree->data<n)
{
if(isPresent(tree->left,m) && isPresent(tree->right,n))
{
return tree;
}
else
return NULL;
}
if(tree->data==m)
{
if(tree->data<n)
{
if(isPresent(tree->right,n))
return tree;
else
return NULL;
}
if(tree->data>n)
{
if(isPresent(tree->left,n))
return tree;
else
return NULL;
}
if(tree->data==n)
return tree;
}
if(tree->data==n)
{
if(tree->data<m)
{
if(isPresent(tree->right,m))
return tree;
else
return NULL;
}
if(tree->data>m)
{
if(isPresent(tree->left,m))
return tree;
else
return NULL;
}
if(tree->data==m)
return tree;
}

return NULL;

}

In Java :

/* Node is defined as :
class Node
int data;
Node left;
Node right;

*/

static Node lca(Node root,int v1,int v2)
{
String left = "l";
String right = "r";
Node rootcopy1 = new Node();
rootcopy1 = root;
Node rootcopy2 = new Node();
rootcopy2 = root;

while(rootcopy1 != null) //finding v1's path
{
if(v1 == rootcopy1.data) //found it, no need to continue
{
break;
}
else if(v1 < rootcopy1.data)
{
rootcopy1 = rootcopy1.left;
}
else
{
rootcopy1 = rootcopy1.right;
}
}

while(rootcopy2 != null) //finding v2's path
{
if(v2 == rootcopy2.data) //found it, no need to continue
{
break;
}
else if(v2 < rootcopy2.data)
{
rootcopy2 = rootcopy2.left;
}
else
{
rootcopy2 = rootcopy2.right;
}
}

rootcopy1 = root; //need to travel along tree down from root again to find LCA to return

while(v1path.peek() != null && v2path.peek() != null) //comparing paths taken to find v1 and v2 to determine LCA
{
if(v1path.peek() == v2path.peek()) //if paths take same branch, LCA is farther down from here, keep going
{
if(v1path.peek() == "l") //take left
{
v1path.remove();
v2path.remove();
rootcopy1 = rootcopy1.left;
}
else //take right
{
v1path.remove();
v2path.remove();
rootcopy1 = rootcopy1.right;
}
}
else //this is the LCA since the paths split here
{
break;
}
}
return rootcopy1;
}

In python3 :

# Enter your code here. Read input from STDIN. Print output to STDOUT
'''
class Node:
def __init__(self,info):
self.info = info
self.left = None
self.right = None

// this is a node of the tree , which contains info as data, left , right
'''

def lca(root, v1, v2):
node=root
if node is None:
return None
if node.info>v1 and node.info>v2:
return lca(node.left,v1,v2)
elif node.info<v1 and node.info < v2:
return lca(node.right,v1,v2)
else:
return node

In C :

/* you only have to complete the function given below.
node is defined as

struct node {

int data;
struct node *left;
struct node *right;

};

*/
struct node *lca( struct node *root, int v1, int v2 ) {
if( root->data == v1 || root->data == v2 )
return root;
if( root->data > v1 && root->data > v2 )
return lca(root->left, v1, v2);
if( root->data < v1 && root->data < v2 )
return lca(root->right, v1, v2);
return root;
}```
```

## Get Node Value

This challenge is part of a tutorial track by MyCodeSchool Given a pointer to the head of a linked list and a specific position, determine the data value at that position. Count backwards from the tail node. The tail is at postion 0, its parent is at 1 and so on. Example head refers to 3 -> 2 -> 1 -> 0 -> NULL positionFromTail = 2 Each of the data values matches its distance from the t

## Delete duplicate-value nodes from a sorted linked list

This challenge is part of a tutorial track by MyCodeSchool You are given the pointer to the head node of a sorted linked list, where the data in the nodes is in ascending order. Delete nodes and return a sorted list with each distinct value in the original list. The given head pointer may be null indicating that the list is empty. Example head refers to the first node in the list 1 -> 2 -

## Cycle Detection

A linked list is said to contain a cycle if any node is visited more than once while traversing the list. Given a pointer to the head of a linked list, determine if it contains a cycle. If it does, return 1. Otherwise, return 0. Example head refers 1 -> 2 -> 3 -> NUL The numbers shown are the node numbers, not their data values. There is no cycle in this list so return 0. head refer

## Find Merge Point of Two Lists

This challenge is part of a tutorial track by MyCodeSchool Given pointers to the head nodes of 2 linked lists that merge together at some point, find the node where the two lists merge. The merge point is where both lists point to the same node, i.e. they reference the same memory location. It is guaranteed that the two head nodes will be different, and neither will be NULL. If the lists share

## Inserting a Node Into a Sorted Doubly Linked List

Given a reference to the head of a doubly-linked list and an integer ,data , create a new DoublyLinkedListNode object having data value data and insert it at the proper location to maintain the sort. Example head refers to the list 1 <-> 2 <-> 4 - > NULL. data = 3 Return a reference to the new list: 1 <-> 2 <-> 4 - > NULL , Function Description Complete the sortedInsert function

## Reverse a doubly linked list

This challenge is part of a tutorial track by MyCodeSchool Given the pointer to the head node of a doubly linked list, reverse the order of the nodes in place. That is, change the next and prev pointers of the nodes so that the direction of the list is reversed. Return a reference to the head node of the reversed list. Note: The head node might be NULL to indicate that the list is empty.