小范围排序(C++)

关于算法与数据结构的相关博文:

二叉树相关练习题(C++)
经典排序算法的C++实现
与字符串有关的一些典型问题的C++解法
一些可以用动态规划(DP)算法解决的问题(C++)
排列组合相关笔试面试题(C++)
与概率相关的算法题C++解法(附证明过程)
二分查找的巧妙运用(C++)
位运算在算法题中的使用(C++)
链表相关练习题(C++)
用实例讲解栈和队列(C++)
一些智力题的C++解法
KMP算法相关学习资料
LeetCode经典题目笔记(一)
LeetCode经典题目笔记(二)

1、小范围排序
已知一个几乎有序的数组,几乎有序是指,如果把数组排好顺序的话,每个元素移动的距离可以不超过k,并且k相对于数组来说比较小。
选择改进的堆排序。根据题意,最小值一定在A的前k(0~k-1)个元素内、次小值一定在A的第二组k(1~k)个元素内,以此类推,每次取原数组A的k个元素进行堆排序,然后把堆顶元素放入A的已排序序列中,(0~k-1)排序的堆顶赋值给A[0],(1~k)排序的堆顶赋值给A[1],以此类推。最后剩下A中最后的k个元素(k-n~n-1),进行标准的堆排序,第一次是K个元素的堆,排序后将堆顶赋值给A[n-k],紧接着把堆尾元素赋值给堆顶,再排序,此时只是k-1个元素的堆,依次类推,每次把堆顶元素放入A中已排序序列后,都把堆尾元素赋值到堆顶,同时堆的元素个数减1,直到堆的元素个数为1,整个排序结束。
class  ScaleSort {
public
:
void  heapify( int * B, int  i, int  k) {
         int  j,ex;
        ex = B[i];
        j = 2*i + 1;
         while  (j < k) {
            if (j + 1 < k && B[j + 1] < B[j]) 
                j++;            
            if (B[j] >= ex)  break ;           
            B[i] = B[j];
            i = j;
            j = 2*i + 1;
        }
        B[i] = ex;
         return ;
    }

     vector  sortElement( vector < int > A,  int  n,  int  k) {
        // write code here
         int  m = 0,exc;
        int  *temp =  new
        int [k];
         for  ( int  l = 0;l < k;l++) {
            temp[l] = A[l];
        }
         for  ( int  i = k/2-1;i >= 0;i--)
        heapify(temp,i,k);

         for  ( int  i = k;i < n;i++) {
            A[i-k] = temp[0];
            temp[0] = A[i];
            heapify(temp,0,k);
        }

         for  ( int  j = n-k;j < n;j++) {
            A[j] = temp[0];
            k--;
            temp[0] = temp[k];
            heapify(temp,0,k);
        }

         delete  []temp;
        temp = NULL;
         return  A;
    }
};

2、求一个数组排序后相邻元素之差的最大值,时间复杂度为O(n)、空间复杂度为O(n)
若先排序后求差值则只有桶排序满足时间复杂度,但是桶排序不能满足空间复杂度,桶排序的空间复杂度为O(max-min)。因此要用改进的桶排序但是又没有真正的排序。

①、求出数组A的最大值max和最小值min,并把区间max-min平均分成n份,每份大小为interval,则只需要n+1个桶;
②、用A[i]-min/interval的整数部分确定A[i]该入的桶,并定义三个大小为n+1的数组,bucket记录n+1个桶每个桶的入桶元素个数,max_bucket记录每个桶中最大值,min_bucket记录每个桶中最小值;
③、遍历bucket数组,将后一个桶的最小值min_bucket[j]减去前一个桶的最大值max_bucket[j-1],记录下最大的差值,返回该差值。

class  Gap {
public :
     int  maxGap( vector < int > A,  int  n) {
         int  max = A[0],min = A[0];

        for ( int  i = 1;i < n;i++) {
            if (A[i] > max) max = A[i];
            else
                if (A[i] < min) min = A[i];
        }

         float  interval = ( float )(max - min)/n;

         int  bucket[n+1];
        for ( int  j = 0;j < n+1;j++) 
            bucket[j] = 0;

        
int  max_bucket[n+1],min_bucket[n+1];

        for ( int  i = 0;i < n;i++) {
             int  j = ( int )(A[i]-min)/interval;
            bucket[j]++;
            min_bucket[j] = A[i];
            max_bucket[j] = A[i];
        }

        for ( int  i = 0;i < n;i++) {
             int  j = ( int )(A[i]-min)/interval;
            if (A[i] > max_bucket[j]) max_bucket[j] = A[i]; 
            if (A[i] < min_bucket[j]) min_bucket[j] = A[i];
        }

         int  maxGap = 0;
        for ( int  i = 0,j = 1;j < n+1;j++) {
            if (bucket[j] > 0) {
                if (min_bucket[j]-max_bucket[i] > maxGap) 
                    maxGap = min_bucket[j] - max_bucket[i];
                i = j;
            }                
        }
         return  maxGap;
    }
};

你可能感兴趣的:(数据结构与基本算法,C/C++)