用败者树从N个数中选择最大的k个数字

最新推荐文章于 2021-11-18 11:10:31 发布

chenbingchenbing

最新推荐文章于 2021-11-18 11:10:31 发布

阅读量861

点赞数

CC 4.0 BY-SA版权

分类专栏：综合文章标签： path up struct

本文链接：https://blog.youkuaiyun.com/chenbingchenbing/article/details/6967914

综合专栏收录该内容

107 篇文章

订阅专栏

本文探讨了在大数据背景下，如何通过优化算法提高数据处理效率。重点介绍了选择合适的数据结构、利用并行计算和分布式处理等技术手段，以及如何在实际应用中实现算法的高效执行。同时，讨论了不同场景下算法选择的重要性，并提供了具体案例分析。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

20 21 24 29 36 45 56 69 84 101 120 141 164 189 16 45 76 109 144 181 20 61 104 149 196 45 96 149 4 61 120 181 44 109 176 45 116 189 64 141 20 101 184 69 156 45 136 29 124 21 120 21 124 29 136 45 156 69 184 101 20 141 64 189 116 45 176 109 44 181 120 61 4 149 96 45 196 149 104 61 20 181 144 109 76 45 16 189 164 141 120 101 84 69 56 45 36 29 24 21

184 184 189 189 189 189 196 196

￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥

#include <stdio.h>
#include <stdlib.h>

typedef struct wrap_data
{
int path;
int *data;
}wrap_data;

int choosevec(int path)
{
        if(path<=4)
        {
                return 4;
        }
        else if (path<=8)
        {
                return 8;
        }
        else if(path<=16)
        {
                return 16;
        }
        else
        {
                return 32;
        }
}

wrap_data **vec;
int vecsize;

void    up ( int num )
{
        int i,j,k;
        wrap_data *first,*second;
        i=num;
        second=vec[i];
        while(i)
        {
                j=i/2;
                first=vec[j];

                if(!first)
                {
                        vec[j]=second;
                        return ;

                }
                if ( first->path==second->path)
                {
                        i=j;
                }
                else if ( *( second->data )> *( first->data ))
                {
                        vec[j]=second;
                        second=first;
                        i=j;

                }
                else
                {
                        i=j;
                }
        }
}

int main()
{
#define PATH 8
#define LENGTH 100
#define MAX_BIG 999999999

        wrap_data *result;
        int i=0,j=0,k=0;
        int global[LENGTH]={0};
        wrap_data a[PATH]={0};
        int label=0;

vecsize=2* choosevec(PATH);
vec=(wrap_data **)calloc( vecsize ,sizeof (wrap_data*));

        for(i=0;i<LENGTH;i++)
        {
          global[i]=(i*i+20)%200;
                printf("%d   ",global[i]);
        }

        for(i=0;i<PATH;i++)
        {
                a[i].path=i;
                a[i].data=(int *)calloc (1 ,sizeof (int ));
                *(a[i].data)=global[label++];

}

        k=vecsize/2;
        for(i=0;i<PATH;i++)
        {
                vec[k+i]=&a[i];
        }
        for(i=0;i<PATH;i++)
        {
                up(i+k);

}

        while(label <LENGTH)
        {
                result=vec[0];
                if( global[label]<*( result->data))
                {
                }
                else
                {
                        vec[0]=0;
                        *(result->data)=global[label ];
                        up (result->path+k);
                }
                label++;

        }
        //dump
        printf("\n");
        i=0;
        while(i++<PATH)
        {
                result=vec[0];
                printf("%d ", *(result->data));
                vec[0]=0;
                *(result->data)=MAX_BIG;
                up (result->path+k);

}