devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

二叉查找树全面详细介绍_什么是二插查找树

作者：IT小白 | 2024-05-15 10:13:36

赞

踩

什么是二插查找树

一、前言

重新梳理整理归纳二叉搜索树。主要参考《C++数据结构与算法》。

 

二、定义

二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。是数据结构中的一类。在一般情况下，查询效率比链表结构要高。

二叉排序树定义，一棵空树，或者是具有下列性质的二叉树：

  1. 若左子树不空，则左子树上所有结点的值均小于它的根结点的值；
  2. 若右子树不空，则右子树上所有结点的值均大于它的根结点的值；
  3. 左、右子树也分别为二叉排序树；
  4. 没有键值相等的结点。

 

三、二叉搜索树接口操作说明

二叉搜索树的基本操作有：搜索（查找）、遍历、插入、删除。

3.1 搜索

在树中定位一个元素的算法相当直观，《4.2 搜索（查找）》实现了该算法。对于每个节点，算法将要定位的值与当前所指节点中存储的值进行比较。如果该值小于存储值，则转向左子树；如果该值大于存储的值，则转向右子树。如果二者相同，很明显查找过程可以结束了。如果没有其他可以查找的节点，该查找过程也终止，这表示该值不在该树中。

搜索实现方法可以分为：递归搜索、非递归搜索《4.2 搜索（查找）》实现了该算法。

 

3.2 遍历

树的遍历是当且仅当访问树中每个节点一次的过程。遍历可以解释为把所有的节点放在一条线上,或者将树线性化。

遍历的定义只指定了个条件：每个节点仪访问一次，没有指定这些节点的访问顺序。因此，节点有多少种排列方式，就有多少种遍历方法。对于有n个节点的树，共有n!个不同的遍历方式。然而，大多数遍历方式是混乱的，很难从中找到规律，因此实现这样的遍历缺乏普遍性。对于每个n，必须实现一套独立的遍历程序，其中只有很少的几个可以用于不同数量的数据。在如此多的遍历方法中，大多数方法明显没有什么用处，这里仅介绍两类方法，即深度优先遍历与广度优先遍历。

遍历可以分为：深度优先遍历(DFS)和广度优先遍历(BFS)。

3.2.1 深度优先遍历(DFS)

深度优先遍历将尽可能地向左(或向右)进行，在遇到第一个转折点时，向左(或向右)一步，然后,再尽可能地向左(或向右)发展。这一过程，一直重复，直至访问了所有的节点为止。然而，这一定义并没有清楚地指明什么时候访问节点：在沿着树向下进行之前还是在折返之后？深度优先遍历有许多变种。

这种类型的遍历中，有3个有趣的任务：

  • v——访问节点
  • L——遍历左子树
  • R——遍历右子树

如果这些任务在每个节点上都以相同的顺序执行，就形成了有序遍历。这3种任务自身共有3!=6种排序方式，因此，总共有6种有序深度优先遍历：VLR，LVR，LRV，VRL，RVL，RLV。

遍历方式看起来还是有些多，如果规定访问总是从左向右移动，则上面的遍历方式可以缩减为3种。这三种遍历方式的标准名称为：

  • VLR——前序树遍历
  • LVR——中字树遍历
  • LVR——后序树遍

深度优先遍历(DFS)按照遍历顺序可以分为：前序遍历、中序遍历、后序遍历

深度优先遍历(DFS)按照实现方法可以分为：递归遍历实现、非递归遍历实现、Morris遍历实现。

深度优先遍历接口有9(3*3)个。

备注：递归遍历实现、非递归遍历实现、Morris遍历实：详细讲解：https://blog.csdn.net/nie2314550441/article/details/107073598

 

3.2.2 广度优先遍历(BFS)

用队列实现。《4.5 插入》实现了插入节点算法的代码。

广度优先遍历从最低层(或者最高层)开始，向下(或向上)逐层访问每个节点，在每一层次上，从左到右(或从右到左)访问每个节点。这样就有4种访问方式，其中的种访问方式(从上到下、从左到右的广度优先遍历方式)。

当使用队列时，这种遍历方式的实现相当直接。假设从上到下、从左到右进行广度优先遍历。在访问了一个节点后，它的子节点(如果有的话)就放到队列的末尾，然后访问队列头部的节点。对于层次为n的节点，它的子节点位于第n+1层，如果将该节点的所有子节点都放到队列的末尾，那么，这些节点将在第n层的所有节点都访问后再访问。这样，算法就满足了“第n层的所有节点都必须在第n+1层的节点之前访问”的条件。实现过程见——4.4 广度优先遍历。

 

3.3 插入

要插入键值为el的新节点，必须找到树中的一个终端节点，并将新节点与该节点连接。要找到这样一个终端节点，可以使用与查找树相同的技术：在扫描树的过程中，比较键值el与当前检查的节点的键值。如果el小于该键值，就测试当前节点的左子节点，否则，就测试当前节点的右子节点。如果要测试的p的子节点为空，就停止扫描，新节点将成为p的子节点。图6-12显示了这一过程。

插入实现方法可以分为：非递归实现、递归实现。

 

3.4 删除

删除节点有两种方案：查找合并删除、查找复制删除。

执行删除操作的复杂度取决于要删除的节点在树中的位置。删除有两个子树的节点比删除叶节点困难得多，删除算法的复杂度与被删除节点的子节点数目成正比。从二叉查找树中删除节点有三种情况：

(1)要删除的节点是一个叶节点，该节点没有子节点。这种情况最容易处理。其父节点的相应指针设置为空，该节点通过delete操作被删除，如图6-14所示。

(2)要删除的节点有一个子节点，这种情况也不复杂。父节点中指向该节点的指针重新设置为指向被删除节点的子节点。这样，被删除节点的子节点提升一个层次，其后的所有后裔节点根据家族关系依次提升一个层次。例如，要删除图6-15中包含20的节点，可以将其父节点15的右指针指向其唯的子节点16。

(3)要删除的节点有两个子节点。在这种情况中，无法一步完成删除操作，因为父节点的右指针或左指针不能同时指向被删除节点的两个子节点。本节讨论解决这一问题的两种不同方案。

3.4.1 查找合并删除

查找合并删除：查找到删除节点P，将P节点删除，然后将左节点L、右节点R进行合并，最后将P父节点（如果有的话）指向L节点。

1）需要删除的节点，有左右孩子节点，下图中删除节点是点P，灰色节点表示该节点可以有可以没有。P节点可以有父节点，可以没有，如果有父节点，可以是父节点的左节点也可以是右节点，对结果没有影响。

2）P节点删除之后剩下：P节点父节点（如果有的话）、左节点L、右节点R。查找合并删除：查找到P节，将P节点删除，然后将P节点父节点（如果有的话）、左节点L、右节点R进行合并，准确来说是将左节点L、右节点R进行合并。

3）找到P节点右节点中最大节点，并将R节点接在最大节点右节点上，P父节点（如果有的话）指向L节点。

P节点的右节点中最大节点查找方法，一直查找L节点的右节点，直到最后一个没有右节点的节点D即为P节点中最大的节点，D节点的右节点指向R节点，合并完成，例如下图：

3.4.2 查找复制删除

查找复制删除：查找一个可以替换P节点位置的节点，将该节点元素复制到P节点中，并将该节点删除。能替换P节点位置的节点有两个，一个是P节点左节点中元素最大的节点，另一个是P节点右节点中元素最小的节点，这里用到的是P节点左节点中元素最大的节点。

1）需要删除的节点，有左右孩子节点，下图中删除节点是点P，灰色节点表示该节点可以有可以没有。P节点可以有父节点，可以没有，如果有父节点，可以是父节点的左节点也可以是右节点，对结果没有影响。

2）查找P节点左节点中最大的节点D

3) 将D节点元素复制到P节点中，D节点的父节点Pre指向D节点左节点，删除D节点。需要说明一下，如果Pre和P是同一个节点，则Pre左节点指向T节点，如果Pre和P不是同一个节点，则Pre右节点指向T节点。

 

四、二叉搜索树接口C++实现(代码说明)

4.1 基本定义

为了方便使用对栈和队列一些接口进行了重写。

  1. template<class T>
  2. class Stack: public stack<T> 
  3. {
  4. public:
  5.     T pop() 
  6.     {
  7.         T tmp = stack<T>::top();
  8.         stack<T>::pop();
  9.         return tmp;
  10.     }
  11. };
  12.  
  13. template<class T>
  14. class Queue: public queue<T> 
  15. {
  16. public:
  17.     T dequeue() 
  18.     {
  19.         T tmp = queue<T>::front();
  20.         queue<T>::pop();
  21.         return tmp;
  22.     }
  23.  
  24.     void enqueue(const T& m_el) 
  25.     {
  26.         queue<T>::push(m_el);
  27.     }
  28. };
  29.  
  30. template<class T>
  31. class BSTNode 
  32. {
  33. public:
  34.     BSTNode()
  35.     {
  36.         m_el = 0;
  37.         m_left = nullptr;
  38.         m_right = nullptr;
  39.     }
  40.  
  41.     BSTNode(const T& e, BSTNode<T>* l = nullptr, BSTNode<T> * r = nullptr)
  42.     {
  43.         m_el = e; 
  44.         m_left = l; 
  45.         m_right = r;
  46.     }
  47.  
  48.     T m_el;
  49.     BSTNode<T>* m_left;
  50.     BSTNode<T>* m_right;
  51. };

 

4.2 搜索（查找）

递归实现和非递归实现，很容易理解直接看代码即可。

  1. // 搜索，递归实现
  2. template<class T>
  3. T* BST<T>::recursiveSearch(BSTNode<T>* p, const T& m_el) const 
  4. {
  5.     if (p != 0)
  6.     {
  7.         if (m_el == p->m_el)
  8.             return &p->m_el;
  9.         else if (m_el < p->m_el)
  10.             return recursiveSearch(p->m_left, m_el);
  11.         else 
  12.             return recursiveSearch(p->m_right, m_el);
  13.     }
  14.     else
  15.         return 0;
  16. }
  17.  
  18. // 搜索，非递归实现
  19. template<class T>
  20. T* BST<T>::search(BSTNode<T>* p, const T& m_el) const 
  21. {
  22.     while (p != 0)
  23.     {
  24.         if (m_el == p->m_el)
  25.             return &p->m_el;
  26.         else if (m_el < p->m_el)
  27.             p = p->m_left;
  28.         else 
  29.             p = p->m_right;
  30.     }
  31.  
  32.     return 0;
  33. }

 

4.3 深度优先遍历

4.3.1 递归实现：前序遍历、中序遍历、后序遍历

递归实现的，前序遍历、中序遍历、后序遍历直接看代码即可。

  1. // 前序遍历，递归实现
  2. template<class T>
  3. void BST<T>::preorder(BSTNode<T>* p)
  4. {
  5. 	if (p != 0)
  6. 	{
  7.         visit(p);
  8.         preorder(p->m_left);
  9.         preorder(p->m_right);
  10. 	}
  11. }
  12.  
  13. // 中序遍历，递归实现
  14. template<class T>
  15. void BST<T>::inorder(BSTNode<T>* p) 
  16. {
  17.     if (p != 0) 
  18.     {
  19.         inorder(p->m_left);
  20.         visit(p);
  21.         inorder(p->m_right);
  22.     }
  23. }
  24.  
  25. // 后序遍历，递归实现
  26. template<class T>
  27. void BST<T>::postorder(BSTNode<T>* p) 
  28. {
  29.     if (p != 0) 
  30.     {
  31.         postorder(p->m_left);
  32.         postorder(p->m_right);
  33.         visit(p);
  34.     }
  35. }

4.3.2 非递归实现：前序遍历、中序遍历、后序遍历

  1. // 前序遍历，非递归栈实现
  2. template<class T>
  3. void BST<T>::iterativePreorder() 
  4. {
  5.     Stack<BSTNode<T>*> travStack;
  6.     BSTNode<T>* p = root;
  7.     if (p != 0) 
  8.     {
  9.         travStack.push(p);
  10.         while (!travStack.empty())
  11.         {
  12.             p = travStack.pop();
  13.             visit(p);
  14.             if (p->m_right != 0)
  15.                 travStack.push(p->m_right);
  16.  
  17.             if (p->m_left != 0)            
  18.                 travStack.push(p->m_left); 
  19.         }
  20.     }
  21. }
  22.  
  23. // 中序遍历，非递归栈实现
  24. template<class T>
  25. void BST<T>::iterativeInorder() 
  26. {
  27.     Stack<BSTNode<T>*> travStack;
  28.     BSTNode<T>* p = root;
  29.     while (p != nullptr) 
  30.     {
  31.         while (p != nullptr)
  32.         {                 
  33.             if (p->m_right)                
  34.                 travStack.push(p->m_right); 
  35.  
  36.             travStack.push(p);
  37.             p = p->m_left;
  38.         }
  39.  
  40.         p = travStack.pop();             
  41.         while (!travStack.empty() && p->m_right == nullptr)
  42.         { 
  43.             visit(p);                                
  44.             p = travStack.pop();
  45.         }
  46.  
  47.         visit(p);                       
  48.         if (!travStack.empty())          
  49.             p = travStack.pop();
  50.         else 
  51.             p = nullptr;
  52.     }
  53. }
  54.  
  55. // 后序遍历，非递归栈实现
  56. template<class T>
  57. void BST<T>::iterativePostorder() 
  58. {
  59.     Stack<BSTNode<T>*> travStack;
  60.     BSTNode<T>* p = root, * q = root;
  61.     while (p != nullptr) 
  62.     {
  63.         for (; p->m_left != nullptr; p = p->m_left)
  64.             travStack.push(p);
  65.  
  66.         while (p->m_right == nullptr || p->m_right == q)
  67.         {
  68.             visit(p);
  69.             q = p;
  70.             if (travStack.empty())
  71.                 return;
  72.  
  73.             p = travStack.pop();
  74.         }
  75.         travStack.push(p);
  76.         p = p->m_right;
  77.     }
  78. }

4.3.3 Morris遍历：前序遍历、中序遍历、后序遍历

  1. // 前序遍历，非递归Morris遍历算法实现
  2. template<class T>
  3. void BST<T>::MorrisPreorder() 
  4. {
  5.     BSTNode<T>* p = root, * tmp;
  6.     while (p != nullptr) 
  7.     {
  8.         if (p->m_left == nullptr)
  9.         {
  10.             visit(p);
  11.             p = p->m_right;
  12.         }
  13.         else 
  14.         {
  15.             tmp = p->m_left;
  16.             while (tmp->m_right != nullptr && tmp->m_right != p)
  17.                 tmp = tmp->m_right;   
  18.  
  19.             if (tmp->m_right == nullptr)
  20.             {  
  21.                 visit(p);         
  22.                 tmp->m_right = p;    
  23.                 p = p->m_left;        
  24.             }
  25.             else 
  26.             {                   
  27.                 tmp->m_right = nullptr;    
  28.                 p = p->m_right;       
  29.             }                        
  30.         }
  31.     }
  32. }
  33.  
  34. // 中序遍历，非递归Morris遍历算法实现
  35. template<class T>
  36. void BST<T>::MorrisInorder() 
  37. {
  38.     BSTNode<T>* p = root, * tmp;
  39.     while (p != 0)
  40.     {
  41.         if (p->m_left == 0) 
  42.         {
  43.             visit(p);
  44.             p = p->m_right;
  45.         }
  46.         else 
  47.         {
  48.             tmp = p->m_left;
  49.             while (tmp->m_right != 0 &&
  50.                 tmp->m_right != p)  
  51.                 tmp = tmp->m_right;   
  52.             if (tmp->m_right == 0) 
  53.             {   
  54.                 tmp->m_right = p;    
  55.                 p = p->m_left;       
  56.             }
  57.             else 
  58.             {                   
  59.                 visit(p);      
  60.                 tmp->m_right = 0;    
  61.                 p = p->m_right;      
  62.             }                      
  63.         }
  64.     }
  65. }
  66.  
  67. // 后序遍历，非递归Morris遍历算法实现
  68. template<class T>
  69. void BST<T>::MorrisPostorder() 
  70. {
  71.     BSTNode<T>* p = new BSTNode<T>(), * tmp, * q, * r, * s;
  72.     p->m_left = root;
  73.     while (p != 0)
  74.     {
  75.         if (p->m_left == 0)
  76.             p = p->m_right;
  77.         else
  78.         {
  79.             tmp = p->m_left;
  80.             while (tmp->m_right != 0 && tmp->m_right != p)  
  81.                 tmp = tmp->m_right;   
  82.  
  83.             if (tmp->m_right == 0) 
  84.             {   
  85.                 tmp->m_right = p;     
  86.                 p = p->m_left;        
  87.             }
  88.             else
  89.             {             
  90.                 for (q = p->m_left, r = q->m_right, s = r->m_right;
  91.                     r != p; q = r, r = s, s = s->m_right)
  92.                     r->m_right = q;
  93.  
  94.                 for (s = q->m_right; q != p->m_left;
  95.                     q->m_right = r, r = q, q = s, s = s->m_right)
  96.                     visit(q);
  97.  
  98.                 visit(p->m_left);    
  99.                 tmp->m_right = 0;     
  100.                 p = p->m_right;      
  101.             }                   
  102.         }
  103.     }
  104. }

 

4.4 广度优先遍历

  1. // 广度优先遍历：从上到下，从左到右
  2. template<class T>
  3. void BST<T>::breadthFirst() 
  4. {
  5.     Queue<BSTNode<T>*> queue;
  6.     BSTNode<T>* p = root;
  7.     if (p != 0) 
  8.     {
  9.         queue.enqueue(p);
  10.         while (!queue.empty()) 
  11.         {
  12.             p = queue.dequeue();
  13.             visit(p);
  14.             if (p->m_left != 0)
  15.                 queue.enqueue(p->m_left);
  16.             if (p->m_right != 0)
  17.                 queue.enqueue(p->m_right);
  18.         }
  19.     }
  20. }

 

4.5 插入

非递归实现和递归实现

  1. // 插入插入一个元素，非递归实现
  2. template<class T>
  3. bool BST<T>::insert(const T& m_el) 
  4. {
  5.     BSTNode<T>* p = root, * prev = 0;
  6.     while (p != 0) 
  7.     {  
  8.         prev = p;
  9.         if (m_el < p->m_el)
  10.             p = p->m_left;
  11.         else if (m_el > p->m_el)
  12.             p = p->m_right;
  13.         else
  14.         {
  15.             cout << "BST<T>::insert 插入相同的数据，插入失败" << endl;
  16.             return false;
  17.         }
  18.     }
  19.  
  20.     if (root == 0)    
  21.         root = new BSTNode<T>(m_el);
  22.     else if (m_el < prev->m_el)
  23.         prev->m_left = new BSTNode<T>(m_el);
  24.     else 
  25.         prev->m_right = new BSTNode<T>(m_el);
  26.  
  27. 	return true;
  28. }
  29.  
  30. // 插入插入一个元素，递归实现
  31. template<class T>
  32. bool BST<T>::recursiveInsert(BSTNode<T>*& p, const T& m_el) 
  33. {
  34.     if (p == 0)
  35.         p = new BSTNode<T>(m_el);
  36.     else if (m_el < p->m_el)
  37.         recursiveInsert(p->m_left, m_el);
  38.     else if (m_el > p->m_el)
  39.         recursiveInsert(p->m_right, m_el);
  40.     else
  41.     {
  42.         cout << "BST<T>::recursiveInsert 插入相同的数据，插入失败" << endl;
  43.         return false;
  44.     }
  45.     
  46.     return true; 
  47. }

 

4.6 删除

查找复制删除和查找归并删除

  1. // 查找复制删除
  2. template<class T>
  3. void BST<T>::findAndDeleteByCopying(const T& m_el) 
  4. {
  5.     BSTNode<T>* p = root, * prev = 0;
  6.     while (p != 0 && p->m_el != m_el) 
  7.     {
  8.         prev = p;
  9.         if (m_el < p->m_el)
  10.             p = p->m_left;
  11.         else 
  12.             p = p->m_right;
  13.     }
  14.  
  15.     if (p != 0 && p->m_el == m_el)
  16.     {
  17.         if (p == root)
  18.             deleteByCopying(root);
  19.         else if (prev->m_left == p)
  20.             deleteByCopying(prev->m_left);
  21.         else
  22.             deleteByCopying(prev->m_right);
  23. 	}
  24.     else if (root != 0)
  25.         cout << "m_el " << m_el << " is not in the tree\n";
  26.     else 
  27.         cout << "the tree is empty\n";
  28. }
  29.  
  30. // 查找复制删除
  31. template<class T>
  32. void BST<T>::deleteByCopying(BSTNode<T>*& node) 
  33. {
  34.     if (node == nullptr)
  35.         return;
  36. 	
  37.     BSTNode<T>* previous, * tmp = node;
  38.     if (node->m_right == nullptr)                  // node 没有右节点
  39.         node = node->m_left;
  40.     else if (node->m_left == nullptr)              // node 没有左节点
  41.         node = node->m_right;
  42.     else 
  43.     {
  44.         tmp = node->m_left;							// node 有左、右节点
  45.         previous = node;                   
  46.         while (tmp->m_right != nullptr)
  47.         {         
  48.             previous = tmp;
  49.             tmp = tmp->m_right;
  50.         }
  51.  
  52.         node->m_el = tmp->m_el;                
  53.         if (previous == node)
  54.             previous->m_left = tmp->m_left;
  55.         else 
  56.             previous->m_right = tmp->m_left;   
  57.     }
  58.  
  59.     delete tmp;                            
  60. }
  61.  
  62. // 查找合并删除
  63. template<class T>
  64. void BST<T>::findAndDeleteByMerging(const T& m_el) 
  65. {
  66.     BSTNode<T>* p = root, * prev = 0;
  67.     while (p != 0 && p->m_el != m_el)
  68.     {
  69.         prev = p;
  70.         if (m_el < p->m_el)
  71.             p = p->m_left;
  72.         else 
  73.             p = p->m_right;
  74.     }
  75.  
  76. 	if (p != 0 && p->m_el == m_el)
  77. 	{
  78.         if (p == root)
  79.             deleteByMerging(root);
  80.         else if (prev->m_left == p)
  81.             deleteByMerging(prev->m_left);
  82.         else
  83.             deleteByMerging(prev->m_right);
  84. 	}
  85.     else if (root != 0)
  86.         cout << "m_el " << m_el << " is not in the tree\n";
  87.     else cout << "the tree is empty\n";
  88. }
  89.  
  90. // 查找合并删除
  91. template<class T>
  92. void BST<T>::deleteByMerging(BSTNode<T>*& node) 
  93. {
  94.     if (node == nullptr)
  95.         return;
  96.  
  97.     BSTNode<T>* tmp = node;
  98.     if (node->m_right == nullptr)           // node 没有右节点
  99.         node = node->m_left;     
  100.     else if (node->m_left == nullptr)       // node 没有左节点
  101.         node = node->m_right;    
  102.     else 
  103.     {                      
  104.         tmp = node->m_left;      
  105.         while (tmp->m_right != nullptr)
  106.             tmp = tmp->m_right;
  107.  
  108.         tmp->m_right = node->m_right;           															
  109.         tmp = node;							
  110.         node = node->m_left;					
  111.     }
  112.  
  113.     delete tmp;								
  114. }

 

五、完整代码

  1. // 通用二叉查找树的实现
  2. #pragma once
  3. #include <queue>
  4. #include <stack>
  5. #include <iostream>
  6. using namespace std;
  7.  
  8. template<class T>
  9. class Stack: public stack<T> 
  10. {
  11. public:
  12.     T pop() 
  13.     {
  14.         T tmp = stack<T>::top();
  15.         stack<T>::pop();
  16.         return tmp;
  17.     }
  18. };
  19.  
  20. template<class T>
  21. class Queue: public queue<T> 
  22. {
  23. public:
  24.     T dequeue() 
  25.     {
  26.         T tmp = queue<T>::front();
  27.         queue<T>::pop();
  28.         return tmp;
  29.     }
  30.  
  31.     void enqueue(const T& m_el) 
  32.     {
  33.         queue<T>::push(m_el);
  34.     }
  35. };
  36.  
  37. template<class T>
  38. class BSTNode 
  39. {
  40. public:
  41. 	BSTNode()
  42. 	{
  43.         m_el = 0;
  44.         m_left = nullptr;
  45.         m_right = nullptr;
  46. 	}
  47.  
  48.     BSTNode(const T& e, BSTNode<T>* l = nullptr, BSTNode<T> * r = nullptr)
  49.     {
  50.         m_el = e; 
  51.         m_left = l; 
  52.         m_right = r;
  53.     }
  54.  
  55. 	T m_el;
  56. 	BSTNode<T>* m_left;
  57. 	BSTNode<T>* m_right;
  58. };
  59.  
  60. template<class T>
  61. class BST 
  62. {
  63. public:
  64.     BST()  { root = 0; }
  65.     ~BST() { clear();  }
  66.  
  67.     void clear() 
  68.     {
  69.         clear(root);
  70.         root = 0;
  71.     }
  72.  
  73. 	// 搜索，递归实现
  74. 	T* recursiveSearch(const T& m_el) const { return recursiveSearch(root, m_el); }
  75.     // 搜索，非递归实现
  76.     T* search(const T& m_el) const { return search(root, m_el); }
  77.  
  78.     // 前序遍历，递归实现
  79.     void preorder()  { preorder(root); }
  80.     // 中序遍历，递归实现
  81.     void inorder()  { inorder(root); }
  82.     // 后续遍历，递归实现
  83.     void postorder()  { postorder(root); }
  84.     // 前序遍历，非递归栈实现
  85.     void iterativePreorder();
  86.     // 中序遍历，非递归栈实现
  87.     void iterativeInorder();
  88.     // 后序遍历，非递归栈实现
  89.     void iterativePostorder();
  90.     // 前序遍历，非递归Morris遍历算法实现
  91.     void MorrisPreorder();
  92.     // 中序遍历，非递归Morris遍历算法实现
  93.     void MorrisInorder();
  94.     // 后序遍历，非递归Morris遍历算法实现
  95.     void MorrisPostorder();
  96.  
  97.     // 广度优先遍历：从上到下，从左到右
  98.     void breadthFirst();
  99.  
  100.     // 插入插入一个元素，非递归实现
  101.     bool insert(const T&);
  102.     // 插入插入一个元素，递归实现
  103.     bool recursiveInsert(const T& m_el) { recursiveInsert(root, m_el); }
  104.  
  105.     // 查找合并删除
  106.     void findAndDeleteByMerging(const T&);
  107.     // 查找复制删除
  108.     void findAndDeleteByCopying(const T&);
  109.  
  110. protected:
  111.     BSTNode<T>* root;
  112.     void clear(BSTNode<T>*);
  113.     // 插入插入一个元素，递归实现
  114.     bool recursiveInsert(BSTNode<T>*&, const T&);
  115.     // 搜索（查找），非递归实现
  116.     T* search(BSTNode<T>*, const T&) const;
  117.     // 搜索（查找），递归实现
  118.     T* recursiveSearch(BSTNode<T>*, const T&) const;
  119.     // 前序遍历，递归实现
  120.     void preorder(BSTNode<T>*);
  121.     // 中序遍历，递归实现
  122.     void inorder(BSTNode<T>*);
  123.     // 后序遍历，递归实现
  124.     void postorder(BSTNode<T>*);
  125.     // 复制删除
  126.     void deleteByCopying(BSTNode<T>*&);
  127.     // 合并删除
  128.     void deleteByMerging(BSTNode<T>*&);
  129.     // 访问节点
  130.     virtual void visit(BSTNode<T>* p) { cout << p->m_el << ' '; }
  131. };
  132.  
  133. template<class T>
  134. void BST<T>::clear(BSTNode<T>* p) 
  135. {
  136.     if (p != 0) 
  137.     {
  138.         clear(p->m_left);
  139.         clear(p->m_right);
  140.         delete p;
  141.     }
  142. }
  143.  
  144. // 搜索（查找），递归实现
  145. template<class T>
  146. T* BST<T>::recursiveSearch(BSTNode<T>* p, const T& m_el) const 
  147. {
  148.     if (p != 0)
  149.     {
  150.         if (m_el == p->m_el)
  151.             return &p->m_el;
  152.         else if (m_el < p->m_el)
  153.             return recursiveSearch(p->m_left, m_el);
  154.         else 
  155.             return recursiveSearch(p->m_right, m_el);
  156.     }
  157.     else
  158.         return 0;
  159. }
  160.  
  161. // 搜索（查找），非递归实现
  162. template<class T>
  163. T* BST<T>::search(BSTNode<T>* p, const T& m_el) const 
  164. {
  165.     while (p != 0)
  166.     {
  167.         if (m_el == p->m_el)
  168.             return &p->m_el;
  169.         else if (m_el < p->m_el)
  170.             p = p->m_left;
  171.         else 
  172.             p = p->m_right;
  173.     }
  174.  
  175.     return 0;
  176. }
  177.  
  178. // 前序遍历，递归实现
  179. template<class T>
  180. void BST<T>::preorder(BSTNode<T>* p)
  181. {
  182. 	if (p != 0)
  183. 	{
  184.         visit(p);
  185.         preorder(p->m_left);
  186.         preorder(p->m_right);
  187. 	}
  188. }
  189.  
  190. // 中序遍历，递归实现
  191. template<class T>
  192. void BST<T>::inorder(BSTNode<T>* p) 
  193. {
  194.     if (p != 0) 
  195.     {
  196.         inorder(p->m_left);
  197.         visit(p);
  198.         inorder(p->m_right);
  199.     }
  200. }
  201.  
  202. // 后序遍历，递归实现
  203. template<class T>
  204. void BST<T>::postorder(BSTNode<T>* p) 
  205. {
  206.     if (p != 0) 
  207.     {
  208.         postorder(p->m_left);
  209.         postorder(p->m_right);
  210.         visit(p);
  211.     }
  212. }
  213.  
  214. // 前序遍历，非递归栈实现
  215. template<class T>
  216. void BST<T>::iterativePreorder() 
  217. {
  218.     Stack<BSTNode<T>*> travStack;
  219.     BSTNode<T>* p = root;
  220.     if (p != 0) 
  221.     {
  222.         travStack.push(p);
  223.         while (!travStack.empty())
  224.         {
  225.             p = travStack.pop();
  226.             visit(p);
  227.             if (p->m_right != 0)
  228.                 travStack.push(p->m_right);
  229.  
  230.             if (p->m_left != 0)            
  231.                 travStack.push(p->m_left); 
  232.         }
  233.     }
  234. }
  235.  
  236. // 中序遍历，非递归栈实现
  237. template<class T>
  238. void BST<T>::iterativeInorder() 
  239. {
  240.     Stack<BSTNode<T>*> travStack;
  241.     BSTNode<T>* p = root;
  242.     while (p != nullptr) 
  243.     {
  244.         while (p != nullptr)
  245.         {                 
  246.             if (p->m_right)                
  247.                 travStack.push(p->m_right); 
  248.  
  249.             travStack.push(p);
  250.             p = p->m_left;
  251.         }
  252.  
  253.         p = travStack.pop();             
  254.         while (!travStack.empty() && p->m_right == nullptr)
  255.         { 
  256.             visit(p);                                
  257.             p = travStack.pop();
  258.         }
  259.  
  260.         visit(p);                       
  261.         if (!travStack.empty())          
  262.             p = travStack.pop();
  263.         else 
  264.             p = nullptr;
  265.     }
  266. }
  267.  
  268. // 后序遍历，非递归栈实现
  269. template<class T>
  270. void BST<T>::iterativePostorder() 
  271. {
  272.     Stack<BSTNode<T>*> travStack;
  273.     BSTNode<T>* p = root, * q = root;
  274.     while (p != nullptr) 
  275.     {
  276.         for (; p->m_left != nullptr; p = p->m_left)
  277.             travStack.push(p);
  278.  
  279.         while (p->m_right == nullptr || p->m_right == q)
  280.         {
  281.             visit(p);
  282.             q = p;
  283.             if (travStack.empty())
  284.                 return;
  285.  
  286.             p = travStack.pop();
  287.         }
  288.         travStack.push(p);
  289.         p = p->m_right;
  290.     }
  291. }
  292.  
  293. // 前序遍历，非递归Morris遍历算法实现
  294. template<class T>
  295. void BST<T>::MorrisPreorder() 
  296. {
  297.     BSTNode<T>* p = root, * tmp;
  298.     while (p != nullptr) 
  299.     {
  300.         if (p->m_left == nullptr)
  301.         {
  302.             visit(p);
  303.             p = p->m_right;
  304.         }
  305.         else 
  306.         {
  307.             tmp = p->m_left;
  308.             while (tmp->m_right != nullptr && tmp->m_right != p)
  309.                 tmp = tmp->m_right;   
  310.  
  311.             if (tmp->m_right == nullptr)
  312.             {  
  313.                 visit(p);         
  314.                 tmp->m_right = p;    
  315.                 p = p->m_left;        
  316.             }
  317.             else 
  318.             {                   
  319.                 tmp->m_right = nullptr;    
  320.                 p = p->m_right;       
  321.             }                        
  322.         }
  323.     }
  324. }
  325.  
  326. // 中序遍历，非递归Morris遍历算法实现
  327. template<class T>
  328. void BST<T>::MorrisInorder() 
  329. {
  330.     BSTNode<T>* p = root, * tmp;
  331.     while (p != 0)
  332.     {
  333.         if (p->m_left == 0) 
  334.         {
  335.             visit(p);
  336.             p = p->m_right;
  337.         }
  338.         else 
  339.         {
  340.             tmp = p->m_left;
  341.             while (tmp->m_right != 0 && tmp->m_right != p)  
  342.                 tmp = tmp->m_right;   
  343.                 
  344.             if (tmp->m_right == 0) 
  345.             {   
  346.                 tmp->m_right = p;    
  347.                 p = p->m_left;       
  348.             }
  349.             else 
  350.             {                   
  351.                 visit(p);      
  352.                 tmp->m_right = 0;    
  353.                 p = p->m_right;      
  354.             }                      
  355.         }
  356.     }
  357. }
  358.  
  359. // 后序遍历，非递归Morris遍历算法实现
  360. template<class T>
  361. void BST<T>::MorrisPostorder() 
  362. {
  363.     BSTNode<T>* p = new BSTNode<T>(), * tmp, * q, * r, * s;
  364.     p->m_left = root;
  365.     while (p != 0)
  366.     {
  367.         if (p->m_left == 0)
  368.             p = p->m_right;
  369.         else
  370.         {
  371.             tmp = p->m_left;
  372.             while (tmp->m_right != 0 && tmp->m_right != p)  
  373.                 tmp = tmp->m_right;   
  374.  
  375.             if (tmp->m_right == 0) 
  376.             {   
  377.                 tmp->m_right = p;     
  378.                 p = p->m_left;        
  379.             }
  380.             else
  381.             {             
  382.                 for (q = p->m_left, r = q->m_right, s = r->m_right;
  383.                     r != p; q = r, r = s, s = s->m_right)
  384.                     r->m_right = q;
  385.  
  386.                 for (s = q->m_right; q != p->m_left;
  387.                     q->m_right = r, r = q, q = s, s = s->m_right)
  388.                     visit(q);
  389.  
  390.                 visit(p->m_left);    
  391.                 tmp->m_right = 0;     
  392.                 p = p->m_right;      
  393.             }                   
  394.         }
  395.     }
  396. }
  397.  
  398. // 广度优先遍历：从上到下，从左到右
  399. template<class T>
  400. void BST<T>::breadthFirst() 
  401. {
  402.     Queue<BSTNode<T>*> queue;
  403.     BSTNode<T>* p = root;
  404.     if (p != 0) 
  405.     {
  406.         queue.enqueue(p);
  407.         while (!queue.empty()) 
  408.         {
  409.             p = queue.dequeue();
  410.             visit(p);
  411.             if (p->m_left != 0)
  412.                 queue.enqueue(p->m_left);
  413.             if (p->m_right != 0)
  414.                 queue.enqueue(p->m_right);
  415.         }
  416.     }
  417. }
  418.  
  419. // 插入插入一个元素，非递归实现
  420. template<class T>
  421. bool BST<T>::insert(const T& m_el) 
  422. {
  423.     BSTNode<T>* p = root, * prev = 0;
  424.     while (p != 0) 
  425.     {  
  426.         prev = p;
  427.         if (m_el < p->m_el)
  428.             p = p->m_left;
  429.         else if (m_el > p->m_el)
  430.             p = p->m_right;
  431.         else
  432.         {
  433.             cout << "BST<T>::insert 插入相同的数据，插入失败" << endl;
  434.             return false;
  435.         }
  436.     }
  437.  
  438.     if (root == 0)    
  439.         root = new BSTNode<T>(m_el);
  440.     else if (m_el < prev->m_el)
  441.         prev->m_left = new BSTNode<T>(m_el);
  442.     else 
  443.         prev->m_right = new BSTNode<T>(m_el);
  444.  
  445. 	return true;
  446. }
  447.  
  448. // 插入插入一个元素，递归实现
  449. template<class T>
  450. bool BST<T>::recursiveInsert(BSTNode<T>*& p, const T& m_el) 
  451. {
  452.     if (p == 0)
  453.         p = new BSTNode<T>(m_el);
  454.     else if (m_el < p->m_el)
  455.         recursiveInsert(p->m_left, m_el);
  456.     else if (m_el > p->m_el)
  457.         recursiveInsert(p->m_right, m_el);
  458. 	else
  459.     {
  460.         cout << "BST<T>::recursiveInsert 插入相同的数据，插入失败" << endl;
  461.         return false;
  462.     }
  463.     
  464. 	return true; 
  465. }
  466.  
  467.  
  468. // 查找合并删除
  469. template<class T>
  470. void BST<T>::findAndDeleteByMerging(const T& m_el)
  471. {
  472.     BSTNode<T>* p = root, * prev = 0;
  473.     while (p != 0 && p->m_el != m_el)
  474.     {
  475.         prev = p;
  476.         if (m_el < p->m_el)
  477.             p = p->m_left;
  478.         else
  479.             p = p->m_right;
  480.     }
  481.  
  482.     if (p != 0 && p->m_el == m_el)
  483.     {
  484.         if (p == root)
  485.             deleteByMerging(root);
  486.         else if (prev->m_left == p)
  487.             deleteByMerging(prev->m_left);
  488.         else
  489.             deleteByMerging(prev->m_right);
  490.     }
  491.     else if (root != 0)
  492.         cout << "m_el " << m_el << " is not in the tree\n";
  493.     else 
  494.         cout << "the tree is empty\n";
  495. }
  496.  
  497. // 查找合并删除
  498. template<class T>
  499. void BST<T>::deleteByMerging(BSTNode<T>*& node)
  500. {
  501.     if (node == nullptr)
  502.         return;
  503.  
  504.     BSTNode<T>* tmp = node;
  505.     if (node->m_right == nullptr)           // node 没有右节点
  506.         node = node->m_left;
  507.     else if (node->m_left == nullptr)       // node 没有左节点
  508.         node = node->m_right;
  509.     else
  510.     {
  511.         tmp = node->m_left;
  512.         while (tmp->m_right != nullptr)
  513.             tmp = tmp->m_right;
  514.  
  515.         tmp->m_right = node->m_right;
  516.         tmp = node;
  517.         node = node->m_left;
  518.     }
  519.  
  520.     delete tmp;
  521. }
  522.  
  523. // 查找复制删除
  524. template<class T>
  525. void BST<T>::findAndDeleteByCopying(const T& m_el) 
  526. {
  527.     BSTNode<T>* p = root, * prev = 0;
  528.     while (p != 0 && p->m_el != m_el) 
  529.     {
  530.         prev = p;
  531.         if (m_el < p->m_el)
  532.             p = p->m_left;
  533.         else 
  534.             p = p->m_right;
  535.     }
  536.  
  537.     if (p != 0 && p->m_el == m_el)
  538.     {
  539.         if (p == root)
  540.             deleteByCopying(root);
  541.         else if (prev->m_left == p)
  542.             deleteByCopying(prev->m_left);
  543.         else
  544.             deleteByCopying(prev->m_right);
  545. 	}
  546.     else if (root != 0)
  547.         cout << "m_el " << m_el << " is not in the tree\n";
  548.     else 
  549.         cout << "the tree is empty\n";
  550. }
  551.  
  552. // 查找复制删除
  553. template<class T>
  554. void BST<T>::deleteByCopying(BSTNode<T>*& node) 
  555. {
  556.     if (node == nullptr)
  557.         return;
  558. 	
  559.     BSTNode<T>* previous, * tmp = node;
  560.     if (node->m_right == nullptr)                  // node 没有右节点
  561.         node = node->m_left;
  562.     else if (node->m_left == nullptr)              // node 没有左节点
  563.         node = node->m_right;
  564.     else 
  565.     {
  566.         tmp = node->m_left;							// node 有左、右节点
  567.         previous = node;                   
  568.         while (tmp->m_right != nullptr)
  569.         {         
  570.             previous = tmp;
  571.             tmp = tmp->m_right;
  572.         }
  573.  
  574.         node->m_el = tmp->m_el;                
  575.         if (previous == node)
  576.             previous->m_left = tmp->m_left;
  577.         else 
  578.             previous->m_right = tmp->m_left;   
  579.     }
  580.  
  581.     delete tmp;                            
  582. }

 

 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/572354
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号