二叉搜索数

16 篇文章 0 订阅

1、构建平衡二叉搜索树

TreeNode* sortedArrayToBST(vector<int>& nums, int start, int end){
        if(end<=start) return NULL; 
        int mid=(end+start)/2;
        TreeNode* root=new TreeNode(nums[mid]);
        root->left=sortedArrayToBST(nums, start, mid);
        root->right=sortedArrayToBST(nums, mid+1,end);
        return root;
    }

摘要:

  本章介绍了二叉查找树的概念及操作。主要内容包括二叉查找树的性质,如何在二叉查找树中查找最大值、最小值和给定的值,如何找出某一个元素的前驱和后继,如何在二叉查找树中进行插入和删除操作。在二叉查找树上执行这些基本操作的时间与树的高度成正比,一棵随机构造的二叉查找树的期望高度为O(lgn),从而基本动态集合的操作平均时间为θ(lgn)。

1、二叉查找树

  二叉查找树是按照二叉树结构来组织的,因此可以用二叉链表结构表示。二叉查找树中的关键字的存储方式满足的特征是:设x为二叉查找树中的一个结点。如果y是x的左子树中的一个结点,则key[y]≤key[x]。如果y是x的右子树中的一个结点,则key[x]≤key[y]。根据二叉查找树的特征可知,采用中根遍历一棵二叉查找树,可以得到树中关键字有小到大的序列。http://www.cnblogs.com/Anker/archive/2013/01/27/2878594.html介绍了二叉树概念及其遍历。一棵二叉树查找及其中根遍历结果如下图所示:


书中给出了一个定理:如果x是一棵包含n个结点的子树的根,则其中根遍历运行时间为θ(n)。

问题:二叉查找树性质与最小堆之间有什么区别?能否利用最小堆的性质在O(n)时间内,按序输出含有n个结点的树中的所有关键字?

2、查询二叉查找树

  二叉查找树中最常见的操作是查找树中的某个关键字,除了基本的查询,还支持最大值、最小值、前驱和后继查询操作,书中就每种查询进行了详细的讲解。

(1)查找SEARCH

  在二叉查找树中查找一个给定的关键字k的过程与二分查找很类似,根据二叉查找树在的关键字存放的特征,很容易得出查找过程:首先是关键字k与树根的关键字进行比较,如果k大比根的关键字大,则在根的右子树中查找,否则在根的左子树中查找,重复此过程,直到找到与遇到空结点为止。例如下图所示的查找关键字13的过程:(查找过程每次在左右子树中做出选择,减少一半的工作量)


书中给出了查找过程的递归和非递归形式的伪代码:

[plain]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. TREE_SEARCH(x,k)  
  2.   if x=NULL or k=key[x]  
  3.       then return x  
  4.   if(k<key[x])  
  5.       then return TREE_SEARCH(left[x],k)  
  6.    else  
  7.       then return TREE_SEARCH(right[x],k)  

[plain]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. ITERATIVE_TREE_SEARCH(x,k)  
  2.   while x!=NULL and k!=key[x]  
  3.       do if k<key[x]  
  4.               then x=left[x]  
  5.            else  
  6.               then x=right[x]  
  7.    return x  

(2)查找最大关键字和最小关键字

  根据二叉查找树的特征,很容易查找出最大和最小关键字。查找二叉树中的最小关键字:从根结点开始,沿着各个节点的left指针查找下去,直到遇到NULL时结束。如果一个结点x无左子树,则以x为根的子树中,最小关键字就是key[x]。查找二叉树中的最大关键字:从根结点开始,沿着各个结点的right指针查找下去,直到遇到NULL时结束。书中给出了查找最大最小关键字的伪代码:

1 TREE_MINMUM(x)
2    while left[x] != NULL
3       do x=left[x]
4    return x
1  TREE_MAXMUM(x)
2     while right[x] != NULL
3          do x= right[x]
4      return x

(3)前驱和后继

  给定一个二叉查找树中的结点,找出在中序遍历顺序下某个节点的前驱和后继。如果树中所有关键字都不相同,则某一结点x的前驱就是小于key[x]的所有关键字中最大的那个结点,后继即是大于key[x]中的所有关键字中最小的那个结点。根据二叉查找树的结构和性质,不用对关键字做任何比较,就可以找到某个结点的前驱和后继。

  查找前驱步骤:先判断x是否有左子树,如果有则在left[x]中查找关键字最大的结点,即是x的前驱。如果没有左子树,则从x继续向上执行此操作,直到遇到某个结点是其父节点的右孩子结点。例如下图查找结点7的前驱结点6过程:



    查找后继步骤:先判断x是否有右子树,如果有则在right[x]中查找关键字最小的结点,即使x的后继。如果没有右子树,则从x的父节点开始向上查找,直到遇到某个结点是其父结点的左儿子的结点时为止。


书中给出了求x结点后继结点的伪代码:

[html]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. TREE_PROCESSOR(x)  
  2.     if right[x] != NULL  
  3.         then return TREE_MINMUM(right(x))  
  4.     y=parent[x]  
  5.     while y!= NULL and x ==right[y]  
  6.            do x = y  
  7.                y=parent[y]  
  8.     return y  

定理:对一棵高度为h的二叉查找,动态集合操作SEARCH、MINMUM、MAXMUM、SUCCESSOR、PROCESSOR等的运行时间均为O(h)。

3、插入和删除

  插入和删除会引起二叉查找表示的动态集合的变化,难点在在插入和删除的过程中要保持二叉查找树的性质。插入过程相当来说要简单一些,删除结点比较复杂。

(1)插入

  插入结点的位置对应着查找过程中查找不成功时候的结点位置,因此需要从根结点开始查找带插入结点位置,找到位置后插入即可。下图所示插入结点过程:


书中给出了插入过程的伪代码:

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. TREE_INSERT(T,z)  
  2.     y = NULL;  
  3.     x =root[T]  
  4.     while x != NULL  
  5.         do y =x  
  6.             if key[z] < key[x]  
  7.                  then x=left[x]  
  8.                  else  x=right[x]  
  9.      parent[z] =y  
  10.      if y=NULL  
  11.         then root[T] =z  
  12.         else if key[z]>key[y]  
  13.                    then  keft[y]  = z  
  14.                    else   right[y] =z  

插入过程运行时间为O(h),h为树的高度。

(2)删除

  从二叉查找树中删除给定的结点z,分三种情况讨论:


<1>结点z没有左右子树,则修改其父节点p[z],使其为NULL。删除过程如下图所示:


<2>如果结点z只有一个子树(左子树或者右子树),通过在其子结点与父节点建立一条链来删除z。删除过程如下图所示:


<3>如果z有两个子女,则先删除z的后继y(y没有左孩子),在用y的内容来替代z的内容


书中给出了删除过程的伪代码:

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. TREE_DELETE(T,z)  
  2.     if left[z] ==NULL or right[z] == NULL  
  3.        then y=z  
  4.        else  y=TREE_SUCCESSOR(z)  
  5.    if left[y] != NULL  
  6.        then x=left[y]  
  7.        else  x=right[y]  
  8.    if x!= NULL  
  9.        then parent[x] = parent[y]  
  10.    if p[y] ==NULL  
  11.       then root[T] =x  
  12.       else if y = left[[prarnt[y]]  
  13.                   then left[parent[y]] = x  
  14.                   else  right[parent[y]] =x  
  15.     if y!=z  
  16.         then key[z] = key[y]  
  17.               copy y's data into z  
  18.      return y  

定理:对高度为h的二叉查找树,动态集合操作INSERT和DELETE的运行时间为O(h)。

4、实现测试

  采用C++语言实现一个简单的二叉查找树,支持动态集合的基本操作:search、minmum、maxmum、predecessor、successor、insert和delete。设计的二叉查找树结构如下所示:

[html]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. template <class T>  
  2. class  BinarySearchTreeNode  
  3. {  
  4. public:  
  5.     T elem;  
  6.     struct BinarySearchTreeNode<T> *parent;  
  7.     struct BinarySearchTreeNode<T>* left;  
  8.     struct BinarySearchTreeNode<T>* right;  
  9. };  
  10.   
  11.   
  12. template <class T>  
  13. class BinarySearchTree  
  14. {  
  15. public:  
  16.     BinarySearchTree();  
  17.     void tree_insert(const T& elem);  
  18.     int  tree_remove(const T& elem );  
  19.     BinarySearchTreeNode<T>* tree_search(const T& elem)const;  
  20.     T tree_minmum(BinarySearchTreeNode<T>* root)const;  
  21.     T tree_maxmum(BinarySearchTreeNode<T>* root)const;  
  22.     T tree_successor(const T& elem) const;  
  23.     T tree_predecessor(const T& elem)const;  
  24.     int empty() const;  
  25.     void inorder_tree_walk()const;  
  26.     BinarySearchTreeNode<T>* get_root()const {return root;}  
  27. private:  
  28.     BinarySearchTreeNode<T>* root;  
  29. };  

完整程序:

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


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值