N个数里面找出最大的k个数

题目:给出N个无序的数,然后找出其中最大的k个数

解题思路:

         首先测试数据有可能会有一亿个数,数据量特别的大,数据库不可能存储这么多的数据。如果直接sort排序,NlogN时间复杂度实在是太高,大于10^9。我们可以考虑对数据进行分块读取,每次读取的数据块大小应大于k

         不如先假设第一次读取的数据块前k个数最大,然后把k个数建成最小二叉堆。然后从第k+1个数开始,每个数都与堆顶的数值进行比较,如果数字i大于堆顶则把堆顶的元素的元素替换成i,再调整一次堆。最后读取完数据之后,这个二叉堆里面的元素就是从小到大排序好的最大k个数。

时间复杂度:O(NlogK)

空间复杂度:O(K)

证明过程:

         为什么求最大的k个用的不是最大堆,而是最小堆?最大堆堆顶的元素是最大的,往下的子树越来越小,把N个数建成最大堆,那么堆顶往下的k个数就是最大的k个数。但是时间复杂度O(NlogN)和空间复杂度O(N)太高!

         排序时间复杂度很高,是因为进行了很多没有用的判断,我们只需要取最大的k个数,而排序则把N个数都从小到大排序好了。建立一个k个数的最小堆,假设堆里面的元素是最大的,当然只是假设。如果从M+1N这些数只要有数大于最小堆堆顶的数,那么假设就不成立,堆顶那个数就不符合,自然把它去掉,把新的数加进来,再重新调整堆,使得堆顶的元素最小。

         为什么要用最小堆呢?因为每次查找这k个数里面的最小的那个数就是堆顶,时间复杂度是O1)。如果直接用数组来存储这k个数,虽然查找的时间复杂度是logN,但是当把这个数插入数组的时候,数组比它小其他元素还需要往前平移,所以时间复杂度远远大于logN。由于每次调整堆的时间复杂度是logN。所以最小堆的做法的时间复杂度是

O(NlogK),而空间复杂度只有O(K)

 

代码1  C++的STL库优先队列实现二叉堆

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <algorithm> 
#include <queue> 
using namespace std; 
struct cmp{ 
   bool operator ()(int a,int b) 
   { 
       return a>b; 
   } 
}; 
#define MAX 11000 
int a[MAX]; 
using namespace std; 
priority_queue<int,vector<int>,cmp>q; 
int main() 
{ 
   int n,i,k,m,top; 
   scanf("%d%d",&n,&m); 
     for(i=1;i<=n;i++) 
     { 
          scanf("%d",&k); 
          if(i<=m)   //前m个数入 队列 
          { 
               q.push(k); 
               if(i==m)  //纪录前m个数中最小的数 
                    top=q.top(); 
          } 
          else 
          { 
               if(k>top)  //如果新加入的数大于队列中最小的数则出队 
               { 
                    q.pop(); 
                    q.push(k); 
                    top=q.top(); 
               } 
          } 
     } 
     k=0; 
     while(!q.empty())  //这样处理是为了最后一个数打印时没有空格 
     { 
          a[k++]=q.top(); 
          q.pop(); 
     } 
     for(i=0;i<k;i++) 
     { 
          printf("%d",a[i]); 
          if(i==k-1) 
               printf("\n"); 
          else 
               printf(" "); 
     } 
   return 0; 
}


 

代码2 (数组实现堆):

#include <stdio.h> 
#define MAX 10001 
int a[MAX]; 
void HeapAdjust(int R[],int s,int t)  //筛选函数1 
{ 
   int i,j,temp; 
   temp=R[s]; 
   i=s; 
   for(j=2*i;j<=t;j=2*j) 
   { 
       if(j<t&&R[j]<R[j+1]) 
           j++; 
       if(temp>R[j]) break; 
       R[i]=R[j]; 
       i=j; 
   } 
   R[i]=temp; 
} 

void HeapSort(int R[],int n)   //堆排 
{ 
   int i; 
   for(i=n/2;i>0;i--) 
   { 
       HeapAdjust(R,i,n); 
   } 
   for(i=n;i>1;i--) 
   { 
       R[1]^=R[i]; 
       R[i]^=R[1]; 
       R[1]^=R[i]; 
       HeapAdjust(R,1,i-1); 
   } 
} 

void HeapAdjust2(int R[],int s,int t)   //筛选函数2 
{ 
   int i,j,temp; 
   temp=R[s]; 
   i=s; 
   for(j=2*i;j<=t;j=2*j) 
   { 
       if(j<t&&R[j]>R[j+1]) 
           j++; 
       if(temp<R[j]) break;  //找到比新加入的元素还大的根节点 
       R[i]=R[j]; 
       i=j; 
   } 
   R[i]=temp; 
} 

int main() 
{ 
   int i,k,n,m; 
   scanf("%d%d",&n,&m); 
   for(i=1;i<=m;i++) 
   { 
       scanf("%d",&a[i]); 
   } 
   HeapSort(a,m); 
   for(i=m+1;i<=n;i++) 
   { 
       scanf("%d",&k); 
       if(k>a[1])         //新元素大于堆中最小元素则加入堆 
       { 
           a[1]=k; 
           HeapAdjust2(a,1,m);   //从根节点开始重新筛选一次 
       } 
   } 
   HeapSort(a,m); 
   for(i=1;i<=m;i++) 
   { 
       printf("%d",a[i]); 
       if(i==m) 
           printf("\n"); 
       else 
           printf(" "); 
   } 
   return 0; 
}

注:原创文章,转载请注明出处

 

阅读更多
文章标签: 最大k个数
个人分类: STL
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭