SUGGESTED B+Tree DELETION ALGORITHM:
adatdi

1. 	Find the entry to be deleted.

2.	Delete entry from leaf. If this leaf (call it Z)
	is left with less than necessary entries go to 3.
	Otherwise, terminate.

3.	If neither the right nor the left sibling of Z
	(same parent) has more than ceil[(n-1)/2] then
	goto 4.
	Otherwise, redistribute the entries from one sibling 
	with those in Z, so that half of the total are in sibling 
	and half in Z.
		* If one of the siblings has more records than
		  the other use it.
		* If both have the same amount use the left one 
		  (arbitrary choice)
	Change the new distinguishing key of Z (from its sibling)
	in the parent and terminate.

4.	Combine the entries in one sibling with those in Z.
	 /* this happens only when both adjacent siblings
	    have exactly ceil[n/2] entries-choose the left 
	    sibling if there is one
	  */
	Delete from parent the distinguishing key of Z (from 
	its siblings ) and delete the address of Z.
	If the parent is left with less than the necessary 
	entries (sparse) goto 5.
	Otherwise Terminate.
	  /* if the parent is the root, it can not become sparse
	     unless no value is left. In this case, the present 
	     node with the records of Z  and its sibling, become 
	     the root and in fact the entire tree
	   */

5.	Internal Node Redistribution: If an internal node is
	left sparse, temporarily concatanate it with the 
	larger of its siblings (or left if both are of equal size)
	AND the key distinguishing it from its sibling.
	If there are exactly (n-1) keys in this 
	concatanation GOTO 6.
	Otherwise (there are more than [n-1] keys) redistribute 
	values by placing the new middle value in the parent 
	in the place of the previous distinguishing 
	value and Terminate.

6.	The [n-1] values (entries/keys) are merged to become one 
	internal node. The key and addresses in the parent are 
	deleted. If the parent is too sparse Goto Step 5.
	Otherwise Terminate.