二叉树之二叉搜索树（BSTree）

 1 #ifndef OBJECT_H
 2 #define OBJECT_H
 3 
 4 #include <iomanip>    // size_t
 5 
 6 namespace LinWeiJie_lib
 7 {
 8 
 9 class Object
10 {
11 public:
12     void* operator new(size_t size);
13     void operator delete(void* p);
14     void* operator new[](size_t size);
15     void operator delete[](void* p);
16     bool operator == (const Object& obj);
17     bool operator != (const Object& obj);
18     virtual ~Object() = 0;
19 };
20 
21 }
22 
23 #endif // OBJECT_H

  1 #ifndef EXCEPTION_H
  2 #define EXCEPTION_H
  3 
  4 #include "Object.h"
  5 
  6 namespace LinWeiJie_lib
  7 {
  8 
  9 #define THROW_EXCEPTION(e, m) (throw e(m, __FILE__, __LINE__))  // 注释掉throw语句即可兼容老版本的不支持异常处理的C++编译器
 10 
 11 class Exception : public Object
 12 {
 13 protected:
 14     char* m_message;
 15     char* m_location;
 16 
 17     void init(const char* message, const char* file, int line);
 18 public:
 19     Exception(const char* message);
 20     Exception(const char* file, int line);
 21     Exception(const char* message, const char* file, int line);
 22 
 23     Exception(const Exception& e);
 24     Exception& operator= (const Exception& e);
 25 
 26     virtual const char* message() const;
 27     virtual const char* location() const;
 28 
 29     virtual ~Exception() = 0;
 30 };
 31 
 32 class ArithmeticException : public Exception    // 算术异常
 33 {
 34 public:
 35     ArithmeticException() : Exception(nullptr){}
 36     ArithmeticException(const char* message) : Exception(message){}
 37     ArithmeticException(const char* file, int line) : Exception(file, line){}
 38     ArithmeticException(const char* message, const char* file, int line) : Exception(message, file, line){}
 39 
 40     ArithmeticException(const ArithmeticException& e) : Exception(e){}
 41 
 42     ArithmeticException& operator=(const ArithmeticException& e)
 43     {
 44         Exception::operator=(e);
 45 
 46         return *this;
 47     }
 48 
 49     ~ArithmeticException();
 50 };
 51 
 52 class NullPointerException : public Exception  // 空指针异常
 53 {
 54 public:
 55     NullPointerException() : Exception(nullptr) {}
 56     NullPointerException(const char* message) : Exception(message) {}
 57     NullPointerException(const char* file, int line) : Exception(file, line) {}
 58     NullPointerException(const char* message, const char* file, int line) : Exception(message, file, line) {}
 59 
 60     NullPointerException(const NullPointerException& e) : Exception(e) {}
 61 
 62     NullPointerException& operator= (const NullPointerException& e)
 63     {
 64         Exception::operator=(e);
 65 
 66         return *this;
 67     }
 68 
 69     ~NullPointerException();
 70 };
 71 
 72 class IndexOutOfBoundsException : public Exception    // 下标越界异常
 73 {
 74 public:
 75     IndexOutOfBoundsException() : Exception(nullptr) {}
 76     IndexOutOfBoundsException(const char* message) : Exception(message) {}
 77     IndexOutOfBoundsException(const char* file, int line) : Exception(file, line) {}
 78     IndexOutOfBoundsException(const char* message, const char* file, int line) : Exception(message, file, line) {}
 79 
 80     IndexOutOfBoundsException(const IndexOutOfBoundsException& e) : Exception(e) {}
 81 
 82     IndexOutOfBoundsException& operator= (const IndexOutOfBoundsException& e)
 83     {
 84         Exception::operator=(e);
 85 
 86         return *this;
 87     }
 88 
 89     ~IndexOutOfBoundsException();
 90 };
 91 
 92 class NoEnoughMemoryException : public Exception    // 内存不足异常
 93 {
 94 public:
 95     NoEnoughMemoryException() : Exception(nullptr) {}
 96     NoEnoughMemoryException(const char* message) : Exception(message) {}
 97     NoEnoughMemoryException(const char* file, int line) : Exception(file, line) {}
 98     NoEnoughMemoryException(const char* message, const char* file, int line) : Exception(message, file, line) {}
 99 
100     NoEnoughMemoryException(const NoEnoughMemoryException& e) : Exception(e) {}
101 
102     NoEnoughMemoryException& operator= (const NoEnoughMemoryException& e)
103     {
104         Exception::operator=(e);
105 
106         return *this;
107     }
108 
109     ~NoEnoughMemoryException();
110 };
111 
112 class InvalidParameterException : public Exception  // 无效参数异常
113 {
114 public:
115     InvalidParameterException() : Exception(nullptr) {}
116     InvalidParameterException(const char* message) : Exception(message) {}
117     InvalidParameterException(const char* file, int line) : Exception(file, line) {}
118     InvalidParameterException(const char* message, const char* file, int line) : Exception(message, file, line) {}
119 
120     InvalidParameterException(const InvalidParameterException& e) : Exception(e) {}
121 
122     InvalidParameterException& operator= (const InvalidParameterException& e)
123     {
124         Exception::operator=(e);
125 
126         return *this;
127     }
128 
129     ~InvalidParameterException();
130 };
131 
132 class InvalidOperationException : public Exception  // 无效操作异常
133 {
134 public:
135     InvalidOperationException() : Exception(nullptr) {}
136     InvalidOperationException(const char* message) : Exception(message) {}
137     InvalidOperationException(const char* file, int line) : Exception(file, line) {}
138     InvalidOperationException(const char* message, const char* file, int line) : Exception(message, file, line) {}
139 
140     InvalidOperationException(const InvalidOperationException& e) : Exception(e) {}
141 
142     InvalidOperationException& operator= (const InvalidOperationException& e)
143     {
144         Exception::operator=(e);
145 
146         return *this;
147     }
148 
149     ~InvalidOperationException();
150 };
151 
152 class DuplicateDataException : public Exception    // 重复数据异常
153 {
154 public:
155     DuplicateDataException() : Exception(nullptr) {}
156     DuplicateDataException(const char* message) : Exception(message) {}
157     DuplicateDataException(const char* file, int line) : Exception(file, line) {}
158     DuplicateDataException(const char* message, const char* file, int line) : Exception(message, file, line) {}
159 
160     DuplicateDataException(const DuplicateDataException& e) : Exception(e) {}
161 
162     DuplicateDataException& operator= (const DuplicateDataException& e)
163     {
164         Exception::operator=(e);
165 
166         return *this;
167     }
168 
169     ~DuplicateDataException();
170 };
171 
172 class FileOversizeException : public Exception    // 文件太大异常
173 {
174 public:
175     FileOversizeException() : Exception(nullptr) {}
176     FileOversizeException(const char* message) : Exception(message) {}
177     FileOversizeException(const char* file, int line) : Exception(file, line) {}
178     FileOversizeException(const char* message, const char* file, int line) : Exception(message, file, line) {}
179 
180     FileOversizeException(const FileOversizeException& e) : Exception(e) {}
181 
182     FileOversizeException& operator= (const FileOversizeException& e)
183     {
184         Exception::operator=(e);
185 
186         return *this;
187     }
188 
189     ~FileOversizeException();
190 };
191 
192 class EmptyTreeException : public Exception    // 空树异常
193 {
194 public:
195     EmptyTreeException() : Exception(nullptr) {}
196     EmptyTreeException(const char* message) : Exception(message) {}
197     EmptyTreeException(const char* file, int line) : Exception(file, line) {}
198     EmptyTreeException(const char* message, const char* file, int line) : Exception(message, file, line) {}
199 
200     EmptyTreeException(const EmptyTreeException& e) : Exception(e) {}
201 
202     EmptyTreeException& operator= (const EmptyTreeException& e)
203     {
204         Exception::operator=(e);
205 
206         return *this;
207     }
208 
209     ~EmptyTreeException();
210 };
211 
212 }
213 
214 #endif // EXCEPTION_H

  1 #ifndef TREE_H
  2 #define TREE_H
  3 
  4 #include <iomanip>
  5 
  6 namespace LinWeiJie_lib
  7 {
  8 
  9 template < typename T >
 10 class TNode
 11 {
 12 public:
 13     T mKey;
 14 
 15     TNode() = delete;
 16     TNode(const T& key);
 17     TNode(const TNode<T>& tNode) = default;
 18     TNode(TNode<T> && tNode) = default;
 19     TNode<T>& operator = (const TNode<T>& tNode) = default;
 20     TNode<T>& operator = (TNode<T> && tNode) = default;
 21     virtual ~TNode() = 0;
 22 };
 23 
 24 template < typename T >
 25 TNode<T>::TNode(const T& key) : mKey(key)
 26 {
 27 }
 28 
 29 template < typename T >
 30 TNode<T>::~TNode()
 31 {
 32 }
 33 
 34 template < typename T >
 35 class Tree
 36 {
 37 protected:
 38     TNode<T>*    mRoot;
 39     size_t        mCount;
 40 
 41     Tree();
 42     Tree(const Tree<T>& tree) = delete;
 43     Tree(Tree<T> && tree);
 44     Tree<T>& operator = (const Tree<T>& tree) = delete;
 45     Tree<T>& operator = (Tree<T> && tree);
 46     virtual ~Tree() = 0;
 47 
 48 public:
 49     virtual void preOrder() const = 0;
 50     virtual void inOrder() const = 0;
 51     virtual void postOrder() const = 0;
 52     virtual void levelOrder() const = 0;
 53 
 54     virtual TNode<T>* search(const T& key) const = 0;            // 递归版
 55     virtual TNode<T>* iterativeSearch(const T& key) const = 0;    // 非递归版
 56 
 57     virtual void insert(const T& node) = 0;
 58     virtual void remove(const T& node) = 0;
 59     virtual void destroy() = 0;
 60 
 61     virtual const T& getRootKey() const = 0;
 62     virtual void printTree() const = 0;
 63 };
 64 
 65 template < typename T >
 66 Tree<T>::Tree() : mRoot(nullptr), mCount(0)
 67 {
 68 }
 69 
 70 template < typename T >
 71 Tree<T>::Tree(Tree<T> && tree)
 72 {
 73     mRoot = tree.mRoot;
 74     mCount = tree.mCount;
 75 
 76     tree.mRoot = nullptr;
 77     tree.mCount = 0;
 78 }
 79 
 80 template < typename T >
 81 Tree<T>& Tree<T>::operator = (Tree<T> && tree)
 82 {
 83     if ( this == &tree )
 84         return *this;
 85     
 86     mRoot = tree.mRoot;
 87     mCount = tree.mCount;
 88     
 89     tree.mRoot = nullptr;
 90     tree.mCount = 0;
 91 }
 92 
 93 template < typename T >
 94 Tree<T>::~Tree()
 95 {
 96 }
 97 
 98 }
 99 
100 #endif

  1 #ifndef BSTREE_H
  2 #define BSTREE_H
  3 
  4 #include <iostream>
  5 #include <stack>
  6 #include <queue>
  7 
  8 #include "Exception.h"
  9 #include "Tree.h"
 10 
 11 using namespace std;
 12 
 13 namespace LinWeiJie_lib
 14 {
 15 
 16 template < typename T >
 17 class BSTNode : public TNode<T>
 18 {
 19 public:
 20     BSTNode<T>    *mLeft;
 21     BSTNode<T>    *mRight;
 22     BSTNode<T>    *mParent;
 23 
 24     BSTNode() = delete;
 25     BSTNode(const T& key, BSTNode<T> *left, BSTNode<T> *right, BSTNode<T> *parent);
 26     BSTNode(const BSTNode<T>& tree) = delete;
 27     BSTNode(BSTNode<T> && tree);
 28     BSTNode<T>& operator = (const BSTNode<T>& tree) = delete;
 29     BSTNode<T>& operator = (BSTNode<T> && tree);
 30     virtual ~BSTNode();
 31 };
 32 
 33 template < typename T >
 34 BSTNode<T>::BSTNode(const T& key, BSTNode<T> *left, BSTNode<T> *right, BSTNode<T> *parent) :
 35     TNode<T> (key), mLeft(left), mRight(right), mParent(parent)
 36 {
 37 }
 38 
 39 template < typename T >
 40 BSTNode<T>::BSTNode(BSTNode<T> && tree)
 41 {
 42     mLeft = tree.mLeft;
 43     mRight = tree.mRight;
 44     mParent = tree.mParent;
 45 
 46     tree->mLeft = nullptr;
 47     tree->mRight = nullptr;
 48     tree->mParent = nullptr;
 49 }
 50 
 51 template < typename T >
 52 BSTNode<T>& BSTNode<T>::operator = (BSTNode<T> && tree)
 53 {
 54     if ( this == &tree )
 55         return *this;
 56     
 57     delete mLeft;
 58     delete mRight;
 59     delete mParent;
 60     
 61     mLeft = tree->mLeft;
 62     mRight = tree->mRight;
 63     mParent = tree->mParent;
 64 
 65     return *this;
 66 }
 67 
 68 template < typename T >
 69 BSTNode<T>::~BSTNode()
 70 {
 71 
 72 }
 73 
 74 template < typename T >
 75 class BSTree : public Tree<T>
 76 {
 77 protected:
 78     virtual void preOrder(BSTNode<T> *tree) const;                                // 深度优先的前、中、后序遍历
 79     virtual void inOrder(BSTNode<T> *tree) const;
 80     virtual void postOrder(BSTNode<T> *tree) const;
 81 
 82     virtual void levelOrder(BSTNode<T> *tree) const;                            // 广度优先
 83 
 84     virtual BSTNode<T>* search(BSTNode<T> *tree, const T& key) const;            // 递归版搜索
 85     virtual BSTNode<T>* iterativeSearch(BSTNode<T> *tree, const T& key) const;    // 非递归版搜索
 86 
 87     virtual BSTNode<T>* minimum(BSTNode<T> *tree) const;                        // 获取最小最大值
 88     virtual BSTNode<T>* maximum(BSTNode<T> *tree) const;
 89 
 90     virtual BSTNode<T>* successor(BSTNode<T> *node) const;                        // 查找后继，即大于又最接近node的节点
 91     virtual BSTNode<T>* predecessor(BSTNode<T> *node) const;                    // 查找前继
 92 
 93     virtual void insert(BSTNode<T> *node);
 94     virtual BSTNode<T>* remove(BSTNode<T> *node);                                // 返回值用于删除，返回值实际是替换结点
 95     virtual void destroy(BSTNode<T> *tree);
 96 
 97     void printTree(BSTNode<T> *tree, bool firstNode) const;                        // 打印树，类似linux的tree命令
 98 
 99     virtual int height(BSTNode<T> *tree) const;                                    // 树的高度
100     virtual int degree(BSTNode<T> *tree) const;                                    // 结点的度数
101 
102 public:
103     BSTree();
104     BSTree(const BSTree<T>&) = default;
105     BSTree(BSTree<T> &&) = default;
106     BSTree<T>& operator = (const BSTree<T>&) = default;
107     BSTree<T>& operator = (BSTree<T> &&) = default;
108     virtual ~BSTree();
109 
110     virtual void preOrder() const;
111     virtual void inOrder() const;
112     virtual void postOrder() const;
113 
114     virtual void levelOrder() const;
115 
116     virtual BSTNode<T>* search(const T& key) const;
117     virtual BSTNode<T>* iterativeSearch(const T& key) const;
118 
119     virtual const T& minimum() const;
120     virtual const T& maximum() const;
121 
122     virtual void insert(const T& key);
123     virtual void remove(const T& key);
124     virtual void destroy();
125 
126     virtual int height() const;
127     virtual int degree() const;
128 
129     virtual size_t getCount() const;
130 
131     virtual const T& getRootKey() const;
132     virtual void printTree() const;
133 };
134 
135 template < typename T >
136 BSTree<T>::BSTree() : Tree<T> ()
137 {
138 }
139 
140 template < typename T >
141 void BSTree<T>::preOrder(BSTNode<T> *tree) const
142 {
143     if ( tree != nullptr )
144     {
145         cout << tree->mKey << " " << flush;
146         preOrder(tree->mLeft);
147         preOrder(tree->mRight);
148     }
149 }
150 
151 template < typename T >
152 void BSTree<T>::preOrder() const
153 {
154     preOrder(dynamic_cast<BSTNode<T>*>(this->mRoot));
155 }
156 
157 template < typename T >
158 void BSTree<T>::inOrder(BSTNode<T> *tree) const
159 {
160     if ( tree != nullptr )
161     {
162         inOrder(tree->mLeft);
163         cout << tree->mKey << " " << flush;
164         inOrder(tree->mRight);
165     }
166 }
167 
168 template < typename T >
169 void BSTree<T>::inOrder() const
170 {
171     inOrder(dynamic_cast<BSTNode<T>*>(this->mRoot));
172 }
173 
174 template < typename T >
175 void BSTree<T>::postOrder(BSTNode<T> *tree) const
176 {
177     if ( tree != nullptr )
178     {
179         postOrder(tree->mLeft);
180         postOrder(tree->mRight);
181         cout << tree->mKey << " " << flush;
182     }
183 }
184 
185 template < typename T >
186 void BSTree<T>::postOrder() const
187 {
188     postOrder(dynamic_cast<BSTNode<T>*>(this->mRoot));
189 }
190 
191 template < typename T >
192 void BSTree<T>::levelOrder(BSTNode<T> *tree) const
193 {
194     if ( tree != nullptr )
195     {
196         queue<BSTNode<T>*> tmp;
197         tmp.push(tree);
198 
199         while( tmp.size() > 0 )
200         {
201             BSTNode<T>* t = tmp.front();
202             tmp.pop();
203 
204             if ( t->mLeft != nullptr )
205                 tmp.push(t->mLeft);
206 
207             if ( t->mRight != nullptr )
208                 tmp.push(t->mRight);
209 
210             cout << t->mKey << " " << flush;
211         }
212     }
213 }
214 
215 template < typename T >
216 void BSTree<T>::levelOrder() const
217 {
218     levelOrder(dynamic_cast<BSTNode<T>*>(this->mRoot));
219 }
220 
221 template < typename T >
222 BSTNode<T>* BSTree<T>::search(BSTNode<T> *node, const T& key) const
223 {
224     if ( node == nullptr || node->mKey == key )
225     {
226         return node;
227     }
228     else if ( key < node->mKey )
229         return search(dynamic_cast<BSTNode<T>*>(node)->mLeft, key);
230     else
231         return search(dynamic_cast<BSTNode<T>*>(node)->mRight, key);
232 }
233 
234 template < typename T >
235 BSTNode<T>* BSTree<T>::search(const T& key) const
236 {
237     return search(dynamic_cast<BSTNode<T>*>(this->mRoot), key);
238 }
239 
240 template < typename T >
241 BSTNode<T>* BSTree<T>::iterativeSearch(BSTNode<T>* node, const T& key) const
242 {
243     while ( (node != nullptr) && (node->mKey != key) )
244     {
245         if ( key < node->mKey )
246             node = node->mLeft;
247         else
248             node = node->mRight;
249     }
250 
251     return node;
252 }
253 
254 template < typename T >
255 BSTNode<T>* BSTree<T>::iterativeSearch(const T& value) const
256 {
257     return iterativeSearch(dynamic_cast<BSTNode<T>*>(this->mRoot), value);
258 }
259 
260 template < typename T >
261 BSTNode<T>* BSTree<T>::minimum(BSTNode<T>* tree) const
262 {
263     if ( tree == nullptr )
264         return nullptr;
265 
266     while ( tree->mLeft != nullptr )
267         tree = tree->mLeft;
268 
269     return tree;
270 }
271 
272 template < typename T >
273 const T& BSTree<T>::minimum() const
274 {
275     BSTNode<T> *p = minimum(dynamic_cast<BSTNode<T>*>(this->mRoot));
276     if ( p == nullptr )
277         THROW_EXCEPTION(EmptyTreeException, "The tree is empty ...");
278 
279     return p->mKey;
280 }
281 
282 template < typename T >
283 BSTNode<T>* BSTree<T>::maximum(BSTNode<T>* tree) const
284 {
285     if ( tree == nullptr )
286         return nullptr;
287 
288     while ( tree->mRight != nullptr )
289         tree = tree->mRight;
290 
291     return tree;
292 }
293 
294 template < typename T >
295 const T& BSTree<T>::maximum() const
296 {
297     BSTNode<T> *p = maximum(dynamic_cast<BSTNode<T>*>(this->mRoot));
298     if ( p == nullptr )
299         THROW_EXCEPTION(EmptyTreeException, "The tree is empty ...");
300 
301     return p->mKey;
302 }
303 
304 template < typename T >
305 BSTNode<T>* BSTree<T>::successor(BSTNode<T> *node) const    // 查找后继
306 {
307     if ( node->mRight != nullptr )                            // 如果node有右孩子，则在它的右孩子里面最小的是后继
308     {
309         return minimum(node->mRight);
310     }
311 
312     BSTNode<T>* ret = node->mParent;                        // 如果node没有右孩子，且它自身是左孩子，则它的父亲是后继
313     while ( (ret != nullptr) && (node == ret->mRight) )        // 如果node没有右孩子，且它自身是右孩子，它的最近祖先是左孩子的，则这个祖先的父亲就是后继
314     {
315         node = ret;
316         ret = ret->mParent;
317     }
318 
319     return ret;
320 }
321 
322 template < typename T >
323 BSTNode<T>* BSTree<T>::predecessor(BSTNode<T>* node) const    // 查找前继
324 {
325     if ( node->mLeft != nullptr )                            // 如果node有左孩子，则在它的左孩子里面最大的是前继
326         return maximum(node->mLeft);
327 
328     BSTNode<T>* ret = node->mParent;                        // 如果node没有左孩子，且它自身是右孩子，则它的父亲是后继
329     while ( (ret != nullptr) && (node == ret->mLeft) )        // 如果node没有左孩子，且它自身是左孩子，它的最近祖先是右孩子的，则这个祖先的父亲就是后继
330     {
331         node = ret;
332         ret = ret->mLeft;
333     }
334 
335     return ret;
336 }
337 
338 template < typename T >
339 void BSTree<T>::insert(BSTNode<T>* node)
340 {
341     BSTNode<T>* in = nullptr;                // 插入点
342     BSTNode<T>* parent = dynamic_cast<BSTNode<T>*>(this->mRoot);        // 插入点的父节点
343 
344     while ( parent != nullptr )                // 查找node的插入点
345     {
346         in = parent;
347         if ( node->mKey < in->mKey )        // 如果node结点小于插入点，则插入到左孩子分支
348             parent = parent->mLeft;
349         else if ( node->mKey > in->mKey )    // 如果node结点大于插入点，则插入到右孩子分支
350             parent = parent->mRight;
351         else                                // 如果数据等同则跳出
352             break;
353     }
354 
355     node->mParent = in;                    // 设置node结点的父亲为插入点
356     if ( in == nullptr )                // 如果插入点为空，设node结点为根节点
357         this->mRoot = node;
358     else if ( node->mKey < in->mKey )    // 如果node结点小于插入点，插入左边
359         in->mLeft = node;
360     else if ( node->mKey > in->mKey )    // 如果node结点大于插入点，插入右边
361         in->mRight = node;
362     else                                // 如果数据等同则直接替换并释放插入的结点
363     {
364         in->mKey = node->mKey;
365         delete node;
366         return;
367     }
368 
369     ++this->mCount;                        // 结点统计，注意重复结点插入时不能增加
370 }
371 
372 template < typename T >
373 void BSTree<T>::insert(const T& key)
374 {
375     insert(new BSTNode<T>(key, nullptr, nullptr, nullptr));
376 }
377 
378 template < typename T >
379 BSTNode<T>* BSTree<T>::remove(BSTNode<T> *node)
380 {
381     BSTNode<T>* replace = nullptr;            // 代替结点
382     BSTNode<T>* del = nullptr;                // 删除点
383 
384     if ( (node->mLeft == nullptr) || (node->mRight == nullptr) )    // 如果孩子不全，node就是删除点，可以直接用仅有的孩子代替
385         del = node;
386     else                                                            // 否则有两个孩子，后继就是删除点(右子树中最小的成员)
387     {
388         del = successor(node);                                        // 查找后继
389         node->mKey = del->mKey;                                        // 直接用后继key替换node的key
390     }
391 
392     if ( del->mLeft != nullptr )            // 如果有左孩子，则更新左孩子为代替结点（如果if成立就只有左孩子）
393         replace = del->mLeft;
394     else                                    // 否则设右孩子为代替结点
395         replace = del->mRight;
396 
397     if ( replace != nullptr )                // 如果代替结点不是空树，更新代替结点的父亲
398         replace->mParent = del->mParent;
399 
400     if ( del->mParent == nullptr )            // 如果结点是根节点且孩子不全，那就直接替换
401         this->mRoot = replace;
402     else if ( del == del->mParent->mLeft )    // 如果删除点为左孩子，则更新父节点的左孩子
403         del->mParent->mLeft = replace;
404     else                                    // 否则更新父节点的右孩子
405         del->mParent->mRight = replace;
406 
407     --this->mCount;
408 
409     return del;
410 }
411 
412 template < typename T >
413 void BSTree<T>::remove(const T& key)
414 {
415     BSTNode<T> *del = nullptr, *node;
416     del = search(dynamic_cast<BSTNode<T>*>(this->mRoot), key);
417 
418     if ( del != nullptr )                        // 找到的删除点不为空
419         if ( (node = remove(del)) != nullptr )    // 删除node并返回代替结点
420             delete node;                        // 删除代替结点
421 }
422 
423 template < typename T >
424 void BSTree<T>::destroy(BSTNode<T> *tree)
425 {
426     if ( tree == nullptr )
427         return;
428 
429     if ( tree->mLeft != nullptr )
430         destroy(tree->mLeft);
431 
432     if ( tree->mRight != nullptr )
433         destroy(tree->mRight);
434 
435     delete tree;
436     tree = nullptr;
437 }
438 
439 template < typename T >
440 void BSTree<T>::destroy()
441 {
442     destroy(dynamic_cast<BSTNode<T>*>(this->mRoot));
443     this->mRoot = nullptr;
444     this->mCount = 0;
445 }
446 
447 template < typename T >
448 int BSTree<T>::height(BSTNode<T>* node) const
449 {
450     int ret = 0;
451 
452     if( node != nullptr )
453     {
454         int lh = height(node->mLeft);
455         int rh = height(node->mRight);
456 
457         ret = ((lh > rh) ? lh : rh) + 1;
458     }
459 
460     return ret;
461 }
462 
463 template < typename T >
464 int BSTree<T>::height() const
465 {
466     int ret = 0;
467 
468     if( this->mRoot != nullptr )
469     {
470         ret = height(dynamic_cast<BSTNode<T>*>(this->mRoot));
471     }
472 
473     return ret;
474 }
475 
476 template < typename T >
477 int BSTree<T>::degree(BSTNode<T>* node) const
478 {
479     int ret = 0;
480 
481     if( node != nullptr )
482     {
483         BSTNode<T>* child[] = { node->mLeft, node->mRight };
484 
485         ret = (!!node->mLeft + !!node->mRight);        // 统计有效结点数，!!用于转换成bool类型，如果是有效结点则为1，否则为0
486 
487         for(int i=0; (i<2) && (ret<2); i++)            // 如果儿子不足2个需要检查
488         {
489             int d = degree(child[i]);
490 
491             if( ret < d )
492             {
493                 ret = d;
494             }
495         }
496     }
497 
498     return ret;
499 }
500 
501 template < typename T >
502 int BSTree<T>::degree() const
503 {
504     return degree(dynamic_cast<BSTNode<T>*>(this->mRoot));
505 }
506 
507 template < typename T >
508 size_t BSTree<T>::getCount() const
509 {
510     return this->mCount;
511 }
512 
513 template <typename T>
514 void BSTree<T>::printTree(BSTNode<T> *tree, bool firstNode) const
515 {
516     if ( tree == nullptr )
517         return;
518 
519     size_t height = this->height();                // 树的高度
520     static bool *outTag = new bool[height]();    // 左边是否还有结点的标记，初始化为false
521     uint8_t static layer = 0;                    // 当前层数，根结点为第一层
522     uint8_t i;
523     ++layer;
524 
525     if ( layer > 1 )                    // 如果不是根节点需要输出特殊符号
526     {
527         for (i=1; i<layer-1; ++i )        // 根节点和最后一个结点不需要，所以从1至(layer-1)
528             if ( outTag[i] )            // 如果左边还有结点
529                 cout << "|       ";
530             else
531                 cout << "        ";
532 
533         if ( firstNode == true )        // 判断左右结点，非二叉树需要另外处理
534             cout << "L-------" << flush;
535         else
536             cout << "R-------" << flush;
537     }
538     cout << tree->mKey << endl;
539 
540     if ( (tree->mRight) != nullptr )    // 先输出右节点
541     {
542         if ( tree->mLeft != nullptr )    // 如果左边还有结点需要做标记
543             outTag[layer] = true;
544         printTree(tree->mRight, false);    // false表示当前是右节点
545     }
546 
547     if ( tree->mLeft != nullptr )
548     {
549         outTag[layer] = false;            // 左结点左边不再有结点，恢复默认标记
550         printTree(tree->mLeft, true);
551     }
552 
553     --layer;                            // 结点回溯时高度需要减1
554 }
555 
556 template <typename T>
557 void BSTree<T>::printTree() const
558 {
559     printTree(dynamic_cast<BSTNode<T>*>(this->mRoot), false);    // 作为根节点时，右参数无意义
560 }
561 
562 template < typename T >
563 const T& BSTree<T>::getRootKey() const
564 {
565     return this->mRoot->mKey;
566 }
567 
568 template < typename T >
569 BSTree<T>::~BSTree()
570 {
571     destroy();
572 }
573 
574 }
575 
576 #endif // BSTREE_H

 1 #ifndef TIMES_H
 2 #define TIMES_H
 3 
 4 #include <iostream>
 5 #include <sys/time.h>
 6 #ifdef _WIN32
 7 #include <windows.h>
 8 #endif
 9 
10 namespace LinWeiJie_lib
11 {
12 
13 // CPU频率计时器
14 #if defined (__i386__)
15 static __inline__ unsigned long long GetCycleCount(void)
16 {
17         unsigned long long int x;
18         __asm__ volatile("rdtsc":"=A"(x));
19         return x;
20 }
21 #elif defined (__x86_64__)
22 static __inline__ unsigned long long GetCycleCount(void)
23 {
24         unsigned hi,lo;
25         __asm__ volatile("rdtsc":"=a"(lo),"=d"(hi));
26         return (static_cast<unsigned long long>(lo))|(static_cast<unsigned long long>(hi)<<32);
27 }
28 #endif
29 
30 static void timing(bool b){
31     if(b) goto GET;
32     static struct timeval tv_begin, tv_end;
33     gettimeofday(&tv_begin, nullptr);
34 
35 #ifdef _WIN32
36     static LARGE_INTEGER li_freq, li_start, li_stop;
37     QueryPerformanceFrequency(&li_freq);
38     QueryPerformanceCounter(&li_start);
39 #endif
40 
41     static uint64_t t1 = GetCycleCount();
42 
43     std::cout << "启动计时..." << std::endl;
44     goto END;
45 
46 GET:
47     gettimeofday(&tv_end, nullptr);
48     std::cout << "Linux:  \t" << std::fixed << (tv_end.tv_sec+tv_end.tv_usec/1000000.0)-(tv_begin.tv_sec+tv_begin.tv_usec/1000000.0) << " s" << std::endl;
49 
50 #ifdef _WIN32
51     QueryPerformanceCounter(&li_stop);
52     std::cout << "Windows:\t" << (li_stop.QuadPart-li_start.QuadPart) * 1.0 / li_freq.QuadPart << " s" << std::endl;
53 #endif
54 
55     std::cout << "CPU:    \t" << (GetCycleCount() - t1)/3800000000.0 << " s" << std::endl;
56 END:
57     ;
58 }
59 
60 static void timingStart()
61 {
62     timing(false);
63 }
64 
65 static void timingEnd()
66 {
67     timing(true);
68 }
69 
70 }
71 
72 #endif // TIMES_H

 1 #include <iostream>
 2 #include <cmath>
 3 
 4 #include "BSTree.h"
 5 
 6 #include "Times.h"
 7 
 8 using namespace std;
 9 using namespace LinWeiJie_lib;
10 
11 int main(int argc, char* argv[])
12 {
13     uint16_t layer = 8;    // 结点最小层数
14 
15     if ( argc == 2 && atoi(argv[1])>0 )
16         layer = static_cast<uint8_t>(atoi(argv[1]));
17     else {
18         cout << "请输入结点最小层数，注意内存大小，结点层数上限为：" << log(RAND_MAX*RAND_MAX+1)/log(2) << endl;
19         cin >> layer;
20     }
21 
22     timingStart();                            // 启动计时
23 
24     cout << endl;
25 
26     uint64_t const count = (1ull<<layer)-1;    // 结点数
27     uint16_t speed;                            // 记录插入和删除的进度百分比（0～100）
28 
29     BSTree<uint64_t> *tree = new BSTree<uint64_t>();
30 
31     speed = 0;
32     srand(static_cast<unsigned int>(time(nullptr)));
33     while ( tree->getCount() < count )
34     {
35         tree->insert(static_cast<size_t>(rand()*rand()));    // 使用随机值插入；如果是顺序值，会退化成链表模式，且插入变慢
36 
37         if ( (tree->getCount()*100/count > speed) || (tree->getCount() == count) )    // 进度值出现变化或完成操作时才能输出
38         {
39             speed = static_cast<uint16_t>(tree->getCount()*100/count);
40             cout << "\r已添加：" << setw(3) << speed << ‘%‘ << flush;
41         }
42     }
43     cout << endl;
44 
45     cout << "\n前序遍历: ";
46     tree->preOrder();
47     cout << endl;
48 
49     cout << "\n中序遍历: ";
50     tree->inOrder();
51     cout << endl;
52 
53     cout << "\n后续遍历: ";
54     tree->postOrder();
55     cout << endl;
56 
57     cout << "\n广度遍历：";
58     tree->levelOrder();
59     cout << endl;
60 
61     cout << "\n最小值: " << tree->minimum();
62     cout << "\n最大值: " << tree->maximum();
63     cout << "\nheight = " << tree->height();
64     cout << "\n结点数= " << tree->getCount();
65     cout << endl;
66 
67     cout << "\n输出树形信息：" << endl;
68     tree->printTree();
69     cout << endl;
70 
71     speed = 0;
72     srand(static_cast<unsigned int>(time(nullptr)));
73     while ( tree->getCount() )
74     {
75         uint64_t node;
76 //        if ( tree->getCount()*100/count < 20 )            // 剩余量太少时，随机值命中有效结点的概率太低，从而导致删除缓慢
77             node = tree->getRootKey();
78 //        else
79 //            node = static_cast<size_t>(rand()*rand());
80 
81         tree->remove(node);
82 
83         if ( ((count-tree->getCount())*100/count > speed) || (tree->getCount() == count) )
84         {
85             speed = static_cast<uint16_t>((count-tree->getCount())*100/count);
86             cout << "\r已删除：" << setw(3) << speed << ‘%‘ << flush;
87         }
88     }
89     cout << endl;
90 
91     tree->destroy();
92     delete tree;
93     tree = nullptr;
94 
95     cout << endl;
96     timingEnd();
97 
98     return 0;
99 }