二叉查找树（数据结构与算法分析代码）

该书的代码是通过public的成员函数使用调用private递归函数的常规技术。

不过我发现书本的insert函数是不可以实现结点相连。所以我参考了《算法导论》的insert函数（非递归）。

PS：有一些函数没有写。。。。注释的地方为原书private成员insert函数。。。。。

PS: 之前搞错了书本的代码。。。。其实书本的代码是可以实现的。。。。。书本的是递归。。。。。。。

注释地方为书本代码。。。。。。

  1 #include<iostream>
  2 using namespace std;
  3 
  4 template <typename Object>
  5 class BinarySearchTree
  6 {
  7 private:
  8     struct BinaryNode
  9     {
 10         Object data;
 11         BinaryNode * left;
 12         BinaryNode * right;
 13 
 14         BinaryNode( const Object & d, BinaryNode *l, BinaryNode *r )
 15             : data( d ), left( l ), right( r )
 16         { }
 17     };
 18 
 19 
 20 public:
 21     BinarySearchTree( )
 22     {
 23         root = NULL;
 24     }
 25 
 26     BinarySearchTree( const BinarySearchTree & rhs )
 27     {
 28         root = rhs.root;
 29     }
 30     ~BinarySearchTree( )
 31     {
 32         makeEmpty( );
 33     }
 34 
 35     bool isEmpty( ) const
 36     {
 37         if( root == NULL )
 38             return true;
 39         else
 40             return false;
 41     }
 42 
 43     const Object & findMin( ) const
 44     {
 45         return findMin( root );
 46     }
 47 
 48     const Object & findMax( ) const
 49     {
 50         return findMax( root );
 51     }
 52 
 53     bool contains( const Object & x ) const
 54     {
 55         return contains( x, root );
 56     }
 57 
 58     void insert( const Object & k )
 59     {
 60         BinaryNode * x = root;
 61         BinaryNode * y = NULL;
 62         BinaryNode * z = new BinaryNode( k, NULL, NULL );
 63 
 64         while( x != NULL )
 65         {
 66             y = x;
 67             if( k < x->data )
 68                 x = x->left;
 69             else
 70                 x = x->right;
 71         }
 72 
 73         if( y == NULL )
 74             root = z;
 75         else if( k < y->data )
 76             y->left = z;
 77         else
 78             y->right = z;
 79     }
 80 
 81     void remove( const Object & x )
 82     {
 83         remove( x, root );
 84     }
 85 
 86     void makeEmpty( )
 87     {
 88         makeEmpty( root );
 89     }
 90 
 91     void preRecursive( )
 92     {
 93         preRecursive( root );
 94     }
 95 
 96 private:
 97     BinaryNode * root;
 98 
 99     BinaryNode * findMin( BinaryNode * t ) const
100     {
101         if( t == NULL )
102             return NULL;
103         if( t->left == NULL )
104             return t;
105         return findMin( t->left );
106     }
107 
108     BinaryNode * findMax( BinaryNode * t ) const
109     {
110         if( t == NULL )
111             return NULL;
112         if( t->right == NULL )
113             return t;
114         return findMax( t->right );
115     }
116 
117     bool contains ( const Object & x, BinaryNode * t ) const
118     {
119         if( t == NULL )
120             return false;
121         else if( x < t->data )
122             return contains( x, t->left );
123         else if( x > t->data )
124             return contains( x, t->right );
125         else
126             return true;
127     }
128 
129     /*void insert( const Object & x, BinaryNode * & t ) const
130     {
131         if( t == NULL )
132         {
133             t = new BinaryNode( );
134             t->data = x;
135             t->left = t->right = NULL;
136 
137             t = new BinaryNode( x, NULL, NULL );
138         }
139         else if ( x < t->data )
140             insert( x, t->left );
141         else if ( x > t->data )
142             insert( x, t->right );
143         else
144             ;
145     }*/
146 
147     void remove( const Object & x, BinaryNode * & t ) const
148     {
149         if( t == NULL )
150             return ;
151         if( x < t->data )
152             remove( x, t->left );
153         else if( x > t->data )
154             remove( x, t->right );
155         else if( t->left != NULL && t->right != NULL )
156         {
157             t->data = findMin( t->right )->data;
158             remove( t->data, t->right );
159         }
160         else
161         {
162             BinaryNode * oldNode = t;
163             t = ( t->left != NULL ) ? t->left : t->right;
164             delete oldNode;
165         }
166     }
167 
168     void makeEmpty( BinaryNode * & t ) const
169     {
170         if( t != NULL )
171         {
172             makeEmpty( t->left );
173             makeEmpty( t->right );
174             delete t;
175         }
176         t = NULL;
177     }
178 
179     void preRecursive( BinaryNode * &T ) const
180     {
181         if( T != NULL )
182         {
183             cout << T->data << " ";
184             preRecursive( T->left );
185             preRecursive( T->right );
186         }
187     }
188 
189 };
190 
191 
192 int main( )
193 {
194     BinarySearchTree<int> T;
195     T.insert( 10 );
196     T.insert( 5 );
197     T.insert( 15 );
198     T.insert( 3 );
199     T.insert( 8 );
200     T.preRecursive( );
201     cout << endl;
202     T.remove( 5 );
203     T.preRecursive( );
204     return 0;
205 }
posted @ 2012-11-07 21:30  alan_forever  阅读(361)  评论(0)  编辑  收藏  举报