Binary Search Tree Analysis based on Wikipedia

Read more from wikipedia: http://en.wikipedia.org/wiki/Binary_search_tree 

1. what is it?  

 a node-based binary
tree data structure which has the following properties:
The left subtree of a node contains only nodes with keys less than the
node's key.
The right subtree of a node contains only nodes with keys greater than the node's key.
The left and right subtree must each also be a binary search tree.
There must be no duplicate nodes.
2. Time complexity: 

Time complexity in big O notation
	Average	Worst case
Space	O(n)	O(n)
Search	O(log n)	O(n)
Insert	O(log n)	O(n)
Delete	O(log n)	O(n)

3. Operations: 

 1) search algorithm in pseudocode: 

  iterative version, finds a BST node:

algorithm Find(key, root):
current-node := root
while current-node is not Nil do
if current-node.key = key then
return current-node
else if key < current-node.key then
current-node := current-node.left
else
current-node := current-node.right

The following recursive version is equivalent:

algorithm Find-recursive(key, node):  // call initially with node = root
if node = Nil or node.key = key then
node
else if key < node.key then
Find-recursive(key, node.left)
else
Find-recursive(key, node.right)

 2) a typical BST insertion might be performed in C++:

void insert(int value)
{
if(root == NULL)
root = new Node(value);
else
insertHelper(root, value);
}

void insertHelper(Node* node, int value)
{
if(value < node->key)
{
if(node->leftChild == NULL)
node->leftChild = new Node(value);
else
insertHelper(node->leftChild, value);
}
else
{
if(node->rightChild == NULL)
node->rightChild = new Node(value);
else
insertHelper(node->rightChild, value);
}
}

an iterative approach to inserting into a binary search tree in Java:

private Node m_root;

public void insert(int data) {
if (m_root == null) {
m_root = new TreeNode(data, null, null);
return;
}
Node root = m_root;
while (root != null) {
// Choose not add 'data' if already present (an implementation decision)
if (data == root.getData()) {
return;
} else if (data < root.getData()) {
// insert left
if (root.getLeft() == null) {
root.setLeft(new TreeNode(data, null, null));
return;
} else {
root = root.getLeft();
}
} else {
// insert right
if (root.getRight() == null) {
root.setRight(new TreeNode(data, null, null));
return;
} else {
root = root.getRight();
}
}
}
}

Below is a recursive approach to the insertion method.

private Node m_root;

public void insert(int data){
if (m_root == null) {
m_root = new TreeNode(data, null, null);
} else {
internalInsert(m_root, data);
}
}

private static void internalInsert(Node node, int data){
// Choose not add 'data' if already present (an implementation decision)
if (data == node.getKey()) {
return;
} else if (data < node.getKey()) {
if (node.getLeft() == null) {
node.setLeft(new TreeNode(data, null, null));
} else {
internalInsert(node.getLeft(), data);
}
} else {
if (node.getRight() == null) {
node.setRight(new TreeNode(data, null, null));
} else {
internalInsert(node.getRight(), data);
}
}
}

3) Deletion: 3 types: 

Deleting a leaf (node with no children): Deleting a leaf is easy, as we can simply remove it from the tree.
Deleting a node with one child: Remove the node and replace it with its child.
Deleting a node with two children: Call the node to be deleted N. Do not delete N. Instead, choose either its in-order successor
node or its in-order predecessor node, R. Replace the value of N with the value of R, then delete R.

 code in C Sharp:

private static Node Search(Node tree, double data, out Node parent)
{
// empty tree
if (tree == null)
{
parent = null;
return null;
}

// node to find is the tree root
if (data == tree.data)
{
parent = null;
return tree;
}

// peek left
if (tree.left != null && data == tree.left.data)
{
parent = tree;
return tree.left;
}

// peek right
if (tree.right != null && data == tree.right.data)
{
parent = tree;
return tree.right;
}

if (data < tree.data)
return Search(tree.left, data, out parent);

if (data > tree.data)
return Search(tree.right, data, out parent);

// unreacheable code
parent = null;
return null;
}

public static Node Smallest(Node tree, out Node parent)
{
if (tree == null)
{
parent = null;
return null;
}

if (tree.left == null)
{
parent = null;
return tree;
}

if (tree.left.left == null)
{
parent = tree;
return tree.left;
}

return Smallest(tree.left, out parent);
}

public static void Remove(ref Node tree, double data)
{
Node NodeToRemove, NodeToMove, parent;
// Find node to remove
NodeToRemove = Search(tree, data, out parent);

// if the value is not found, return
if (NodeToRemove == null) return;

// Deleting a leaf or a node with one child:
// Remove the node and replace it with the child (or null if it has none)
if (NodeToRemove.left == null || NodeToRemove.right == null)
{
// Get a reference to the child
Node child;
if (NodeToRemove.left == null)
child = NodeToRemove.right;
else
child = NodeToRemove.left;

// if the node is the root of the tree
if (parent == null)
tree = child;

// if the node has a parent
else
{
if (NodeToRemove.data > parent.data)
parent.right = child;
else
parent.left = child;
}
return;
}
// Deleting a node with two children:
// Call the node to be deleted N. Do not delete N.
// Instead, choose either its in-order successor node or its in-order predecessor node, R.
// Replace the value of N with the value of R, then delete R.
NodeToMove = Smallest(NodeToRemove.right, out parent);

// replace the value
NodeToRemove.data = NodeToMove.data;

// Remove the bottom node
Remove(ref NodeToMove, NodeToMove.data);
if (parent == null)
NodeToRemove.right = NodeToMove;
else
parent.left = NodeToMove;
}

code in C++.

template <typename T>
bool BST<T>::remove(const T & itemToDelete)
{
return remove(root, itemToDelete);
}

template <typename T>
bool BST<T>::remove(Node<T>* & ptr, const T& key)       //helper remove function
{
if (ptr==nullptr)
return false;   // item not in BST

if (key < ptr->data)
remove(ptr->LeftChild, key);
else if (key > ptr->data)
remove(ptr->RightChild, key);
else
{
Node<T> *temp;

if (ptr->LeftChild==nullptr)
{
temp = ptr->RightChild;
delete ptr;
ptr = temp;
}
else if (ptr->RightChild==nullptr)
{
temp = ptr->LeftChild;
delete ptr;
ptr = temp;
}
else    //2 children
{
temp = ptr->RightChild;
Node<T> *parent = nullptr;

while(temp->LeftChild!=nullptr)
{
parent = temp;
temp = temp->LeftChild;
}
ptr->data = temp->data;
if (parent != nullptr)
remove(parent->LeftChild, parent->LeftChild->data);
else
remove(ptr->RightChild, ptr->RightChild->data);
}
}
}

4) Traversal 

 An in-order traversal of a binary search tree will always result in a sorted list of node items (numbers, strings or other comparable items).

An in-order traversal algorithm for C is given below.

void in_order_traversal(struct Node *n, void (*cb)(void*))
{
struct Node *cur, *pre;

if(!n)
return;

cur = n;

while(cur) {
if(!cur->left) {
cb(cur->val);
cur= cur->right;
} else {
pre = cur->left;

while(pre->right && pre->right != cur)
pre = pre->right;

if (!pre->right) {
pre->right = cur;
cur = cur->left;
} else {
pre->right = NULL;
cb(cur->val);
cur = cur->right;
}
}
}
}

5) Sort:  Similar to heapsort,
we insert all the values we wish to sort into a new ordered data structure—in this case a binary search tree—and then traverse it in order, building our result.