二叉搜索树

用链表来表示， 其中每个节点为一个对象，除了key外，每个节点还包含了属性left, right, p,它们分别指向了结点的左孩子，右孩子和双亲。对任何结点x， 其左子树的所有结点关键字最大不超过x.key, 其右子树的所有结点关键字最小不低于x.key.

代码如下

http://www.cnblogs.com/sld666666/archive/2010/10/23/1859512.html

http://www.cnblogs.com/sysu-blackbear/archive/2013/02/12/2910190.html

 35 template<class T>
 36 void BindaryTree<T>::preOder(BindaryTree<T>* root)
 37 {
 38   if (root) {
 39     cout<<root->data<<" ";
 40     preOder(root->left);
 41     preOder(root->right);
 42   } else {
 43     return;
 44   }
 45 }
 46
 47 template<class T>
 48 void BindaryTree<T>::inOrder(BindaryTree<T>* root)
 49 {
 50   if (root) {
 51     inOder(root->left);
 52     cout<<root->data<<" ";
 53     inOder(root->right);
 54   }
 55 }
 56
 57 template<class T>
 58 void BindaryTree<T>::postOder(BindaryTree<T>* root)
 59 {
 60   if (root) {
 61     postOder(root->left);
 62     postOder(root->right);
 63     cout<<root->data<<" ";
 64   }
 65 }
 66
 67 template<class T>
 68 void BinaryTree<T>::levelOrder(BindaryTree<T>* root)
 69 {
 70   deque<BinaryTreeNode<T>* > q;
 71   q.push_back(root);
 72   BinrayTreeNode<T>* t = root;
 73   while (t) {
 74     cout<<<t->data<<" ";
 75     if (t->left) .push_back(t->left);
 76     if (t->right) q.push_back(t->right);
 77     q.pop_front();
 78     t = q.front();
 79   }
 80 }

 82 template<class T>
 83 BinarySearchTree<T>::BinarySearchTree()
 84 {
 85   root = NULL;
 86 }
 87
 88 template<class T>
 89 BinarySearchTree<T>::BinarySearchTree(const BinarySearchTree& rhs)
 90 {
 91   root = NULL:
 92     *this = rhs;
 93 }
 94
 95 template<class T>
 96 BinarySearchTree<T>::~BinarySearchTree()
 97 {
 98   makeEmpty();
 99 }
100
101
102 template<class T>
103 const T& BinarySearchTree<T>::findMin() const
104 {
105   if (!isEmpty()) {
106     BinaryTreeNode<T>* r = root;
107     while (r->left)
108       r = r->left;
109     return r->data;
110   }
111   return 0;
112 }
113
114 template<class T>
115 const T& BinarySearchTree<T>::findMax() const
116 {
117   if (!isEmpty()) {
118     BinaryTreeNode<T>* r= root;
119     while (r->right)
120       r = r->right;
121     return r->data;
122   }
123   return 0;
124 }

126 template<class T>
127 void BinarySearchTree<T>::insert(const T& x)
128 {
129   BinaryTreeNode<T>* node = root;
130   while (node) {
131     if (x < node->data)
132       node = node->left;
133     else if (x > node->right)
134       node = node->right;
135   }
136   node = new BinaryTreeNode<T>(x);
137 }
138 template<class T>
139 void BinarySearchTree<T>::remove(const T& x)
140 {
141   if (root == NULL)
142     return;
143   BinaryTreeNode<T>* node = root;
144   while (node) {
145     if (x < node->left)
146       node = node->left;
147     else if (x > node->right)
148       node = node->right;
149     else if ( node->left && node->right) {
150       node->data = findMin(node->right);
151       //then remove that node in tree
152     } else {
153       BinaryTreeNode<T>* n1 = node;
154       node = (node->left) ? t->left:(node->right) ? t->right : NULL;
155       delete n1;
156     }
157   }
158 }
159
160 template<class T>
161 bool BinarySearchTree<T>::contain(const T& x) const
162 {
163   BinaryTreeNode<T>* node = root;
164   while (node) {
165     if (x < node->data)
166       node = node->left;
167     else if (x > node->right)
168       node = node->rigth;
169     else
170       return true;
171   }
172   return false;
173 }

175 template<typename T>
176 static void makeEmpty(BinaryTreeNode<T>* root)
177 {
178   if (root == NULL)
179     return;
180   if (root->left)
181     makeEmpty(root->left);
182   if (root->right)
183     makeEmpty(root->right);
184   delete root;
185   root = NULL;
186 }
187 template<class T>
188 void BinarySearchTree<T>::makeEmpty()
189 {
190
191    makeEmpty(root);
192 }
193
194 template<typename T>
195 void BFS(int v, int reach [], int lable)
196 {
197   deque<int> q;
198   q.push_back(v);
199   reach[v] = label;
200   while (q.size())  {
201     int w = q.front();
202     for (int i = 1; i <= n; i++) {
203       if (a[w][i] != NoEdge && reach[i] !=label) {
204         q.push_back(i);
205         reach[i] = label;
206       }
207     }
208     q.pop_front();
209
210   }
211 }
212
213 template<typename T>
214 void BFS1(int v, int reach[], int label)
215 {
216   deque<int> q;
217   q.push_back(v);
218   reach[v] = label;
219   while (q.size()) {
220     int w = q.front();
221     ChainNode<int>* p = H[v].first;
222     while (p != NULL) {
223       if (reach[p->data] != label) {
224         q.push_back(p->data);
225         reach[p->data] = label;
226       }
227       p = p->link;
228     }
229     q.pop_front();
230   }

233 template<typename T>
234 void DFS(int v, int reach[], int label)
235 {
236   reach[v]= label;
237   for (int i = 1; i <= n; i++)
238   {
239     if (a[v][i] != NoEdge && reach[i] != label)
240     {
241       DFS(i, reach, label);
242     }
243   }
244 }
245
246
247
248 template<typename T>
249 bool findPath(int v, int &length, int w, int path[], int reach[])
250 {
251   reach[v] = 1;
252   for (int i =1; i <= n; i++) {
253
254   if (!reach[i] && a[v][i] != NoEdge) {
255     length++;
256     path[length] = i;
257     if (i == w)
258       return true;
259     if (findPath(a[v][i], length, w, path, reach))
260       return true;
261     length--;
262   }
263   }
264   return false;
265
266 }