一个很全面的Binary Search Tree java实现

/** */ /**
  * tree.java
  * demonstrates binary tree
  * to run this program: c>java TreeApp
   */

import  java.io. * ;
import  java.util. * ;   // for Stack class
/

class   Node
... {
     public   int  iData ;             // data item (key)
     public   double  dData;       // data item
     public  Node leftChild;      // this node's left child
     public  Node rightChild;     // this node's right child

     public   void  displayNode()    // display ourself
    ... { 
        System.out.print( " { " );
        System.out.print(iData);
        System.out.print( " ,  " );
        System.out.print(dData);
        System.out.print( " } " );
    }
}    // end class Node

// /

class  Tree
... {
     private  Node root;       // first node of tree

     // .......................................................................
     public  Tree()              // constructor
     ... {
        root  =   null  ;           // no nodes in tree yet
    }            
     // .......................................................................
     public  Node find( int  key)    // find node with given key
     ... {                                   // (assumes not-empty tree)
         Node current  =  root;    // start at root

          while (current.iData  !=  key)      // while no match,
         ... {
             if ( key  <  current.iData)                    // go left ?
                   current  =  current.leftChild;
             else                                              // or go right?
                   current  =  current.rightChild;  
            
             if ( current  ==   null  )             //  if no child,
                    return   null ;                 // didn't find it
        }

         return  current;                       // found it
    } // end find()
     // .......................................................................
     public   void  insert( int  id, double  dd)
     ... {
        Node newNode  =   new  Node();    // make new node
        newNode.iData  =  id;                 // insert data
        newNode.dData  =  dd;

         if ( root  ==   null  )                      // no node in root
            root  =  newNode;
         else                                       // root occupied
         ... {
            Node current  =  root;            // start at root
            Node parent;
             while ( true )                          // (exits internally)
             ... {
                parent  =  current;
                 if ( id  <  current.iData )       // go left?
                 ... {
                    current  =  current.leftChild;
                     if ( current  ==   null  )                // if end of the line
                     ... {                                        // insert on left
                          parent.leftChild  =  newNode;
                           return ;
                    }
                } // end if go left
                 else                                 // or go right? 
                 ... {
                    current  =  current.rightChild;
                     if ( current  ==   null  )                // if end of the line
                     ... {                                        // insert on right
                        parent.rightChild  =  newNode;
                         return ;
                    }
                } // end else go right
            } // end while
        } // end else on root
    } // end insert()
     // .......................................................................
     public   boolean  delete(  int  key )  // delete node with given key
     ... {
        Node current  =  root;
        Node parent  =  root;
         boolean  isLeftChild  =   true ;

         while ( current.iData  !=  key )      // search for node
         ... {
            parent  =  current;

             if ( key  <  current.iData )                // go left ?
             ... {
                isLeftChild  =   true ;
                current  =  current.leftChild;
            }
             else                                          // or go right?
             ... {
                isLeftChild  =   false ;
                current  =  current.rightChild;
            }

             if ( current  ==   null  )            // end of the line,
                  return   false ;                // didn't find it
        } // end while

// found node to delete
        
         //  if no children,simply delete it
         if ( current.leftChild == null   &&  current.rightChild == null )
         ... {
             if ( current  ==  root )          // if root;
                root  =   null ;                      // tree is empty
             else   if ( isLeftChild )
                parent.leftChild  =   null ;       // disconnect from parent
             else
                parent.rightChild  =   null ;
        }

         // if no right child,replace with left subtree
         else   if  ( current.rightChild ==   null  )
         ... {
             if ( current  ==  root )
                root  =  current.leftChild;
             else   if ( isLeftChild )
                parent.leftChild  =  current.leftChild;
             else
                parent.rightChild  =  current.leftChild;
        }

         // if no left child, replace with right subtree
         else   if ( current.leftChild ==   null  )
         ... {
             if ( current  ==  root )
                root  =  current.rightChild;
             else   if ( isLeftChild )
                parent.leftChild  =  current.rightChild;
             else
                parent.rightChild  =  current.rightChild;
        }

         // two children,so replace with inorder successor
         else
         ... {
             // get successor of node to delete (current)
            Node successor  =  getSuccessor( current );

             // connect parent of current to successor instead
             if ( current  ==  root)
                root  =  successor;
             else   if ( isLeftChild )
                parent.leftChild  =  successor;
             else
                parent.rightChild  =  successor;

             // connect successor to current's left child
            successor.leftChild  =  current.leftChild;
        } // end else two children

         // (successor can't have a left child)
         return   true ;          // success
    } // end delete();
     // .......................................................................
     // returns node with next-highest value after delNode
     // goes to right child,then right child's left descendents
     private  Node getSuccessor( Node delNode )
     ... {
        Node successorParent  =  delNode;
        Node successor  =  delNode;
        Node current  =  delNode.rightChild;             // go to right child

         while ( current  !=   null )                              // until no more left children
         ... {                                                                             
            successorParent  =  successor;
            successor  =  current;
            current  =  current.leftChild;                          // go to leftChild
        }
                                                                  
         if ( successor  !=  delNode.rightChild )           // if successor not right child make connections
         ... {
            successorParent.leftChild  =  successor.rightChild;
            successor.rightChild  =  delNode.rightChild;
        }

         return  successor;
    } // end getSuccessor()
     // .......................................................................
     public   void  traverse(  int  traverseType)
     ... {
         switch (traverseType)
         ... {
             case   1 : System.out.print( " Preorder traversal:  " );
                       preOrder(root);
                        break ;
             case   2 : System.out.print( " Inorder traversal:  " );
                        inOrder(root);
                         break ;
             case   3 : System.out.print( " Postorder traversal:  " );
                        postOrder(root);
                         break ;
        }
        System.out.println();
    } // end traverse();
     // .......................................................................
     private   void  preOrder(Node localRoot)
     ... {
         if ( localRoot  !=   null )
         ... {
            System.out.print(localRoot.iData  +   "   " );
            preOrder(localRoot.leftChild);
            preOrder(localRoot.rightChild);
        }
    } // end preOrder();
     // .......................................................................
     private   void  inOrder(Node localRoot)
     ... {
         if ( localRoot  !=   null )
         ... {
            inOrder(localRoot.leftChild);
            System.out.print(localRoot.iData  +   "   " );
            inOrder(localRoot.rightChild);
        }
    } // end inOrder();
     // .......................................................................
     private   void  postOrder(Node localRoot)
     ... {
         if ( localRoot  !=   null  )
         ... {
            postOrder(localRoot.leftChild);
            postOrder(localRoot.rightChild);
            System.out.print(localRoot.iData  +   "   " );
        }
    } // end postOrder();
     // .......................................................................
     public   void  displayTree()
     ... {
        Stack globalStack  =   new  Stack();
        globalStack.push(root);
         int  nBlanks  =   32 ;
         boolean  isRowEmpty  =   false ;
        System.out.println( " .................................................................... " );
         while (isRowEmpty  ==   false  )
         ... {
            Stack localStack  =   new  Stack();
            isRowEmpty  =   true ;

             for ( int  j = 0 ; j < nBlanks; j ++ )
                 System.out.print( "   " );

             while (globalStack.isEmpty()  ==   false )
             ... {
                Node temp  =  (Node)globalStack.pop();
                 if ( temp  !=   null )
                 ... {
                    System.out.print(temp.iData);
                    localStack.push(temp.leftChild);
                    localStack.push(temp.rightChild);

                     if (temp.leftChild  !=   null   ||  temp.rightChild  !=   null )
                        isRowEmpty  =   false ;
                }
                 else
                 ... {
                    System.out.print( " .. " );
                    localStack.push( null );
                    localStack.push( null );
                }

                 for ( int  j = 0 ; j < nBlanks * 2 - 2 ; j ++ )
                    System.out.print( "   " );
            } // end while globalStack not empty
            System.out.println();
            nBlanks  /=   2 ;
             while (localStack.isEmpty()  ==   false )
                 globalStack.push( localStack.pop() );
        } // end while is RowEmpty is false
        System.out.println( " ...................................................................... " );
    } // end dispalyTree();
     // .......................................................................
} // end class Tree
// /
class  TreeApp
... {
     public   static   void  main(String[] args)  throws  IOException
     ... {
         int  value;
        Tree theTree  =   new  Tree();

        theTree.insert( 50 , 1.5 );
        theTree.insert( 25 , 1.2 );
        theTree.insert( 75 , 1.7 );
        theTree.insert( 12 , 1.5 );
        theTree.insert( 37 , 1.2 );
        theTree.insert( 43 , 1.7 );
        theTree.insert( 30 , 1.5 );
        theTree.insert( 33 , 1.2 );
        theTree.insert( 87 , 1.7 );
        theTree.insert( 93 , 1.5 );
        theTree.insert( 97 , 1.5 );

         while ( true )
         ... {
            System.out.print( " Enter first letter of show,  " );
            System.out.print( " insert, find, delete, or traverse:  " );
             int  choice  =  getChar();
             switch (choice)
             ... {
                 case   ' s ' : theTree.displayTree();
                             break ;
                 case   ' i ' :  System.out.print( " Enter value to insert:  " );
                            value  =  getInt();
                            theTree.insert(value,value + 0.9 );
                             break ;
                 case   ' f ' : System.out.print( " Enter value to find:  " );
                            value  =  getInt();
                            Node found  =  theTree.find(value);
                             if (found  !=   null )
                              ... {
                                System.out.print( " Found:  " );
                                found.displayNode();
                                System.out.print( " " );
                            }
                             else
                                System.out.println( " Cound not find value  "   +   ' ' );
                             break ;
                 case   ' d ' : System.out.print( " Enter value to delete:  " );
                            value  =  getInt();
                             boolean  didDelete  =  theTree.delete(value);
                             if ( didDelete )
                                System.out.print( " Deleted  " +  value + ' ' );
                             else
                                System.out.print( " Cound not delete value  "   +   ' ' );
                             break ;
                 case   ' t ' : System.out.print( " Enter type 1,2 or 3:  " );
                            value  =  getInt();
                            theTree.traverse(value);
                             break ;
                 default :
                    System.out.print( " Invalid entry " );
            } // end switch
        } // end while
    } // end main()
     // ...............................................................................
     public   static  String getString()  throws  IOException
     ... {
        InputStreamReader isr  =   new  InputStreamReader(System.in);
        BufferedReader br  =   new  BufferedReader(isr);
        String s =  br.readLine();
         return  s;
    }
     // ...............................................................................
     public   static   char  getChar()  throws  IOException
     ... {
        String s  =  getString();
         return  s.charAt( 0 );
    }
     // ...............................................................................
     public   static   int  getInt()  throws  IOException
     ... {
        String s  =  getString();
         return  Integer.parseInt(s);
    }
     // ...............................................................................
} // end class TreeApp
// /