I just finished a script that shows the properties of the binary search tree data structure.

These data structures are organized such that the data lies in “nodes” and each node connects directly to up to two new nodes. These new nodes are called the children of the node, and the original node is called the parent. Because there are up to two children, we designate one child as the “left” child, and the other as the “right” child with the properties that the value stored in the left child is less than the value in the parent, which in itself is less than the value of its right child. If a parent has less than two children, then one (or both) of its children are given the value of null.

The insert and delete procedures need to make sure that they keep the elements of a binary search tree in sorted order.

To insert into a BST, we must first find the correct location where the new element will be placed. This means comparing the value of the new element to the current head of the tree, resulting in three possible outcomes.

if the head is null, then insert the new node at the current position because there is no subtree to compare it to.

if the value of the new element is less than the value at the head node, run the insert procedure on the left child of head.

if the value of the new element is greater than the value at the head node, run the insert procedure on the right child of head.

Similarly, the remove procedure for a binary search tree must first find the element to be removed. Once that element is found, there are three cases depending on the type of node we are dealing with.

if the node has no children, then simply remove the node from the tree.

if the node has only one child (either a left child or a right child), then have the parent of the node point to the child of the node (thus bypassing the node itself).

if the node has two children, then we have two options, either replace the node with the minimum value of the right subtree or the maximum value of the left subtree. The nodes that have these minimum and maximum values will have at most one child because by definition a value less than the minimum value in a right subtree would be a left child and thus would be less than the minimum value, contradicting the meaning of a minimum value. Because these nodes have at most one child, we can now use the procedures above to remove these nodes from the tree.

Because a binary search tree is different than a standard array, there are different methods for viewing the its contents. Three common such methods are preorder, inorder, and postorder traversal.

Preorder traversal visits the nodes of a binary search tree in the order (node), (left child), (right child).

Inorder traversal visits the nodes of a binary search tree in the order (left child), (node), (right child).

Postorder traversal visits the nodes of a binary search tree in the order (left child), (right child), (node).

We are also interested in the depth of a tree, which amounts to the amount of layers or levels of the tree. This can be computed by counting the longest path from the root of the tree to a leaf node (a node with no children) in the tree.

Other Blogs that have covered this topic:

Stoimen’s Web Log

- Queue Data Structure (0.458)
- Topological Sort (0.343)
- Stack Data Structure (0.219)
- Visualizing Huffman Coding Trees (0.155)
- Approximating the Set Cover Problem (0.147)

i’d like to talk to you if i may…. try to reach me at soji_sky@yahoo.com….

very much interested to learn more abour your huffman code, binary search tree works… try to reach me as soon as you can… in great need… hping for your kind consideration…

love,

joster….