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

原创 2012年03月26日 10:07:27
#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;
}





求无序数组第K大的数值,及其所在的位置

求无序数组第K大的数值,及其所在的位置 #include "stdafx.h" #include #include #include void ...

将数组元素循环右移k个位置(Java实现)

用四种方法实现了将数组元素循环右移k个位置,相关的解释作为注释放在代码里面了。 package movearrayelement; import java.util.BitSet; public...

数组第k大的元素的位置

/*快速排序(分治法)原理:是对冒泡排序的一种改进,基本思想是通过一趟排序以待排第一个数据(或最后一个数据)为支点,将待排数据分割成独立的两部分, 其中一部分数据均比另一部分数据小,则可分别对这两部分...

poj 2828 Buy Tickets(树状数组找部分和为k的第一个位置)

Buy Tickets Time Limit: 4000MS   Memory Limit: 65536K Total Submissions: 11135   A...
  • WEYuLi
  • WEYuLi
  • 2013年11月21日 11:58
  • 798

写一段程序,找出数组中第k大小的数,输出数所在的位置。

基本上是利用排序思想,稍微改造以适应这种需求。比如最简单的冒泡排序,冒泡到第k次时就找到了这个数(需要提前缓存原始索引位置);快速排序的思想,把数组分割成大于和小于某值的两部分后,判断每部分的元素个数...

写一段程序,找出数组中第k大小的数,输出数所在的位置。

写一段程序,找出数组中第k大小的数,输出数所在的位置。例如{2,4,3,4,7}中,第一大的数是7,位置在4。第二大、第三大的数都是4,位置在1、3随便输出哪一个均可。函数接口为:int   find...

面试题-找出数组中第k大小的数,输出数所在的位置

这个是我碰到的一个面试题。 因为我C++用得比较

Arithmetic problem | 从数组选K个数位于原数组相对位置,求K个数的最大数

题目如下: 给出两个长度分别是m和n的数组来表示两个大整数,数组的每个元素都是数字0-9。从这两个数组当中选出k个数字来创建一个最大数,其中k满足k 。选出来的数字在创建的最大数里面的位置必须和在原...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:求无需数组第K小的数及其位置
举报原因:
原因补充:

(最多只允许输入30个字)