Lowest common ancestor in binary search tree

  This is a very common question, I  write this just for review. Because it is binary search tree. So we can use binary search tree's property to solve the problem. 

  Solution:  Assume the two nodes are n1 and n2 and n1 < n2, n is the lca to be found. if we n1 < n < n2 , then n is the lca. Otherwise recursively traverse the BST to find when n1 < n < n2. If n is greater than both n1 and n2, then lca lies on left subtree of n. If  n is smaller than both n1 and n2, then lca lies on right subtree of n. Assuming both n1 and n2 are in the BST. 

Consider the below BST for an example:

Below is cpp code to get the lca of this bst:

</pre><pre name="code" class="cpp">#include <iostream>

using namespace std;

template <class T>  class BST;

template <class T> class BSTNode	// binary search tree node definition
{
	friend class BST<T>;

private:
	BSTNode<T> *leftChild;	// left child
	BSTNode<T> *rightChild;	// right child
	T data;	// data domain

public:
	BSTNode() : leftChild(NULL), rightChild(NULL) {}	// constructor
	BSTNode(const T item) : data(item), leftChild(NULL), rightChild(NULL) {}	// constructor
	BSTNode(const T item, BSTNode<T> *left, BSTNode<T> *right) 
		: data(item), leftChild(left), rightChild(right) {}

	T getData() const { return data; }	// get data

	BSTNode<T>* getLeft() const { return leftChild; }	// get left child
	BSTNode<T>* getRight() const { return rightChild; }	// get right child
	~BSTNode() {}
};

template <class T> class BST	// binary search tree class definition
{
private:
	BSTNode<T> *root;	// root node
	void insert(const T &x, BSTNode<T> * &ptr); // insert node to the tree
	void insert_iter(const T &x, BSTNode<T> * &ptr);

	T lca(BSTNode<T> *ptr, T a, T b);	// return the lowest common ancester of node data between a and b
	T lca_iter(BSTNode<T> *ptr, T a, T b);	// iterative way to find lca
	bool find(T x, BSTNode<T> *ptr);	// find node in the binary search tree
	bool find_iter(T x, BSTNode<T> *ptr);	// find node in bst iterative way
public:
	BST<T>() : root(NULL) {}	// constructor
	void insert(const T &x) { insert_iter(x, root); }
	void insert(BSTNode<T> *ptr);
	void traverse(BSTNode<T> *current);
	void traverse() { traverse(root); }
	
	T lca(T a, T b) { return lca_iter(root, a, b); }
	bool find(T x) { return find_iter(x, root); }
};

template <class T> void BST<T>::insert(const T &x, BSTNode<T> * &ptr)
{
	if (ptr == NULL)
	{
		ptr = new BSTNode<T>(x);
		if (ptr == NULL) { cerr << "Out of space" << endl; exit(1); }
	}
	else if (x < ptr->data) insert(x, ptr->leftChild);
	else if (x > ptr->data) insert(x, ptr->rightChild);
}

template <class T> void BST<T>::insert_iter(const T &x, BSTNode<T> * &ptr)
{
	if (ptr == NULL)
	{
		ptr = new BSTNode<T>(x);
		return;
	}
	else
	{
		BSTNode<T> *temp = ptr;
		while (true)
		{
			if (temp->data == x)
			{
				return;
			}
			else if (x < temp->data)
			{
				if (temp->leftChild == NULL)
				{
					temp->leftChild = new BSTNode<T>(x);
					return;
				}
				else
				{
					temp = temp->leftChild;
				}
				
			}
			else if (x > temp->data)
			{
				if (temp->rightChild == NULL)
				{
					temp->rightChild = new BSTNode<T>(x);
					return;
				}
				else
				{
					temp = temp->rightChild;
				}
			}
		}
	}
}

template <class T> void BST<T>::insert(BSTNode<T> *ptr)
{
	BSTNode<T> *p = NULL;

	if (NULL == root)
	{
		root = ptr;
		return;
	}
	else
	{
		p = root;
	}

	while (true)
	{
		if (ptr->getData() == p->getData()) return;
		else if (ptr->getData() < p->getData())
		{
			if (p->getLeft() == NULL)
			{
				p->leftChild = ptr;
				return;
			}
			else
			{
				p = p->getLeft();
			}
		}
		else
		{
			if (p->getRight() == NULL)
			{
				p->rightChild = ptr;
				return;
			}
			else
			{
				p = p->getRight();
			}
		}
	}
}

template <class T> void BST<T>::traverse(BSTNode<T> *current)
{
	if (current != NULL)
	{
		cout << current->data << " ";
		traverse(current->leftChild);
		traverse(current->rightChild);
	}
}

template <class T> T BST<T>::lca(BSTNode<T> *ptr, T a, T b)
{
	//if (ptr == NULL) return T(NULL);

	//if (ptr->data > a && ptr->data > b)
	//{
	//	return lca(ptr->leftChild, a, b);
	//}

	//if (ptr->data < a && ptr->data < b)
	//{
	//	return lca(ptr->rightChild, a, b);
	//}

	//return ptr->data;

	if (!find(a) || !find(b)) return T(NULL);	// if a or b not in the bst, return default value.

	if (ptr == NULL) return T(NULL);	// if a and b are not in the tree or a == b then return default value of type T.

	if (a > b) { T temp = a; a = b; b = temp; }	// if a > b then swap them first.

	if (ptr->data > a && ptr->data < b) return ptr->getData();
	else if (ptr->data > a && ptr->data > b) return lca(ptr->leftChild, a, b);
	else return lca(ptr->rightChild, a, b);
	
}

template <class T> T BST<T>::lca_iter(BSTNode<T> *ptr, T a, T b)
{
	if (!find(a) || !find(b)) return T(NULL);	// if a or b not in the bst, return default value.

	if (ptr == NULL) return T(NULL);	// if a and b are not in the tree or a == b then return default value of type T.

	if (a > b) { T temp = a; a = b; b = temp; }	// if a > b then swap them first.

	BSTNode<T> *temp = ptr;

	while (temp != NULL)
	{
		if (temp->data > a && temp->data > b)
		{
			temp = temp->leftChild;
		}
		else if (temp->data < a && temp->data < b)
		{
			temp = temp->rightChild;
		}
		else
		{
			break;
		}
	}

	return temp->getData();
}

template <class T> bool BST<T>::find(T x, BSTNode<T> *ptr)
{
	if (ptr == NULL) return false;
	else if (x < ptr->data) return find(x, ptr->leftChild);
	else if (x > ptr->data) return find(x, ptr->rightChild);
	else return true;
}

template <class T> bool BST<T>::find_iter(T x, BSTNode<T> *ptr)
{
	if (ptr != NULL)
	{
		BSTNode<T> *temp = ptr;

		while (temp != NULL)
		{
			if (temp->data == x) return true;
			else if (temp->data > x) temp = temp->leftChild;
			else temp = temp->rightChild;
		}
	}

	return false;
}

int main()
{
	cout << "Hello world!" << endl;

	BST<int> *b = new BST<int>();
	b->insert(20);
	b->insert(8);
	b->insert(22);
	b->insert(4);
	b->insert(12);
	b->insert(10);
	b->insert(14);

	b->traverse();

	cout << endl;

	int anc = b->lca(14, 4);

	cout << anc << endl;


	/*BSTNode<int> *node = new BSTNode<int>(1);
	b->insert(node);*/

	getchar();
	return 0;
}

Below is c code for reference:

#include <stdio.h>
#include <stdlib.h>

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

struct node* newNode(int data)
{
	struct node* node = (struct node*)malloc(sizeof(struct node));
	node->data = data;
	node->left = node->right = NULL;
	return node;
}

/*
function to find LCA of n1 and n2. The function assumes that both n1
and n2 are present
*/
struct node* lca(struct node* root, int n1, int n2)
{
	if (root == NULL) return NULL;

	// if both n1 and n2 are smaller that root, then LCA lies in root's left subtree
	if (root->data > n1 && root->data > n2)
	{
		return lca(root->left, n1, n2);
	}

	// if both n1 and n2 are greater than root, then LCA lies in root's right subtree
	if (root->data < n1 && root->data < n2)
	{
		return lca(root->right, n1, n2);
	}

	return root;
}

struct node* lca_iter(struct node* root, int n1, int n2)
{
	if (root == NULL) return NULL;

	while (root != NULL)
	{
		if (root->data > n1 && root->data > n2)
		{
			root = root->left;
		}
		else if (root->data < n1 && root->data < n2)
		{
			root = root->right;
		}
		else
		{
			break;
		}
	}

	return root;
}


int main()
{
	struct node *root = newNode(20);
	root->left = newNode(8);
	root->right = newNode(22);
	root->left->left = newNode(4);
	root->left->right = newNode(12);
	root->left->right->left = newNode(10);
	root->left->right->right = newNode(14);

	int n1 = 10, n2 = 14;
	struct node *t = lca_iter(root, n1, n2);
	printf("LCA of %d and %d is %d \n", n1, n2, t->data);

	n1 = 14, n2 = 8;
	t = lca_iter(root, n1, n2);
	printf("LCA of %d and %d is %d \n", n1, n2, t->data);

	n1 = 10, n2 = 22;
	t = lca_iter(root, n1, n2);
	printf("LCA of %d and %d is %d \n", n1, n2, t->data);

	getchar();

	//system("pause");
	return 0;
}

reference:  Lowest Common Ancestor in a Binary Search Tree.