求小哥哥小姐姐指教一下指针、链表 、结构体的用法

2018年，四年一度的世界杯足球赛又将成为令人关注的热门话题，请用C语言实现世界杯的小组分组。
假定出线的参赛队如下：英格兰、法国、德国、意大利、西班牙、荷兰、葡萄牙、克罗地亚、土耳其、俄罗斯、瑞典、捷克、塞尔维亚、加纳、科特迪瓦、突尼斯、尼日利亚、喀麦隆、日本、韩国、澳大利亚、伊朗、美国、墨西哥、哥斯达黎加、洪都拉斯、巴西、阿根廷、巴拉圭、智利、乌拉圭、厄瓜多尔。
世界杯的小组分组规则如下：
有八只种子球队，分别是乌拉圭队、西班牙队、德国队、阿根廷队、荷兰队、法国队、巴西队以及东道主俄罗斯队。
这八只球队一定分别在A-----H八个组中（八只球队不能碰面）。小组分为A------H一共八个小组。
题目要求：分组结果按行输出。每个小组四个球队。（参考循环赛）。
提示： 1.使用链表指针或者结构体数组； 2.随机数种子；

用数组实现最简单。

struct a{
    struct a *link[ 2 ];
    char *name[ 30 ];
};

为啥你这个结构这么像二叉树~~~

那有什么关系。做一个该结构的数组，0指向种子队，1指向对手。
数组元素的队伍名为胜利者。

这东西有个名字叫 联赛。专门用来做这种比赛的。

特性是 节点值是左右子树的最大值。

[此贴子已经被作者于2017-7-9 17:50编辑过]

还是我敏感了~这样结构体指针竟然和索引指针同一个数据类型~这样让久久有很大联想空间的~如果没有后续的话那两个指针空在这里会影响空间利用率的~

再看后面你回帖又改了一下……这样似乎要加个parent指针或者要找到回溯方法才行……~你是不是打算通过递归来返回parent的数据呢~

然后又再认真看了一下~结构体数组加二叉树结构……好好奇具体实现结构和过程是怎么样子的~

[此贴子已经被作者于2017-7-9 18:04编辑过]

你的意思是我去写出完整的实现函数？

这倒也不是……不过感觉这种写法有点独特或者是我接触的还比较少~或许还是我没有完全消化题目的意思~

你们怎么老是树呀树的？我用普通算法完成了。
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>
int m[30]={0};
enum team{A,B,C,D,E,F,G,H,I};
struct t{
    char country[20];
    team t;
}ct[32];
int *suiji(int n)
{
    static int i=0;
    int *p=&i;
    while(i<n)
    {
        m[i]=rand()%n;
        for(int j=0;j<i;j++)
        if(m[j]==m[i])suiji(n);
        i++;
    }
    return p;   
}

main()
{
    char a[][20]={"英格兰","意大利","葡萄牙","克罗地亚","土耳其","瑞典","捷克",
    "塞尔维亚","加纳","科特迪瓦","突尼斯","尼日利亚","喀麦隆","日本","韩国",
    "澳大利亚","伊朗","美国","墨西哥","哥斯达黎加","洪都拉斯","巴拉圭","智利",
    "厄瓜多尔"};
    char b[8][20]={"法国","德国","西班牙","荷兰","俄罗斯","巴西","阿根廷","乌拉圭"};
   
    srand((unsigned) time(0));
    team tt=A;
    int flag=0;
    int *p;
    for(int i=0;i<32;i++)
    {
            if(i<8)
            {
                if(!flag)
                {
                    p=suiji(8);
                    flag=1;
                }
                ct[i].t=(team)m[i];
                strcpy(ct[i].country,&b[m[i]][0]);
                ct[i].country[strlen(&b[m[i]][0])]='\0';
            }
            else
            {
                if(flag==1)
                {
                    *p=0;
                    suiji(24);
                    flag=2;
                }
                ct[i].t=(team)(m[i-8]%8);
                strcpy(ct[i].country,&a[m[i-8]][0]);
                ct[i].country[strlen(&a[m[i-8]][0])]='\0';
            }
            
            
    }
    flag=0;
   
    for(int i=0,count=0;tt<=H&&i<32;i++)
    {
        if(ct[i].t==tt)
        {
            if(flag==0)
            {
                printf("%c:",tt+'A');
                flag=1;   
            }
            printf("%s ",ct[i].country);
            count++;
            if(count%4==0)
            {
                tt=(team)(tt+1);
                i=-1;
                flag=0;
                printf("\n");
            }
        }
    }
}

赞一个~这算法虽然没啥特别~不过感觉还是更接地气~~

差不多就是这样，但是写的很乱，希望能看懂，好吧，看不懂也没什么关系。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define T

void
INIT( void );

void
Print( void );

int
main( void )
{
    INIT();
    Print();

    return 0;
}

#undef T
#define T League
#define MAX 8
#define CERROR( TEST ) if( NULL == ( TEST ) ) \
                 exit( EXIT_FAILURE ) 
typedef struct T *T;
struct T{
    unsigned int Score;
    T Link[ 2 ];
    char *Name;    
};

static char *name[] = {"英格兰","意大利","葡萄牙","克罗地亚","土耳其","瑞典","捷克","塞尔维亚","加纳","科特迪瓦","突尼斯","尼日利亚","喀麦隆","日本","韩国","澳大利亚","伊朗","美国","墨西哥","哥斯达黎加","洪都拉斯","巴拉圭","智利","厄瓜多尔"};

static char *Send[] = { "乌拉圭","西班牙","德国","阿根廷","荷兰","法国","巴西","俄罗斯"};
static int Flag[ 24 ];
static int FlagSend[ 8 ];
static struct T Group[ MAX ];

void
INIT( void )
{
    int ix,n;
    int f;
    T Temp;

    srand( ( unsigned )time( NULL ) );

    for( ix = 0; MAX > ix; ++ix )
    {
        Group[ ix ].Score = 0;
        Group[ ix ].Name = NULL;

        for( int i = 0; 2 > i; ++i )
        {
            Group[ ix ].Link[ i ] = ( T )calloc( 1, sizeof( struct T ) );
            CERROR( Group[ ix ].Link[ i ] );
            Temp = Group[ ix ].Link[ i ];

            for( int j = 0; 2 > j; ++j,++n )
            {
                Temp->Link[ j ] = ( T )malloc( sizeof( struct T ) );
                CERROR( Temp->Link[ j ] );
                Temp->Link[ j ]->Link[ 0 ] = NULL;
                Temp->Link[ j ]->Link[ 1 ] = NULL;
                 Temp->Link[ j ]->Score = 0;
                if( 1 != i || 1 != j )//种子队并不是随机的，当然要写成随机并不困难。
                {
                    while( 1 )
                    {
                        f = rand() % 24;
                        if( 0 != Flag[ f ] )
                            continue;
                        else
                        {
                            Temp->Link[ j ]->Name = name[ f ];
                            Flag[ f ] = 1;
                            break;
                        }
                        
                    }
                }
                else
                {
                    while( 1 )
                    {
                        f = rand() % 8;
                        if( 0 != FlagSend[ f ] )
                            continue;
                        else
                        {
                            Temp->Link[ j ]->Name = Send[ f ];
                            FlagSend[ f ] = 1;
                            break;
                        }
                    }
                }
                
            }
        }
    } 
}

void
PR( T X );

void
Print( void )
{
    int ix;

    for( ix = 0; MAX > ix; ++ix )
    {
        PR( &Group[ ix ] );
        printf( "\n" );
    }
}

void
PR( T X )
{
    if( NULL == X )
        return;
    if( NULL != X->Name )
        printf( "%s ", X->Name );

    PR( X->Link[ 0 ] );
    PR( X->Link[ 1 ] );
}

[此贴子已经被作者于2017-7-9 19:56编辑过]