求无需数组第K小的数及其位置

最新推荐文章于 2023-04-30 21:07:47 发布
最新推荐文章于 2023-04-30 21:07:47 发布
阅读量585 收藏
点赞数
分类专栏： C++ 文章标签： system include null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kingsong0816/article/details/7393877
版权 
#include "stdafx.h"
#include <time.h>
#include <stdio.h>
#include <stdlib.h>


void swap(int & a, int & b);
int find_position(int* a,int k, int low,int high);
int find_orderk(int* a, int k, int low,int high);

int MAXCOUNT = 10;

void swap(int & a, int & b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

int get_position(int* a, int count,int value)
{
    int pos = -1;
    for ( int i = 0; i < count ; i++ )
    {
        if ( a[i] == value )
        {
            pos = i;
        }
    }
    return pos;
}

void print_array(int* a, int count)
{
    for ( int i = 0; i < count ; i++ )
    {
        if(i%10 == 0)
            printf("\n");
        printf("%d\t", a[i]);
    }
}

//随机选取数组指定范围内的一个数Value，
//把指定范围内的数以Value为分界点，左边部分大于等于Value，右边部分小于Value
//返回所选数值所在的位置
// a[low]... a[m]...a[hight]
//             ^
//  > value  value  < value
//             ^
//             p
int find_position(int* a, int low,int hight)
{
    //只有一个元素直接返回
    if (low >= hight)
    {
        return low;
    }
    
    //随机选取low与hight之间的一个数作为基准
    int m = rand() % (hight - low) + low;
    int value =  a[m];      //选取元素的值
    int p = m;              //选取元素的索引
    
    int lowpos = low;       //第一个小于Value的元素索引
    int hightpos = hight;   //最后一个大于Value的元素索引
    bool bfindl = false;    //是否存在小于Value的元素
    bool bfindh = false;    //是否存在大于Value的元素
    
    for (int i = low; i <= hight; i++)
    {        
        if(a[i] >= value && i != m)
        {
            bfindh = true; //存在大于Value的元素
            if(bfindl)
            {
                //与第一个小于Value的元素交换
                hightpos = lowpos;
                swap(a[lowpos++], a[i]);
                //跳过索引m的位置
                if (lowpos == m)
                {
                    lowpos++;
                }
            }
            else
            {
                hightpos = i;
            }
        }
        //第一个小于Value的索引
        else if( a[i] < value && !bfindl)
        {
            lowpos = i;
            bfindl = true;
        }
    }
    
    //存在大于Value的元素,并且最后一个大于Value的元素在m之后，需要交换
    if(bfindh && hightpos > m)
    {
        swap(a[p], a[hightpos]);
        p = hightpos;
    }
    
    //存在小于Value的元素,并且第一个小于Value的元素在m之前，需要交换
    if(bfindl && lowpos < m)
    {
        swap(a[p], a[lowpos]);
        p = lowpos;
    }

    return p;
}

//随机选取数组指定范围内的一个数Value，
//把指定范围内的数以Value为分界点，左边部分大于等于Value，右边部分小于Value
//返回所选数值所在的位置
// a[low]... a[m]...a[hight]
//             ^
//  > value  value  < value
//             ^
//             p
int find_position_h(int* a, int low,int hight)
{
    //只有一个元素直接返回
    if (low >= hight)
    {
        return low;
    }
    
    //随机选取low与hight之间的一个数作为基准
    int m = rand() % (hight - low) + low;
    int value =  a[m];      //选取元素的值
    int p = m;              //选取元素的索引
    
    int lowpos = low;       //第一个小于Value的元素索引
    int hightpos = hight;   //最后一个大于Value的元素索引
    bool bfindl = false;    //是否存在小于Value的元素
    bool bfindh = false;    //是否存在大于Value的元素
    
    for (int i = low; i <= hight; i++)
    {        
        if(a[i] >= value && i != m)
        {
            bfindh = true; //存在大于Value的元素
            if(bfindl)
            {
                //与第一个小于Value的元素交换
                hightpos = lowpos;
                swap(a[lowpos++], a[i]);
                
                //跳过索引m的位置
                if (lowpos == m)
                {
                    lowpos++;
                }
            }
            else
            {
                hightpos = i;
            }
        }
        //第一个小于Value的索引
        else if( a[i] < value && !bfindl)
        {
            lowpos = i;
            bfindl = true;
        }
    }
    
    //存在大于Value的元素,并且最后一个大于Value的元素在m之后，需要交换
    if(bfindh && hightpos > m)
    {
        swap(a[p], a[hightpos]);
        p = hightpos;
    }
    
    //存在小于Value的元素,并且第一个小于Value的元素在m之前，需要交换
    if(bfindl && lowpos < m)
    {
        swap(a[p], a[lowpos]);
        p = lowpos;
    }

    return p;
}

//随机选取数组指定范围内的一个数Value，
//把指定范围内的数以Value为分界点，左边部分大于等于Value，右边部分小于Value
//返回所选数值所在的位置
// a[low]... a[m]...a[hight]
//             ^
//  < value  value  > value
//             ^
//             p
int find_position_l(int* a, int low,int hight)
{
    //只有一个元素直接返回
    if (low >= hight)
    {
        return low;
    }
    
    //随机选取low与hight之间的一个数作为基准
    int m = rand() % (hight - low) + low;
    int value =  a[m];      //选取元素的值
    int p = m;              //选取元素的索引
    
    int hightpos = low;       //第一个大于Value的元素索引
    int lowpos = hight;   //最后一个小于Value的元素索引
    bool bfindl = false;    //是否存在小于Value的元素
    bool bfindh = false;    //是否存在大于Value的元素
    
    for (int i = low; i <= hight; i++)
    {        
        if(a[i] <= value && i != m)
        {
            bfindl = true; //存在小于Value的元素
            if(bfindh)
            {
                //与第一个大于Value的元素交换
                lowpos = hightpos;
                swap(a[hightpos++], a[i]);
                print_array(a, MAXCOUNT);
                //跳过索引m的位置
                if (hightpos == m)
                {
                    hightpos++;
                }
            }
            else
            {
                lowpos = i;
            }
        }
        //第一个大于Value的索引
        else if( a[i] > value && !bfindh)
        {
            hightpos = i;
            bfindh = true;
        }
    }
    

    //存在大于Value的元素,并且第一个大于Value的元素在m之前，需要交换
    if(bfindh && hightpos < m)
    {
        swap(a[p], a[hightpos]);
        print_array(a, MAXCOUNT);
        p = hightpos;
    }

        //存在小于Value的元素,并且最后一个小于Value的元素在m之后，需要交换
    if(bfindl && lowpos > m)
    {
        swap(a[p], a[lowpos]);
        print_array(a, MAXCOUNT);
        p = lowpos;
    }
    

    return p;
}

//获得数组指定范围【low,height】内第K大的数所在的位置
int find_orderk(int* a, int k, int low,int hight)
{
    //获得一个low与hight之间的一个位置p，使得a[low...p] >= a[p]， a[p+1, hight] < a[p]
    int p = find_position(a, low, hight);
    
    //p与low索引之间的元素个数小于K
    if(p-low < k-1)
    {
        //获得数组指定范围【p+1,height】内第【(k-1)-(p-low)】大的数所在的位置
        p = find_orderk(a, (k-1)-(p-low), p+1, hight);
    }
    //p与low索引之间的元素个数大于K
    else if (p-low > k-1)
    {
        //获得数组指定范围【low,p-1】内第【k】大的数所在的位置
        p = find_orderk(a, k, low, p-1);
    }

    return p;
}

//获得数组指定范围【low,height】内第K大的数所在的位置
int find_orderk_h(int* a, int k, int low,int hight)
{
    //获得一个low与hight之间的一个位置p，使得a[low...p] >= a[p]， a[p+1, hight] < a[p]
    int p = find_position_h(a, low, hight);
    
    //p与low索引之间的元素个数小于K
    if(p-low < k-1)
    {
        //获得数组指定范围【p+1,height】内第【(k-1)-(p-low)】大的数所在的位置
        p = find_orderk(a, (k-1)-(p-low), p+1, hight);
    }
    //p与low索引之间的元素个数大于K
    else if (p-low > k-1)
    {
        //获得数组指定范围【low,p-1】内第【k】大的数所在的位置
        p = find_orderk(a, k, low, p-1);
    }

    return p;
}

//获得数组指定范围【low,height】内第K小的数所在的位置
int find_orderk_l(int* a, int k, int low,int hight)
{
    //获得一个low与hight之间的一个位置p，使得a[low...p] <= a[p]， a[p+1, hight] > a[p]
    int p = find_position_l(a, low, hight);
    
    //p与low索引之间的元素个数小于K
    if(p-low < k-1)
    {
        //获得数组指定范围【p+1,height】内第【(k-1)-(p-low)】大的数所在的位置
        p = find_orderk_l(a, (k-1)-(p-low), p+1, hight);
    }
    //p与low索引之间的元素个数大于K
    else if (p-low > k-1)
    {
        //获得数组指定范围【low,p-1】内第【k】大的数所在的位置
        p = find_orderk_l(a, k, low, p-1);
    }

    return p;
}

int main ()  
{
    srand((unsigned) time(NULL));
    
    //初始化数组
    int srcArray[100];
    int keyArray[100];
    
    int n;
    do
    {
        printf("\n初始化数组，请输入数组元素个数（1-100）：");
        scanf("%d", &n);
        
    }while ( n > 100 || n <= 0);
    MAXCOUNT = n;
    int i = 0;
    while(i < n)
    {
        srcArray[i] = rand()%100;
        keyArray[i]=srcArray[i];
        i++;
    }
    
    //输出数组元素
    print_array(srcArray, n);
    
    //获得参数
    do
    {
        int k = 1;
        do
        {
            printf("\n请输入数值（1-%d）：", n);
            scanf("%d", &k);
        }while ( k > n || k <= 0);
        
        //获得第K大元素位置
        int newpos = find_orderk_h(srcArray, k, 0, n-1);
        int value = srcArray[newpos];
        int srcpos = get_position(keyArray, n, value);
        printf("\n 数组中第 %d 大的数值: %d 位置: %d \n", k, value, srcpos);

        system("PAUSE");
        memcpy(srcArray, keyArray, sizeof(srcArray));

        //获得第n - k + 1小元素位置
        int no = n - k + 1;
        int newpos2 = find_orderk_l(srcArray, no, 0, n-1);
        print_array(srcArray, n);
        int value2 = srcArray[newpos2];
        int srcpos2 = get_position(keyArray, n, value2);
        printf("\n 数组中第 %d 小的数值: %d 位置: %d \n", no , value2, srcpos2);

        system("PAUSE");
        memcpy(srcArray, keyArray, sizeof(srcArray));

    }while ( true );
 
    return 0;
}


烫手De冰
关注
专栏目录
寻找第K小的数
__七把刀__
08-31 1万+
前言 寻找第K小的数属于顺序统计学范畴，通常我们可以直接在O(NlgN)的时间内找到第K小的数，使用归并排序或者堆排序对输入数据按从小到大进行排序，然后选择第K个即可。然而，我们还有更好的算法。 一、热身—最大值和最小值 首先来看一个简单的问题，在一个有n个元素的集合中，需要多少次比较才能确定其最小值呢？这可以很容易退出需要n-1次这个上界。伪代码如下所示： MINIMUM(A
微信小游戏推送（小游戏礼包功能）服务器端接入开发经验总结
最新发布
网易搬砖选手
06-13 1万+
小游戏开发者的游戏内道具，可通过接入平台「礼包系统」，在微信平台各场景发放游戏礼包。发放场景包括：游戏圈、活动运营工具、发现-游戏-福利中心、广告、搜索等道具礼包发货基于微信小游戏统一的消息推送能力，因此在使用礼包中心的发货回调时，需要开发者服务器处理好消息推送的协议。注意：MP配置消息回调地址只有1个，所有消息推送场景都会使用该通道，所以需要先根据MsgType与Event来判断消息类型，进行相应的处理。下面是发送和返回的格式：更多详情可以查看文档：小游戏礼包 | 微信开放文档。
Notes of PTA assignments in week 2
BEIBEI_2011的博客
09-08 317
Q1 找第k小的数 设计一个平均时间为O(n)的算法，在n(1<=n<=1000)个无序的整数中找出第k小的数。 提示：函数int partition(int a[],int left,int right)的功能是根据a[left]~a[right]中的某个元素x（如a[left])对a[left]~a[right]进行划分，划分后的x所在位置的左段全小于等于x,右段全大于等...
求第K小的数
Lee.的博客
12-06 1062
C
求第k小的数
我那柏拉图式的情人
09-30 569
算法思想：直觉上可以用冒泡排序，
数据结构之树状数组 ——详解
weixin_55786578的博客
04-30 1296
树状数组是一种维护前缀和、区间和的数据结构。它在原数组上添加索引，从而高效维护数据。神奇而小巧的数据结构，树状数组的下标必须从1开始！无论是他的修改还是查询，时间复杂度永远都是 logn，适合用于做区间和，前缀和，单点修改比前缀和标准做法的修改快一些。
1数组和广义表1
08-03
在稀疏矩阵中，转置操作可以通过遍历原始三元组数组并交换行和列下标来实现，而无需考虑元素的位置。以下是一个简单的转置算法示例： ```c Triple *transposeMatrix(Matrix &matrix){ Triple *triples = malloc...
k近邻算法_k最近邻分类算法(KNN)的原理及其实现
weixin_39913628的博客
11-18 1801
1. 算法思路通过计算每个训练样例到待分类样品的距离，取和待分类样品距离最近的K个训练样例，K个样品中哪个类别的训练样例占多数，则待分类样品就属于哪个类别核心思想：如果一个样本在特征空间中的k个最相邻的样本中的大多数属于某一个类别，则该样本也属于这个类别，并具有这个类别上样本的特性。该方法在确定分类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所属的类别。kNN方法在类别决策时，只与极少...
KNN.zip_KNN 数字_KNN手写数字识别_knn 数字识别_数字识别_测试集
09-23
总的来说，KNN算法在手写数字识别中发挥着重要作用，它简单易懂且无需假设数据分布，适合小规模或中等规模的数据集。然而，KNN也存在明显的缺点，如计算复杂度高，不适合大规模数据集，以及容易受到异常值的影响。...
找出第K小的数
Elegdawnce的博客
08-16 1147
题目描述：            查找一个数组的第K小的数，注意同样大小算一样大。       如  2 1 3 4 5 2 第三小数为3。      输入：      输入有多组数据。      每组输入n，然后输入n个整数(1     输出：      输出第k小的整数。      样例输入：      6      2 1 3 5 2 2 
找第k小的数
m0_51863774的博客
11-15 448
设计一个平均时间为O(n)的算法，在n(1
第K小的数
代表着月亮的神明幻化出的一只神圣的狼
08-04 73
103 1337251246
求第k小的数（快速排序）
Botton's blog
10-17 1061
算法思想： 时间复杂度：O(n) 在快速排序的过程中,可以分为两段， [l,j][l,j][l,j]这段都是小于等于随机值的 [j+1,r][j + 1,r][j+1,r]这段都是大于等于随机值的 左边这段有 j−l+1j - l + 1j−l+1 个数（记作 slslsl） 也就是说第 111 ~ slslsl （包括sl）小的数字都在左边 第 sl+1sl + 1sl+1 ~ nnn 小的数字都在右边 如果 kkk 是在左边，那直接在左边求即可 如果 kkk 是在右边，那么直接在右边求即可，此时第k小变
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值