二叉查找树相对于 2-3 树和 AVL树简单，其它我就不多说，直接上代码

c语言版：

 1 #ifndef _BINARY_SEARCH_TREE_H_
 2 #define _BINARY_SEARCH_TREE_H_
 3 
 4 typedef int Type;
 5 
 6 typedef struct BSTreeNode {
 7     Type key;
 8     struct BSTreeNode *left;
 9     struct BSTreeNode *right;
10     struct BSTreeNode *parent;
11 } Node, *BSTree;
12 
13 void preorder_bstree(BSTree tree);
14 
15 void inorder_bstree(BSTree tree);
16 
17 void postorder_bstree(BSTree tree);
18 
19 Node* bstree_search(BSTree x, Type key);
20 
21 Node* iterative_bstree_search(BSTree x, Type key);
22 
23 Node* bstree_minimun(BSTree tree);
24 
25 Node* bstree_maximum(BSTree tree);
26 
27 Node* bstree_successor(Node *x);
28 
29 Node* bstree_predecessor(Node *x);
30 
31 Node* insert_bstree(BSTree tree, Type key);
32 
33 Node* delete_bstree(BSTree tree, Type key);
34 
35 void destroy_bstree(BSTree tree);
36 
37 void print_bstree(BSTree tree, Type key, int direction);
38 
39 #endif
bstree.h
  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include "bstree.h"
  4 
  5 void preorder_bstree(BSTree tree)
  6 {
  7     while(tree != NULL)
  8     {
  9         printf("%d ", tree->key);
 10         preorder_bstree(tree->left);
 11         preorder_bstree(tree->right);
 12     }
 13 }
 14 
 15 void inorder_bstree(BSTree tree)
 16 {
 17     while(tree != NULL)
 18     {
 19         inorder_bstree(tree->left);
 20         printf("%d ", tree->key);
 21         inorder_bstree(tree->right);
 22     }
 23 }
 24 
 25 void postorder_bstree(BSTree tree)
 26 {
 27     while(tree != NULL)
 28     {
 29         postorder_bstree(tree->left);
 30         postorder_bstree(tree->right);
 31         printf("%d ", tree->key);
 32     }
 33 }
 34 
 35 Node* bstree_search(BSTree x, Type key)
 36 {
 37     if(x == NULL || x->key == key)
 38         return x;
 39     if(key < x->key)
 40         return bstree_search(x->left, key);
 41     else 
 42         return bstree_search(x->right, key);
 43 }
 44 
 45 Node* iterative_bstree_search(BSTree x, Type key)
 46 {
 47     while((x != NULL) || (x->key != key))
 48     {
 49         if(x->key > key)
 50             x = x->left;
 51         else    
 52             x = x->right;
 53     }
 54 
 55     return x;
 56 }
 57 
 58 Node* bstree_maximum(BSTree tree)
 59 {
 60     if(tree == NULL)
 61         return NULL;
 62     while(tree->right != NULL)
 63         tree = tree->right;
 64     return tree;
 65 }
 66 
 67 Node* bstree_minimun(BSTree tree)
 68 {
 69     if(tree == NULL)
 70         return NULL;
 71     while(tree->left != NULL)
 72         tree = tree->left;
 73     return tree;
 74 }
 75 
 76 Node* bstree_successor(Node* x)
 77 {
 78     if(x->left != NULL)
 79         return bstree_maximum(x->left);
 80     Node* y = x->parent;
 81     while((y != NULL) && (x == y->left))
 82     {
 83         x = y;
 84         y = x->parent;
 85     }
 86     return y;
 87 }
 88 
 89 Node* bstree_predecessor(Node* x)
 90 {
 91     if(x->right != NULL)
 92         return bstree_minimun(x->right);
 93     Node* y = x->parent;
 94     while((y != NULL) && (x == y->right))
 95     {
 96         x = y;
 97         y = y->parent;
 98     }
 99     return y;
100 }
101 
102 Node* create_bstree_node(Type key, Node* parent, Node* left, Node* right)
103 {
104     Node* p;
105     if((p = (Node*)malloc(sizeof(Node))) == NULL)
106         return NULL;
107     p->key = key;
108     p->parent = parent;
109     p->left = left;
110     p->right = right;
111     return p;
112 }
113 
114 Node* bstree_insert(BSTree tree, Node* z)
115 {
116     Node* y = NULL;
117     Node* x = tree;
118 
119     while(x != NULL)
120     {
121         y = x;
122         if(x -> key < z->key)
123             x = x->right;
124         else    
125             x = x->left;
126     }
127 
128     z->parent = y;
129     if(y == NULL)
130         tree = z;
131     else if(z->key < y->key)
132         y->left = z;
133     else if(z->key > y->key)
134         y->right = z;
135     return tree;
136 }
137 
138 Node* insert_bstree(BSTree tree, Type key)
139 {
140     Node *p;
141     if((p = create_bstree_node(key, NULL, NULL, NULL)) == NULL)
142         return NULL;
143     bstree_insert(tree, p);
144 }
145 
146 Node* bstree_delete(BSTree tree, Node *z)
147 {
148     Node* x = NULL;
149     Node* y = NULL;
150 
151     if((z->left == NULL) || (z->right == NULL))
152         y = z;
153     else 
154         y = bstree_successor(z);
155 
156     if(y->left != NULL)
157         x = y->left;
158     else 
159         x = y->right;
160 
161     if(x != NULL)
162         x->parent = y->parent;
163     
164     if(y->parent == NULL)
165         tree = x;
166     else if(y == y->parent->left)
167         y->parent->left = x;
168     else 
169         y->parent->right = x;
170 
171     if(y != z)
172         z->key = y->key;
173     
174     if(y != NULL)
175         free(y);
176 
177     return tree;
178 }
179 
180 Node* delete_bstree(BSTree tree, Type key)
181 {
182     Node* z, *node;
183     if((z = bstree_search(tree, key)) != NULL)
184         tree = bstree_delete(tree, z);
185     return tree;
186 }
187 
188 void destroy_bstree(BSTree tree)
189 {
190     if(tree == NULL)
191         return;
192     if(tree->left != NULL)
193         destroy_bstree(tree->left);
194     if(tree->right != NULL)
195         destroy_bstree(tree->right);
196     free(tree);
197 }
198 
199 void print_bstree(BSTree tree, Type key, int direction)
200 {
201     if(tree != NULL)
202     {
203         if(direction==0)    
204             printf("%2d is root\n", tree->key);
205         else                
206             printf("%2d is %2d's %6s child\n", tree->key, key, direction==1?"right" : "left");
207 
208         print_bstree(tree->left, tree->key, -1);
209         print_bstree(tree->right,tree->key,  1);
210     }
211 }
bstree.c
 1 #include <stdio.h>
 2 #include "bstree.h"
 3 
 4 static int arr[]= {1,5,4,3,2,6};
 5 #define TBL_SIZE(a) ( (sizeof(a)) / (sizeof(a[0])) )
 6 
 7 int main()
 8 {
 9     int i;
10     int ilen;
11 
12     BSTree root = NULL;
13     printf("== add: ");
14     ilen = TBL_SIZE(arr);
15     for(i = 0; i < ilen; i++) 
16     {
17         printf("%d ", arr[i]);
18         root = insert_bstree(root, arr[i]);
19     }
20     getchar();
21     return 0;
22 }
bstree_test.c

但这里有个问题 ， 你们看到可以给我解答一下，我也方便以后回头看一下

就是在window下的动态链接dll， 除了vc++ 的library 外，还有什么方式生成，就比如linux下可以直接生成.so文件

来直接动态链接，window下我发现是无能为里，只能用静态链接。

C++版：

  1 #include <iostream>
  2 #include <stack>
  3 #include <cstdlib>
  4 
  5 using namespace std;
  6 
  7 template<class T>
  8 class BinarySearchTreeNode
  9 {
 10     public :
 11         T elem;
 12         struct BinarySearchTreeNode<T> *parent;
 13         struct BinarySearchTreeNode<T> *left;
 14         struct BinarySearchTreeNode<T> *right;
 15 };
 16 
 17 template <class T>
 18 class BinarySearchTree
 19 {
 20     public:
 21         BinarySearchTree();
 22         void tree_insert(const T& elem);
 23         int tree_remove(const T& elem);
 24         BinarySearchTreeNode<T>* tree_search(const T& elem) const;
 25         T tree_minmum(BinarySearchTreeNode<T>* root) const;
 26         T tree_maxmum(BinarySearchTreeNode<T>* root) const;
 27         T tree_successor(const T& elem) const;
 28         T tree_predecessor(const T& elem) const;
 29         int empty() const;
 30         void inorder_tree_walk() const;
 31         BinarySearchTreeNode<T>* get_root() const 
 32         {
 33             return root;
 34         }
 35 
 36     private:
 37         BinarySearchTreeNode<T>* root;
 38 };
 39 
 40 template <class T>
 41 BinarySearchTree<T>::BinarySearchTree()
 42 {
 43     root = NULL;
 44 }
 45 
 46 template <class T>
 47 void BinarySearchTree<T>::tree_insert(const T& elem)
 48 {
 49     if(!empty())
 50     {
 51         BinarySearchTreeNode<T> *pnode = root;
 52         BinarySearchTreeNode<T> *qnode = NULL;
 53         BinarySearchTreeNode<T> *newnode = new BinarySearchTreeNode<T>;
 54         newnode->elem = elem;
 55         newnode->parent = NULL;
 56         newnode->left = NULL;
 57         newnode->right = NULL;
 58 
 59         while(pnode)
 60         {
 61             qnode = pnode;
 62             if(pnode->elem > elem)
 63                 pnode = pnode->left;
 64             else 
 65                 pnode = pnode->right;
 66         }
 67 
 68         if(qnode->elem > elem)
 69             qnode->left = newnode;
 70         else 
 71             qnode->right = newnode;
 72         newnode->parent = qnode;
 73     }
 74     else 
 75     {
 76         root = new BinarySearchTreeNode<T>;
 77         root->elem = elem;
 78         root->parent = NULL;
 79         root->left = NULL;
 80         root->right = NULL;
 81     }
 82 }
 83 
 84 template<class T>
 85 int BinarySearchTree<T>::tree_remove(const T& elem)
 86 {
 87     BinarySearchTreeNode<T> *pnode;
 88     BinarySearchTreeNode<T> *parentnode, *snode;
 89     pnode = tree_search(elem);
 90     if(pnode != NULL)
 91     {
 92         parentnode = pnode->parent;
 93         if(pnode->right == NULL || pnode->left == NULL)
 94         {
 95             if(pnode->right != NULL)
 96             {
 97                 if(parentnode->left == pnode)
 98                     parentnode->left = pnode->right;
 99                 if(parentnode->right == pnode)
100                     parentnode->right = pnode->right;
101             }
102             else if(pnode->left != NULL)
103             {
104                 if(parentnode->left == pnode)
105                     parentnode->left = pnode->right;
106                 if(parentnode->right == pnode)
107                     parentnode->right = pnode->right;
108             }
109             else {
110                 if(parentnode->left == pnode)
111                     parentnode->left = NULL;
112                 if(parentnode->right == pnode)
113                     parentnode->right = NULL;
114             }
115             delete pnode;
116         }
117         else 
118         {
119             snode = tree_search(tree_successor(pnode->elem));
120             cout<<snode->elem<<endl;
121             pnode->elem = snode->elem;
122             if(snode->parent->left == snode)
123             {
124                 snode->parent->left = snode->right;
125                 snode->right->parent = snode->parent->left;
126             }
127             if(snode->parent->right == snode)
128             {
129                 snode->parent->right = snode->right;
130                 snode->right->parent = snode->parent->right;
131             }
132             delete snode;
133         }
134         return 0;
135     }
136     return -1;
137 }
138 
139 
140 template<class T>
141 BinarySearchTreeNode<T>* BinarySearchTree<T>::tree_search(const T& elem) const
142 {
143     BinarySearchTreeNode<T> *pnode = root;
144     while(pnode)
145     {
146         if(pnode->elem == elem)
147             break;
148         else if(pnode->elem > elem)
149             pnode = pnode->left;
150         else 
151             pnode = pnode->right;
152     }
153 
154     return pnode;
155 }
156 
157 template<class T>
158 T BinarySearchTree<T>::tree_minmum(BinarySearchTreeNode<T> *root) const
159 {
160     BinarySearchTreeNode<T> *pnode = root;
161     if(pnode->left)
162         while(pnode->left)
163             pnode = pnode->left;
164     return pnode->elem;
165 }
166 
167 template<class T>
168 T BinarySearchTree<T>::tree_maxmum(BinarySearchTreeNode<T> *root) const
169 {
170     BinarySearchTreeNode<T> *pnode = root;
171     if(pnode->left)
172         while(pnode->right)
173             pnode = pnode->right;
174     return pnode->elem;
175 }
176 
177 template<class T>
178 T BinarySearchTree<T>::tree_successor(const T& elem) const
179 {
180     BinarySearchTreeNode<T> *pnode = tree_search(elem);
181     BinarySearchTreeNode<T> *parentnode;
182     if(pnode != NULL)
183     {
184         if(pnode->right)
185             return tree_minmum(pnode->right);
186         parentnode = pnode->parent;
187         while(parentnode && pnode == parentnode->left)
188         {
189             pnode = parentnode;
190             parentnode = parentnode->parent;
191         }
192 
193         if(parentnode)
194             return parentnode->elem;
195         else 
196             return T();
197     }
198     return T();
199 }
200 
201 template<class T>
202 T BinarySearchTree<T>::tree_predecessor(const T& elem) const
203 {
204     BinarySearchTreeNode<T>* pnode = tree_search(elem);
205     BinarySearchTreeNode<T>* parentnode;
206     if(pnode != NULL)
207     {
208         if(pnode->left)
209             return tree_maxmum(pnode->left);
210         parentnode = pnode->parent;
211         while(parentnode && pnode == parentnode -> right)
212         {
213             pnode = parentnode;
214             parentnode = pnode->parent;
215         }
216         if(parentnode)
217             return parentnode->elem;
218         else 
219             return T();
220     }
221     return T();
222 }
223 
224 template<class T>
225 int BinarySearchTree<T>::empty() const
226 {
227     return (NULL == root)?1:0;
228 }
229 
230 template<class T>
231 void BinarySearchTree<T>::inorder_tree_walk() const
232 {
233     if(NULL != root)
234     {
235         stack<BinarySearchTreeNode<T>*> s;
236         BinarySearchTreeNode<T> *ptmpnode;
237         ptmpnode = root;
238         while(NULL != ptmpnode || !s.empty())
239         {
240             if(NULL != ptmpnode)
241             {
242                 s.push(ptmpnode);
243                 ptmpnode = ptmpnode->left;
244             }
245             else
246             {
247                 ptmpnode = s.top();
248                 s.pop();
249                 cout<<ptmpnode->elem<<" ";
250                 ptmpnode = ptmpnode->right;
251             }
252         }
253     }
254 }
255 
256 int main()
257 {
258     BinarySearchTree<int> bstree;
259     BinarySearchTreeNode<int>* ptnode, *proot;
260     bstree.tree_insert(32);
261     bstree.tree_insert(21);
262     bstree.tree_insert(46);
263     bstree.tree_insert(54);
264     bstree.tree_insert(16);
265     bstree.tree_insert(38);
266     bstree.tree_insert(70);
267     cout<<"inorder tree walk is: ";
268     bstree.inorder_tree_walk();
269     proot = bstree.get_root();
270     cout<<"\nmax value is: " << bstree.tree_maxmum(proot)<<endl;
271     cout<<"min value is: " << bstree.tree_minmum(proot)<<endl;
272     ptnode = bstree.tree_search(38);
273     if(ptnode)
274         cout<<"exist"<<endl;
275     else 
276         cout<<"error"<<endl;
277     cout<<"the successor of 38 is: " << bstree.tree_successor(38)<<endl;
278     cout<<"the predecessor of 38 is: "<< bstree.tree_predecessor(46)<<endl;
279     if(bstree.tree_remove(46) == 0)
280         cout<<"success"<<endl;
281     else 
282         cout<<"error"<<endl;
283     cout<<"inorder tree walk is: ";
284     bstree.inorder_tree_walk();
285     system("pause");
286 }
bstree.cpp