找出N个数中最小的k个数问题(复杂度O(N*logk))

这是一个经典的算法题，下面给出的算法都在给定的数组基础上进行，好处时不用分配新的空间，坏处是会破坏原有的数组，可以自己分配新的空间以避免对原有数组的破坏。

思路一

先直接排序，再取排序后数据的前k个数。

排序算法用最快的堆排序，复杂度也会达到O(N*logN).

void filterDown(int* disorder, int pos, int size){
    int temppos=pos,temp=;
    while(temppos<size/){
        if(*temppos+<size){
            if(disorder[*temppos+]>disorder[*temppos+]){
                if(disorder[temppos]<disorder[*temppos+]){
                    temp=disorder[temppos];
                    disorder[temppos]=disorder[*temppos+];
                    disorder[*temppos+]=temp;
                    temppos=*temppos+;
                }
                else{
                    break;
                }
            }
            else{
                if(disorder[temppos]<disorder[*temppos+]){
                    temp=disorder[temppos];
                    disorder[temppos]=disorder[*temppos+];
                    disorder[*temppos+]=temp;
                    temppos=*temppos+;
                }
                else{
                    break;
                }
            }
        }
        else if(disorder[temppos]<disorder[*temppos+]){
            temp=disorder[temppos];
            disorder[temppos]=disorder[*temppos+];
            disorder[*temppos+]=temp;
            temppos=*temppos+;
        }
        else{
            break;
        }

    }
}
void heapSort(int* disorder, int size){
    int bottomRowSize=;
    while(bottomRowSize<size){
        bottomRowSize*=;
    }
    int temp=,i=;
    for(int j=size/-;j>=;j--){
        filterDown(disorder, j, size);
    }
    for(int j=size-;j>;j--){
        temp=disorder[];
        disorder[]=disorder[j];
        disorder[j]=temp;
        filterDown(disorder,,j);
    }
}
int _tmain(int argc, _TCHAR* argv[])
{
    const int size=;
    const int maxnum = ;
    const int k=;
    int* disorder=new int[size];
    srand((unsigned) time(NULL));
    for(int i=;i<size;i++){
        disorder[i]=rand()%maxnum;
    }
    heapSort(disorder,size);
    for(int i=;i<k;i++){
        cout<<disorder[i]<<endl;
    }
    return ;
}

当k接近于N时，可以用这种算法。

思路二

先排序前k个数，对于后面N-k个数，依次进行插入。

时间复杂度为O(k*n)

void insertSort(int* disorder, int size){
    int temp=,i=;
    for(int j=;j<size;j++){
        temp=disorder[j];
        for(i=j;i>;i--){
            if(temp<disorder[i-]){
                disorder[i] = disorder[i-];
            }
            else{
                break;
            }
        }
        disorder[i]=temp;
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    const int size=;
    const int maxnum = ;
    const int k=;
    int* disorder=new int[size];
    srand((unsigned) time(NULL));
    int i=,temp;
    for(;i<size;i++){
        disorder[i]=rand()%maxnum;
    }
    insertSort(disorder,k);
    for(int j=k;j<size;j++){
        temp=disorder[j];
        for(i=k-;i>=;i--){
            if(temp<disorder[i]){
                disorder[i+] = disorder[i];
            }
            else{
                break;
            }
        }
        disorder[i+]=temp;
    }

    for(int i=;i<k;i++){
        cout<<disorder[i]<<endl;
    }
    return ;
}

当k很小时，可以用这种算法

思路三

对前k个数，建立最大堆，对于后面N-k个数，依次和最大堆的最大数比较，如果小于最大数，则替换最大数，并重新建立最大堆。

时间复杂度为O(N*logk)

void filterDown(int* disorder, int pos, int size){
    int temppos=pos,temp=;
    while(temppos<size/){
        if(*temppos+<size){
            if(disorder[*temppos+]>disorder[*temppos+]){
                if(disorder[temppos]<disorder[*temppos+]){
                    temp=disorder[temppos];
                    disorder[temppos]=disorder[*temppos+];
                    disorder[*temppos+]=temp;
                    temppos=*temppos+;
                }
                else{
                    break;
                }
            }
            else{
                if(disorder[temppos]<disorder[*temppos+]){
                    temp=disorder[temppos];
                    disorder[temppos]=disorder[*temppos+];
                    disorder[*temppos+]=temp;
                    temppos=*temppos+;
                }
                else{
                    break;
                }
            }
        }
        else if(disorder[temppos]<disorder[*temppos+]){
            temp=disorder[temppos];
            disorder[temppos]=disorder[*temppos+];
            disorder[*temppos+]=temp;
            temppos=*temppos+;
        }
        else{
            break;
        }

    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    const int size=;
    const int maxnum = ;
    const int k=;
    int* disorder=new int[size];
    srand((unsigned) time(NULL));
    int i=,temp;
    for(;i<size;i++){
        disorder[i]=rand()%maxnum;
    }
    for(int j=k/-;j>=;j--){
        filterDown(disorder, j, k);
    }
    for(int j=k;j<size;j++){
        if(disorder[j]<disorder[]){
            disorder[]=disorder[j];
            filterDown(disorder,,k);
        }
    }
    for(int j=k-;j>;j--){
        temp=disorder[];
        disorder[]=disorder[j];
        disorder[j]=temp;
        filterDown(disorder,,j);
    }
    for(int i=;i<k;i++){
        cout<<disorder[i]<<endl;
    }
    return ;
}

当k和N都很大时，这种算法比前两种算法要快很多。