zoukankan      html  css  js  c++  java

  • 笔试算法题（58）：二分查找树性能分析（Binary Search Tree Performance Analysis）

    议题：二分查找树性能分析（Binary Search Tree Performance Analysis）

    分析：

    • 二叉搜索树（Binary Search Tree，BST）是一颗典型的二叉树，同时任何节点的键值大于等于该节点左子树中的所有键值，小于等于该节点右子树中的所有键值，并且每个节点域中保存 一个记录以其为根节点的子树中所有节点个数的属性，这个属性可用于支持贪婪算法的实现；

    • 二叉搜索树的建立是在树的底部添加新的元素，搜索即从根元素开始到达树底部的一条路径，插入和搜索相似（注意对重复键的处理），排序按照节点访问方式不同有前序、中序、后序三种；

    • 二叉搜索树算法的运行时间取决于树的形状，最好情况下根节点与每个外部节点间有㏒N个节点，此时树完全平衡，最坏情况下搜索路径上有N个节点。由于创建二 叉搜索树的时候，第一个插入的元素总是作为根元素，所以元素插入的顺序决定树的形状。在随机情况下，极度平衡和极度不平衡的树都很少出现，所以这种情况下 二叉搜索树算法有着良好的运行情况；

    • 所以平均情况下，N个随机生成的BST树种，一次搜索，插入大约需要1.39㏒N此比较。如果键值不是随机出现，则二叉搜索树退化为N个节点的链表，一次操作为线性O(N)运行时间；

    • 使用BST树存储文件中每一个文本串，基于字符串的排序使得搜索变得容易；

    • BottomUp插入策略：按照前序策略遍历整个树结构，首先查看当前节点是否为NULL，然后与关键值比较查看是否为目标值，不是的话就分别针对左右子 树递归调用搜索算法，然后进入下一个结构，注意在递归调用之间的衔接是由返回一个节点来实现的，所以如果已经到达树底部，则返回一个新节点，这个节点正好 位于上一级的子树连接上，这样正好形成整个树结构；

    • TopDown插入策略：在BottomUp插入策略的基础上，将新插入的节点在递归回溯的时候逐层旋转，知道根节点的位置；使用基于递归插入操作和旋转 操作的策略可以使得最近插入的元素接近BST树的顶部，同时保持树的平衡性。这种插入方式称为从根部插入，实现策略：首先使用普通递归插入将在树底部找到 一个合适的位置插入新的节点，然后使用旋转操作将这个新加入的节点旋转到根节点处，不仅可以保持树的平衡，而且由于最近插入的项被使用的概率大，靠近根节 点则加速搜索效率；

    • 旋转操作：BST树中从根部插入新节点：首要考虑的就是是否能够保持BST树的性质。现在使用基于旋转（Rotation）的转换策略，使得BST树保持原有性质。旋转实质上是交换根节点和一个孩子的角色，同时保持各节点的顺序

       

    • 选择第Kth个值（最小或者最大）：利用Node节点中的count标记（此标记说明以当前节点为根节点的子树的所有节点数），可以快速查找给定的序列中 第Kth个最小或者最大值；当然前提是将给定的序列扩建成BST；从根节点开始，首先检查其左子树中节点个数，如果正好为K个则返回根节点本身，如果大于 K个节点，则对左子树递归调用算法，如果小于K个节点，则说明第K个最小键在根节点的右子树中，变成查找右子树中第K-t-1个最小键的项（t为左子树所 有节点，1为根节点自身）；

    • BST树的节点删除操作：被删除的节点可以有三种情况，没有子节点，有一个子节点，有两个子节点。第一种情况可直接删除；第二种情况需要临时存储子节点的 索引，并让被删除节点的父节点指向这个这个索引；第三种情况需要维护BST树的性质，所以一般性策略是选择右子树中最小的元素作为新的根节点（右子树中最 小的元素出现在最左边，所以它至多只有一个子节点，可容易删除），然而有时候也会选择左子树中的最大元素作为新的根节点（由于在左右子树中任意选择新的节 点作为新的根节点，所以可能造成BST树的不平衡）；

    样例：

      1 struct Node {
  2         int value;
  3         int count;
  4         Node *left;
  5         Node *right;
  6         Node(int v, int c=1, Node* l=NULL, Node* r=NULL):
  7                                 count(c), value(v), left(l), right(r) {
  8 
  9         }
 10 };
 11 /**
 12  * 对root节点进行右旋转操作，也就是：
 13  * 1. 让root原来的左孩子变成newRoot；
 14  * 2. 让root变成newRoot的右子节点；
 15  * 3. 让root原来的左孩子的的右子节点变成root的左子节点
 16  * */
 17 Node* rightRotate(Node *root) {
 18         Node *newRoot=root->left;
 19         root->left=root->left->right;
 20         newRoot->right=root;
 21         return newRoot;
 22 }
 23 /**
 24  * 对root节点进行左旋转操作，也就是：
 25  * 1. 让root原来的右孩子变成newRoot；
 26  * 2. 让root变成newRoot的左子节点；
 27  * 3. 让root原来的右孩子的左子节点变成root的右子节点
 28  * */
 29 Node* leftRotate(Node *root) {
 30         Node *newRoot=root->right;
 31         root->right=root->right->left;
 32         newRoot->left=root;
 33         return newRoot;
 34 }
 35 
 36 Node* binaryTreeSearch(Node *root, int target) {
 37 
 38         if(root==NULL)
 39                 return NULL;
 40 
 41         if(target>root->value)
 42                 return binaryTreeSearch(root->right, target);
 43         else if(target<root->value)
 44                 return binaryTreeSearch(root->left, target);
 45         else
 46                 return root;
 47 }
 48 
 49 Node* binaryTreeInsert(Node *root, int target) {
 50 
 51         if(root==NULL) {
 52                 return new Node(target);
 53         }
 54 
 55         if(target>root->value)
 56                 root->right=binaryTreeInsert(root->right, target);
 57         else if(target<root->value)
 58                 root->left=binaryTreeInsert(root->left, target);
 59 
 60         return root;
 61 }
 62 /**
 63  * 这样可以将新插入的元素旋转到为root；
 64  * 不仅可以保持BST的平衡性，而且可以保证
 65  * 新插入的元素的最大访问延迟；
 66  * */
 67 Node* binaryTreeInsertTopDown(Node *root, int target) {
 68 
 69         if(root==NULL) {
 70                 return new Node(target);
 71         }
 72 
 73         if(target>root->value) {
 74                 root->right=binaryTreeInsert(root->right, target);
 75                 root=leftRotate(root);
 76         }
 77         else if(target<root->value) {
 78                 root->left=binaryTreeInsert(root->left, target);
 79                 root=rightRotate(root);
 80         }
 81 
 82         return root;
 83 }
 84 
 85 Node* binaryTreeInsertWithCount(Node *root, int target) {
 86 
 87         if(root==NULL) {
 88                 return new Node(target);
 89         }
 90 
 91         if(target>root->value)
 92                 root->right=binaryTreeInsert(root->right, target);
 93         else if(target<root->value)
 94                 root->left=binaryTreeInsert(root->left, target);
 95         root->count++;
 96         return root;
 97 }
 98 /**
 99  * 从一个序列中选定第K大的数字，
100  * */
101 int binaryTreeSelect(Node *root, int k) {
102         /**
103          * 如果当前root为NULL，则选择失败
104          * */
105         if(root==NULL) {
106                 printf("
find nothing-_-
");
107                 return -1;
108         }
109         /**
110          * 如果root的左子节点为NULL
111          * */
112         if(root->left==NULL) {
113                 if(k==1)
114                         return root->value;
115                 return binaryTreeSelect(root->right, k-1);
116         }
117         /**
118          * 如果root的左子节点不为NULL；
119          * 1. 如果K<=leftCount，则Kth个节点在左子树中
120          * 2. 如果K==leftCount+1，则kth个节点就是root自身
121          * 3. 如果k>leftCount+1，则Kth个节点就是右子树中的k-1-leftCount个节点
122          * */
123         int leftCount=root->left->count;
124         if(leftCount>=k)
125                 return binaryTreeSelect(root->left, k);
126         else if(leftCount+1==k)
127                 return root->value;
128         else
129                 return binaryTreeSelect(root->right, k-1-leftCount);
130 }
131 
132 /**
133  * 将指定的元素target旋转到根节点
134  * */
135 Node* binaryTreeRotate(Node *root, int target) {
136 
137         if(root==NULL)
138                 return NULL;
139 
140         if(target>root->value) {
141                 root->right=binaryTreeRotate(root->right,target);
142                 leftRotate(root);
143         } else if(target<root->value) {
144                 root->left=binaryTreeRotate(root->left,target);
145                 rightRotate(root);
146         }
147 
148         return root;
149 }
150 /**
151  * 此方法寻找root的左子树中具有最大value的子节点，也就是最‘左边’的子节点；
152  * */
153 Node* subtreeRightMaximum(Node *root) {
154         Node *cur=root;
155         Node *pre;
156         while(cur!=NULL) {
157                 pre=cur;
158                 cur=cur->left;
159         }
160         return pre;
161 }
162 /**
163  * 此方法寻找root的右子树中具有最大value的子节点，也就是最‘左边’的子节点；
164  * */
165 Node* subTreeLeftMaximum(Node* root) {
166         Node *cur=root;
167         Node *pre;
168         while(cur!=NULL) {
169                 pre=cur;
170                 cur=cur->right;
171         }
172         return pre;
173 }
174 
175 Node* binaryTreeDelete(Node *root, int target) {
176 
177         if(root==NULL)
178                 return NULL;
179         Node *temp;
180         Node *newRoot;
181         /**
182          * 如果target比root->value大，则说明其位于root的
183          * 右子树，则继续递归
184          * 如果target比root->value小，则说明其位于root的
185          * 左子树，则继续递归
186          * 如果target等于root->value，则说明当前节点root
187          * 就是需要删除的节点，然后分三种情况讨论：
188          * 1. 如果root没有左右子节点
189          * 2. 如果root只有左节点或者只有右节点
190          * 3. 如果root德尔左右子节点都存在；
191          * */
192         if(target>root->value)
193                 root->right=binaryTreeDelete(root->right, target);
194         else if(target<root->value)
195                 root->left=binaryTreeDelete(root->left, target);
196         else {
197                 if(root->left==NULL && root->right) {
198                         delete root;
199                         return NULL;
200                 } else if(root->left==NULL) {
201                         temp=root->right;
202                         delete root;
203                         return temp;
204                 } else if(root->right==NULL) {
205                         temp=root->left;
206                         delete root;
207                         return temp;
208                 }
209                 /**
210                  * 左右子节点都存在的情况，需要从左右子树中寻找下一个根节点；
211                  * 这里是从右子树中选取最小的一个节点作为新的根节点；
212                  * */
213                 newRoot=subtreeRightMaximum(root->right);
214                 /**
215                  * 由于右子树中最小的节点必然至多只有一个右节点，所以其删除操作
216                  * 较为简单；然后将其的左右子树替换成当前的左右子树；
217                  * */
218                 newRoot=binaryTreeDelete(root->right, newRoot->value);
219                 newRoot->right=root->right;
220                 newRoot->left=root->left;
221                 delete root;
222         }
223 
224 }

    补充：

    • BST中搜索和插入的策略都是一样的，从传入的树节点开始，首先判断其是否为NULL，如果是的话对于搜索来讲表示失败，对于插入来讲表示需要插入新的节 点；如果不是NULL的话，对于搜索来讲比对是否为目标值，然后针对左右子树递归调用，对于插入来讲比对是否相同，表示树中已经有同样的节点算法说明；

    • BST树的构建和搜索也使用同样的遍历策略，所以插入与搜索一样容易实现；旋转可用于防止树变得不平衡，实现删除，合并和其他操作的辅助操作，BST树的 插入操作可以通过在树的底部插入新元素，然后使用左旋和右旋将新元素带到根节点处，防止树的不平衡状态。每次BST搜索命中的项也可以通过旋转带到根节点 处；

    • 使用BST树进行选择算法最大的缺点就是计数域的出现导致额外的内存占用，树结构改变时需要额外的维护操作，同时我们可以对查找到的节点元素使用旋转操作，将其放到根节点的位置，下次使用的时候就能很快定位；


    BST树的性能特征总结：

    • 二叉搜索树算法的运行时间取决于树的形状，最好情况下树可能完全平衡，这样一次搜索过程就是一条路径的长度㏒N，最差情况下树退化为链表，这样一次搜索过程路径长度可能为N；

    • 使用插入操作构建BST树的过程中，越是前面的节点对树最终形状的影响越是大，第一个元素就是树根，对于随机序列来讲，最坏情况出现的概率很小，所以平均情况能保持较好的运行时间，㏒N；

    • 使用索引项来表示搜索节点，避免动态分配内存。当序列以随机序列插入时，生成完全平衡树的概率很小，但二叉树路径的长度和树的高度与BST的搜索开销联系 紧密。平均情况下一棵根据N个随机键生成的BST树中，搜索命中（插入和搜索失败）大约需要1.39㏒N次比较。最坏情况下，可能需要N此比较（也就是顺 序搜索）；
  • 相关阅读:
    如何在Ubuntu Server 18.04上安装Microsoft的Procmon
    如何在Ubuntu 20.04上安装Wine 5.0
    如何在Kali Linux 2020中启用SSH服务
    如何在Ubuntu 20.04 LTS Focal Fossa上安装Apache Groovy
    如何使用命令在Ubuntu 20.04 Linux上安装Vmware Tools
    在Ubuntu 20.04 LTS Focal Fossa上安装Zabbix Agent
    hdu 2089 不要62
    hdu 2093 成绩排名
    hdu 2104 hide handkerchief
    leetcode147对链表进行插入排序
  • 原文地址：https://www.cnblogs.com/leo-chen-2014/p/3762132.html
Copyright © 2011-2022 走看看