查找树

  1 #ifndef BSTREE_H
  2 #define BSTREE_H
  3 
  4 #include <iostream>
  5 
  6 template <typename T>
  7 class BSTreeNode {
  8 public:
  9     T key;
 10     BSTreeNode *left;
 11     BSTreeNode *right;
 12     BSTreeNode *parent;
 13     BSTreeNode(T value, BSTreeNode *p, BSTreeNode *l, BSTreeNode *r)
 14         : key(value), parent(p), left(l), right(r) {}
 15 
 16     T operator*() const { return key; }
 17 };
 18 
 19 template <typename T>
 20 class BSTree
 21 {
 22 public:
 23     typedef BSTreeNode<T> Node;
 24     typedef BSTreeNode<T>* Node_pointer;
 25 
 26 public:
 27     BSTree();
 28     ~BSTree();
 29 
 30     //前序遍历
 31     void preOrder() { preOrder(rootTree); }
 32     //中序遍历
 33     void inOrder() { inOrder(rootTree); }
 34     //后序遍历
 35     void postOrder() { postOrder(rootTree); }
 36     //最大值
 37     T max();
 38     //最小值
 39     T min();
 40     // 找结点(x)的后继结点。即，查找"二叉树中数据值大于该结点"的"最小结点"。
 41     Node* successor(Node *x);
 42     // 找结点(x)的前驱结点。即，查找"二叉树中数据值小于该结点"的"最大结点"。
 43     Node* predecessor(Node *x);
 44     // (递归实现)查找"二叉树"中键值为key的节点
 45     Node* search(T key);
 46     //插入
 47     void insert(T key);
 48     //删除
 49     void remove(T key);
 50     
 51     //清除
 52     void clear();
 53 private:
 54     void insert(Node_pointer &tree, Node *z);
 55     Node* remove(Node_pointer &tree, Node *z);
 56 
 57     void preOrder(Node *tree);
 58     void inOrder(Node *tree);
 59     void postOrder(Node *tree);
 60     Node* max(Node *tree);
 61     Node* min(Node *tree);
 62     Node* search(Node* tree, T key);
 63     void destroy(Node_pointer &tree);
 64 private:
 65     Node *rootTree;
 66 };
 67 
 68 template <typename T>
 69 BSTree<T>::BSTree() : rootTree(nullptr)
 70 {
 71 }
 72 
 73 template <typename T>
 74 BSTree<T>::~BSTree()
 75 {
 76     clear();
 77 }
 78 
 79 template <typename T>
 80 void BSTree<T>::insert(T key)
 81 {
 82     Node* z = new Node(key, nullptr, nullptr, nullptr);
 83     insert(rootTree, z);
 84 }
 85 
 86 template <typename T>
 87 void BSTree<T>::insert(Node_pointer &tree, Node *z)
 88 {
 89     Node* y = nullptr;
 90     Node* x = tree;
 91 
 92     while (x != nullptr) {
 93         y = x;
 94         if (z->key < x->key) {
 95             x = x->left;
 96         }
 97         else {
 98             x = x->right;
 99         }
100     }
101 
102     z->parent = y;
103     if (y == nullptr) {
104         tree = z;
105     }
106     else if (z->key < y->key) {
107         y->left = z;
108     }
109     else {
110         y->right = z;
111     }
112 }
113 
114 
115 template <typename T>
116 void BSTree<T>::preOrder(Node *tree)
117 {
118     if (tree == nullptr) return;
119     std::cout << tree->key << " ";
120     preOrder(tree->left);
121     preOrder(tree->right);
122 }
123 
124 template <typename T>
125 void BSTree<T>::inOrder(Node *tree)
126 {
127     if (!tree) return;
128     inOrder(tree->left);
129     std::cout << tree->key << " ";
130     inOrder(tree->right);
131 }
132 
133 template <typename T>
134 void BSTree<T>::postOrder(Node *tree)
135 {
136     if (!tree) return;
137     postOrder(tree->left);
138     postOrder(tree->right);
139     std::cout << tree->key << " ";
140 }
141 
142 template <typename T>
143 void BSTree<T>::clear()
144 {
145     std::cout << "===destroy: ";
146     destroy(rootTree);
147     std::cout << std::endl;
148 }
149 
150 template <typename T>
151 void BSTree<T>::destroy(Node_pointer &tree)
152 {
153     if (tree == nullptr) return;
154 
155     if (tree->left) {
156         destroy(tree->left);
157     }
158     if (tree->right) {
159         destroy(tree->right);
160     }
161 
162     std::cout << tree->key << " ";
163     delete tree;
164     tree = nullptr;
165 }
166 
167 template <typename T>
168 typename BSTree<T>::Node*  BSTree<T>::max(Node *tree)
169 {
170     if (!tree) return nullptr;
171 
172     Node* x = tree;
173     while (x->right) {
174         x = x->right;
175     }
176     return x;
177 }
178 
179 template <typename T>
180 T BSTree<T>::max()
181 {
182     Node* x = max(rootTree);
183     
184     if (x) {
185         return x->key;
186     } else {
187         return (T)nullptr;
188     }
189         
190 }
191 
192 template <typename T>
193 typename BSTree<T>::Node* BSTree<T>::min(Node *tree)
194 {
195     if (!tree) return nullptr;
196 
197     Node* x = tree;
198     while (x->left) {
199         x = x->left;
200     }
201     return x;
202 }
203 
204 template <typename T>
205 T BSTree<T>::min()
206 {
207     Node* x = min(rootTree);
208 
209     if (x) {
210         return x->key;
211     } else {
212         return (T)nullptr;
213     }
214 }
215 
216 // 找结点(x)的后继结点。即，查找"二叉树中数据值大于该结点"的"最小结点"。
217 template <typename T>
218 typename BSTree<T>::Node* BSTree<T>::successor(Node *x)
219 {
220     if (!x) return nullptr;
221 
222     if (x->right) {
223         return min(x->right);
224     } 
225 
226     //1. x为一个左节点,父节点为后驱
227     //2. x为一个右节点，寻找父节点的父节点。。。，直到找到一个自己作为左孩子的父节点。
228     Node* y = x->parent;
229     while ((y!=nullptr) && (x==y->right)) {
230         x = y;
231         y = x->parent;
232     }
233 
234     return y;
235 }
236 
237 // 找结点(x)的前驱结点。即，查找"二叉树中数据值小于该结点"的"最大结点"。
238 template <typename T>
239 typename BSTree<T>::Node* BSTree<T>::predecessor(Node *x)
240 {
241     if (!x) return nullptr;
242 
243     if (x->left) {
244         return max(x->left);
245     }
246 
247     //1. x为一个右节点,父节点为后驱
248     //2. x为一个左节点，寻找父节点的父节点。。。，直到找到一个自己作为右孩子的父节点。
249     Node* y = x->parent;
250     while ((y != nullptr) && (x == y->left)) {
251         x = y;
252         y = x->parent;
253     }
254 
255     return y;
256 
257 }
258 
259 template <typename T>
260 typename BSTree<T>::Node* BSTree<T>::remove(Node_pointer &tree, Node *z)
261 {
262     Node* x = nullptr;
263     Node* y = nullptr; //删除的节点
264 
265     //1. 假如z只含有一个子节点或者无子节点，删除z节点
266     //2. 假如z含有两个子节点，则删除后驱节点，然后z节点值替换
267     //y最多一个孩子节点
268     if ((z->left == nullptr) || (z->right == nullptr)) {
269         y = z;
270     } else {
271         y = successor(z);
272     }
273 
274     //查找子节点
275     if (y->left != nullptr) {
276         x = y->left;
277     } else {
278         x = y->right;
279     }
280 
281     if (x != nullptr) {
282         x->parent = y->parent;
283     }
284 
285     if (y->parent == nullptr) {
286         tree = x;
287     } 
288     else if (y == y->parent->left) {
289         y->parent->left = x;
290     }
291     else {
292         y->parent->right = x;
293     }
294 
295     return y;
296 }
297 
298 //删除
299 template <typename T>
300 void BSTree<T>::remove(T key)
301 {
302     Node* x = search(key);
303     if (!x) return;
304 
305     Node* y = remove(rootTree, x);
306     if (y) {
307         delete y;
308     }
309 }
310 
311 template <typename T>
312 typename BSTree<T>::Node* BSTree<T>::search(Node* tree, T key)
313 {
314 
315     if (tree==nullptr || tree->key == key) {
316         return tree;
317     }
318 
319     if (key < tree->key) {
320         return search(tree->left, key);
321     } else {
322         return search(tree->right, key);
323     }
324 }
325 
326 template <typename T>
327 typename BSTree<T>::Node* BSTree<T>::search(T key)
328 {
329     return search(rootTree, key);
330 }
331 
332 #endif