• Optimal Binary Search Trees (OBST).
  insures small heights in your trees.

Other Strategies to Maintain trees of shallow depth:
    To maintain a depth that is logarithmic in n;
	--Adjust the tree to maintain.
    AVL Trees are a good example.
	--AVL Trees require no additional info, but 
	  their algorithms are much more complex.
   Red Black Trees also use this method
	--Red Black Trees are easier to implement, 
          but require an extra bit of per node.
   Some NON-Binary Tree types include:
	2-3 Trees
	2-3-4 Trees
	These trees are named for the number of 
	children each node may have.  See the  Dinish 
        and Mheta book for examples and discussion.

ADT SPLAY TREES

Insert()
Delete()
Find()

With M operations, n of which are inserts the Time bounds are related to m lg n Time / Operation Amortized over the whole of operations.

Each Operation should make the tree stalkier on the whole.

Every time you splay on a node, you bring that node up to the root and adjust the other nodes accordingly. (Note: Q is the node splayed on, P is Q's parent and GP is Q's grandparent. A, B, C, and D are trees of their own.)

1)
   P                   Q
  / \                 / \
 A   Q    ==>        P   C
    / \             / \
   B   C           A   B
 
2)
    P                   Q
   / \                 / \
  Q   C    ==>        A   P
 / \                     / \
A   B                   B   C
 
 3)
    GP                       Q
   / \                      / \
  A   P                    P   D
     / \        ==>       / \
    B   Q                GP  C
       / \              / \
      C   D            A  B


4)
     GP                        Q
     / \                      / \
    P   D                    A   P
   / \          ==>             / \
  Q   C                        B  GP
 / \                              / \
A   B                            C   D

 
5)
    GP                        Q
   / \                      /   \
  A   P                    GP    P
     / \        ==>       / \   / \
    Q   D                A   B C   D
   / \
  B   C
 
6)
   GP                        Q
   / \                     /   \
  P   D                   P    GP
 / \    ==>              / \   / \
A   Q                   A   B C   D
   / \
  B   C

Using these primitives, you now must follow these rules to keep the tree in good form:

• On a Find(x) we must find the element, then splay upon the node x until it is the root of the tree.
• On an Insert(x) we must first insert the element x preserving the tree structure, then splay the node x upwards till it is the root of our tree.
• On a Delete (x) we must find the node to be deleted, delete it, and then splay the parent of x, until it is the root node of our tree.

The find operation is of key importance because it will promote speed based on the locality of our last find. Ie; if we are interested in a few elements more so than others, we would have beautiful performace with the splay tree. For example:

1)
   P                   Q
  / \                 / \
 A   Q    ==>        P   C
    / \             / \
   B   C           A   B
 
    P                   Q
   / \                 / \
  Q   C    ==>        A   P
 / \                     / \
A   B                   B   C
 
 
3)  GP                       Q
   / \                      / \
  A   P                    P   D
     / \        ==>       / \
    B   Q                GP  C
       / \              / \
      C   D            A  B
 
4)    GP                       Q
     / \                      / \
    P   D                    A   P
   / \          ==>             / \
  Q   C                        B  GP
 / \                              / \
A   B                            C   D
 
 
5)  GP                       Q
   / \                     /   \
  A   P                   GP    P
     / \        ==>      / \   / \
    Q   D               A   B C   D
   / \
  B   C

6)  GP                       Q
   / \                     /   \
  P   D                   P    GP
 / \    ==>              / \   / \
A   Q                   A   B C   D
   / \
  B   C
 
Assume we will perform

The inserts, and subsequent splays will generate a long
skinny tree.  Let's pickup at the insert of 3:

[ For clarity, the intermediate tree configurations
  are shown as each element is inserted, then splayed ]

upon ST.Insert(3):
 
          2
         / \
        1   3
 
the insert subroutine to splay on 3 would generate:
             3
            / \
           2
          / \
         1
 
upon ST.Insert(4):
             3
            / \
           2   4
          / \
         1
 
the insert subroutine to splay on 4 would generate:
 
               4
              / \
             3
            / \
           2
          / \
         1
upon ST.Insert(5):
               4
              / \
             3   5
            / \
           2
          / \
         1
 
 
the insert subroutine to splay on 5 would generate:
 
                 5
                / \
               4
              / \
             3
            / \
           2
          / \
         1
upon ST.Insert(6):
 
                 5
                / \
               4   6
              / \
             3
            / \
           2
          / \
         1
 
the insert subroutine to splay on 6 would generate:
 
                   6
                  / \
                 5
                / \
               4
              / \
             3
            / \
           2
          / \
         1
 
 
Then, if we were to execute ST.Find(1);
 
The tree would morph:

First;
 
                   6
                  / \
                 5
                / \
               4
              / \
             1
            / \
               2
              / \
                 3
Then;
 
                   6
                  / \
                 1
                / \
                   4
                  / \
                 2   5
                / \
                   3
Then finally as 1 makes its way to the top:
                   1
                  / \
                     6
                    / \
                   4
                  / \
                 2   5
                / \
                   3
 

Let F₁, F₂, F₃,...,F_m be a sequence of find operations on a BST. Let T* be the time to perform F₁,..,F_m on the optimal BST. There exists a constant C such that: This sequence of operations performing F₁,...,F₁ on a splay tree takes less than or equal to CT*.