笔试算法题（31）：将有序数组转换成BST表示 & 线段树的应用

出题：要求将一个有序整数数组转换成最小深度的Binary Search Tree表示；

分析：由于需要是最小深度，所以BST应保持平衡，左右节点数大致相当，并且BST中当前根节点大于所有其左子树中的元素，小于所有其右子树中的元素。对于排序数组而言，中间元素必然作为根节点，然后递归对由中间元素分割的左右数组部分进行处理；

解题：

 struct Node {
         int value;
         Node *left;
         Node *right;
 };

 Node* Array2BST(int *array, int i, int j) {
         /**
          * 如果上下范围相同说明只有一个节点
          * 直接返回
          * */
         if(i==j) {
                 Node *root=new Node();
                 root->value=array[i];
                 root->left=NULL;
                 root->right=NULL;
                 return root;
         }

         int m=(i+j)/;
         Node *root=new Node();
         root->value=array[m];
         /**
          * 由于(i+j)/2是向下取整，所以i+1=j时
          * m=i，这个时候root的左子树为空
          * */
         if(m==i)
                 root->left=NULL;
         else
                 root->left=Array2BST(array, i, m-);
         root->right=Array2BST(array, m+, j);

         return root;
 }

出题：要求实现函数：
　　size_t foo(unsigned int *a1, size_t a1l, unsigned int *a2, size_t a2l)
　　其中a1和a2都是无符号数组，a1l和a2l是对应数组的长度，并且都为偶数。
　　无符号数分成两个数字组成的多个数字区间，如下：
　　　　a1为0,1,3,8,10,20
　　　　a2为0,1,20,50,4,5
　　则a1表示的区间为[0,1],[3,8],[10,20]
　　则a2表示的区间为[0,1],[20,50],[4,5]
　　所以a1和a2重叠的部分为[0,1],[4,5]，长度为2
　　foo函数用于求给定区间数组a1和a2的重叠长度
　　注意：a1和a2长度不超过100万，并且同一个区间数组内部可能出现重叠

分析：

• 线段树（Interval Tree）是BST的一种特例，它将一个区间划分成单元区间（最小元素），每个单元区间对应一个叶子节点；对于一个内部节点而言[a,b]，它的左子树节 点表示为[a,(a+b)/2]，它的右子树节点表示为[(a+b)/2+1,b]。由于每次划分都是对等划分所以IT为平衡树，最终子节点数为N（对于 整数区间而言就是所有数字分布的范围大小），深度为logN +1。快速确定某一个元素在哪些区间节点出现，时间复杂度为O(NlogN)，但是空间复杂度为O(N)；
• 确定区间数组A和B中差值较小的的最大值m和最小值n（假设数组A的区间范围更小，O(A)），并构建区间[m,n]的线段树（O(AlogA)），这样 可以节省空间，如果区间范围较大，可以使用离散的建树方法针对区间元素出现的范围构建多棵区间树，或者使用压缩的方法减少区间节点；
• 在线段树中标记在A中出现的区间节点（O(AlogA)）；将B的区间节点插入线段树（实际上并没有新节点的插入，只是检测是否有A标记过的节点），如果有A区间节点标记的节点，则说明有重复（O(BlogA)）。总时间复杂度O(AlogA)；

解题：

 struct Interval {
         int left;
         int right;
         int count;
 };
 /**
  * 此函数用于创建线段树的基本结构
  * */
 void ConstructIT(int min, int max, Interval** InterTree, int index) {
         /**
          * 构建当前节点
          * index用于索引InterTree中当前元素的位置
          * 遵循父节点为i，则做有子节点分别为2*i, 2*i+1
          * */
         Interval *temp=new Interval();
         temp->count=;
         temp->left=min;
         temp->right=max;
         InterTree[index]=temp;
         /**
          * 如果min和max相等，则说明已经到叶子节点
          * */
         if(min==max)
                 return;
         /**
          * 分别递归创建左右子节点
          * */
         int middle=(min+max)/;
         ConstructIT(min,middle,InterTree,index*);
         ConstructIT(middle+,max,InterTree,index*+);
 }
 /**
  * 此函数用于注入线段树的线段标记信息
  * */
 void InsertInfor(int min, int max, Interval** InterTree, int index) {
         int middle=(InterTree[index]->left + InterTree[index]->right)/;
         if(max<middle) {
                 InsertInfor(min, max, InterTree, *index);
         } else if(min>middle) {
                 InsertInfor(min, max, InterTree, *index+);
         } else if(min==InterTree[index]->left &&
                         max==InterTree[index]->right) {
                 InterTree[index]->count+=;
                 return;
         } else {
                 InsertInfor(min, middle, InterTree, *index);
                 InsertInfor(middle+, max, InterTree, *index+);
         }
 }
 /**
  * 此函数用于检查覆盖区间，注意此时的min和max可能超出
  * InterTree的范围
  * */
 int CheckInterval(int min, int max, Interval** InterTree, int index) {
         int middle=(InterTree[index]->left + InterTree[index]->right)/;
         if(max<middle) {
                 return CheckInterval(min, max, InterTree, *index);
         } else if(min>middle) {
                 return CheckInterval(min, max, InterTree, *index+);
         } else if(min==InterTree[index]->left &&
                         max==InterTree[index]->right) {
                 if(InterTree[index]->count>)
                         return InterTree[index]->count;
         } else {
                 CheckInterval(min, middle, InterTree, *index);
                 CheckInterval(middle+, max, InterTree, *index+);
         }
 }
 int GetOverlapSize(int *first, int lfirst, int *second, int lsecond) {
         /**
          * 获取first和second数组中各自的最大值与最小值的差值
          * 选取差值较小的一个范围作为线段树的构建区间
          * 节省空间消耗
          * */
         int minf=, maxf=,mins=,maxs=;
         for(int i=;i<lfirst;i+=) {
                 if(maxf<first[i])
                         maxf=first[i];
                 if(minf>first[i])
                         minf=first[i];
         }
         for(int i=;i<lsecond;i+=) {
                 if(maxs<second[i])
                         maxs=second[i];
                 if(mins>second[i])
                         mins=second[i];
         }
         int min=minf,max=maxf;
         int isFirst=true;
         if((max-min)>(maxs-mins)) {
                 min=mins;
                 max=maxs;
                 isFirst=false;
         }
         /**
          * 构建一个数组，数组元素为Interval*类型，
          * 数组大小为线段树节点个数，由于线段树是
          * 完全二叉树，所以节点数肯定为2N-1，N为区间
          * 大小，也为叶节点数
          * */
         Interval *InterTree[*(max-min+)-];
         /**
          * 首先构建线段树的基本结构
          * */
         ConstructIT(min, max, InterTree, );
         /**
          * 然后将线段树范围大小对应的区间数组元素
          * 插入到线段树中，如果区间在线段树之外则
          * 需要特殊处理
          * */
         int *temp=NULL, length=;
         int overlapSize=;
         if(isFirst) {
                 for(int i=;i<lfirst;i+=) {
                         if(first[i]<InterTree[]->left ||
                                         first[i-]>InterTree[]->right)
                                 continue;
                         else if(first[i]==InterTree[]->left ||
                                         first[i-]==InterTree[]->right)
                                 overlapSize++;
                         else
                                 InsertInfor(first[i-],first[i], InterTree, );
                 }
                 temp=second;
                 length=lsecond;
         } else {
                 for(int i=;i<lsecond;i+=) {
                         if(second[i]<InterTree[]->left ||
                                         second[i-]>InterTree[]->right)
                                 continue;
                         else if(second[i]==InterTree[]->left ||
                                         second[i-]==InterTree[]->right)
                                 overlapSize++;
                         else
                                 InsertInfor(second[i-],second[i], InterTree, );
                 }
                 temp=first;
                 length=lfirst;
         }
         /**
          * 顺序将temp中的区间元素插入到InterTree中
          * */

         for(int i=;i<length;i+=) {
                 length+=CheckInterval(temp[i-],temp[i],InterTree,);
         }

 }