[已解决]链表13个人报数，求最后留下1个人的序号问题

跑不掉

为什么我的DEV没有运行出正确结果？
什么也没有打印出来

题目如下：

13个人围成一圈，从第一个人开始报数1，2，3。报到3的退出圈子。找出最后留在圈子中的人原来的序号。要求用链表实现。

代码如下：

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

#define N 13
typedef struct People
{
        int num;
        struct People *next;
}people;

int main()
{
        //定义13个人的数据
        people arry[N];
        
        //建立环状链表
        people *head = arry;
        for (int i=0;i < N;++i)
        {
                head->num = i+1;
                head->next = &arry[i+1];
                head = head->next;
        }
        //构成环状结构
        arry[N-1].next = arry;
        
        //开始报数
        int count = N;
        //从1开始报数
        int i = 1;
        while (count>1)
        {
                //判断是否已经退出
                if(head->num ==0)
                {
                        //跳过此人
                        head = head->next;
                        continue;
                }
                
                if (i == 3)  //当前此人需要退出
                {
                        printf("第%d个人退出\n",head->num);
                        head->num = 0;
                        count--;
                }
                //如果不需要退出，继续下一个报号
                ++i;
                head = head->next;
                
                //判断报号超过3，
                if(i>3)
                {
                        i = 1;
                }
        }
        
        //找出编号不为0的人
        while (head->num ==0)
        {
                //找下一个人
                head = head->next;
                if(head->num != 0);
                {
                        printf("没有退出的人为第%d\n个人",head->num);
                        break;
                }
        }
        
        return 0;
}

最佳答案

月排行榜 / 总排行榜

jackz007

2024-10-26 02:17:02

        答案是 13
【代码1】：

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

int main(void)
{
        typedef struct chain {
                int data                                        ;
                struct chain * next                             ;  
        } CHAIN , * PCHAIN                                      ;
        PCHAIN head , p , q                                     ;
        int c , i , k , n = 13 , r                              ;
        for(r = 1 , i = 0 ; i < n ; i ++) {
                if (p = (PCHAIN) malloc(sizeof(CHAIN))) {
                        p -> data = i + 1                       ;
                        p -> next = NULL                        ;
                        if(! i) {
                                head = p                        ;
                                p -> next = p                   ;
                        } else {
                                q -> next = p                   ;
                                p -> next = head                ; 
                        }
                        q = p                                   ;
                } else {
                        fprintf(stderr , "malloc() failure.\n") ;
                        r = 0                                   ;
                }
        }
        if(r) {
                for(k = n , c = 0 , p = q = head ; k > 1 ; p = q -> next) {
                        c ++                                    ;
                        if(! (c % 3)) {
                                q -> next = p -> next           ;
                                k --                            ;
                                free(p)                         ;
                        } else {
                                q = p                           ;
                        }
                }
                printf("%d\n" , p -> data)                      ;
                free(p)                                         ;
        }
}

【代码2】：

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

int main(void)
{
        typedef struct chain {
                int data                                        ;
                struct chain * next                             ;  
        } CHAIN , * PCHAIN                                      ;
        PCHAIN head , p , q                                     ;
        int c , f , i , k , n = 13 , r                          ;
        for(r = 1 , i = 0 ; i < n ; i ++) {
                if (p = (PCHAIN) malloc(sizeof(CHAIN))) {
                        p -> data = i + 1                       ;
                        if(! i) {
                                head = p                        ;
                                p -> next = p                   ;
                        } else {
                                q -> next = p                   ;
                                p -> next = head                ; 
                        }
                        q = p                                   ;
                } else {
                        fprintf(stderr , "malloc() failure.\n") ;
                        r = 0                                   ;
                }
        }
        if(r) {
                for(k = n , c = 0 , p = head ; k > 1 ; p = p -> next) {
                        if(p -> data) {
                                c ++                            ;
                                if(! (c % 3)) {
                                        p -> data = 0           ;
                                        k --                    ;
                                }
                        }
                }
                for(p = head ; ! p -> data ; p = p -> next)     ;
                printf("%d\n" , p -> data)                      ;
        }
        if(head) {
                for(p = head , f = 1 ; f ; p = q) {
                        if(p -> next == head) f = 0             ;
                        q = p -> next                           ;
                        free(p)                                 ;
                }
        }
}

跳转到最佳答案楼层

FishC

你的代码有几个问题导致没有正确输出，下面是一些修正建议：

1. **数组和指针问题**：
   - 使用数组 `arry` 时，应该定义为指针数组指向 `people` 结构体。

2. **环形链表错误**：
   - 你在环形链表的创建过程中没有正确定义下一个节点的位置。

3. **逻辑错误**：
   - 判断剩余的人的循环中包含一个多余的分号 `;`，会导致逻辑错误。

下面是修正后的代码：

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

#define N 13

typedef struct People
{
    int num;
    struct People *next;
} people;

int main()
{
    // 创建环形链表
    people *head = (people *)malloc(sizeof(people));
    people *current = head;
    for (int i = 0; i < N; ++i)
    {
        current->num = i + 1;
        if (i < N - 1)
        {
            current->next = (people *)malloc(sizeof(people));
            current = current->next;
        }
        else
        {
            current->next = head; // 完成环形链表
        }
    }

    int count = N;
    int i = 1;
    current = head;

    // 开始报数
    while (count > 1)
    {
        if (i == 3) // 每数到3时剔除当前节点
        {
            printf("第%d个人退出\n", current->num);
            current->num = 0; // 标记为退出
            count--;
            i = 1; // 重置计数器
        }
        else
        {
            i++;
        }

        // 移动到下一个非0的节点
        current = current->next;
    }

    // 找出剩余的那个人
    while (current->num == 0)
    {
        current = current->next;
    }

    printf("没有退出的人为第%d号\n", current->num);

    // 释放内存
    people *temp;
    while (count--)
    {
        temp = head;
        head = head->next;
        free(temp);
    }

    return 0;
}

### 主要修改：
- 使用动态分配内存，并通过循环创建一个完整的环形链表。
- 保证每次跳过被标记的节点。
- 处理最后一个节点不需要多余的 `;` 来避免逻辑分支进入错误执行部分。
- 提高了可读性和可维护性。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

jackz007

        答案是 13
【代码1】：

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

int main(void)
{
        typedef struct chain {
                int data                                        ;
                struct chain * next                             ;  
        } CHAIN , * PCHAIN                                      ;
        PCHAIN head , p , q                                     ;
        int c , i , k , n = 13 , r                              ;
        for(r = 1 , i = 0 ; i < n ; i ++) {
                if (p = (PCHAIN) malloc(sizeof(CHAIN))) {
                        p -> data = i + 1                       ;
                        p -> next = NULL                        ;
                        if(! i) {
                                head = p                        ;
                                p -> next = p                   ;
                        } else {
                                q -> next = p                   ;
                                p -> next = head                ; 
                        }
                        q = p                                   ;
                } else {
                        fprintf(stderr , "malloc() failure.\n") ;
                        r = 0                                   ;
                }
        }
        if(r) {
                for(k = n , c = 0 , p = q = head ; k > 1 ; p = q -> next) {
                        c ++                                    ;
                        if(! (c % 3)) {
                                q -> next = p -> next           ;
                                k --                            ;
                                free(p)                         ;
                        } else {
                                q = p                           ;
                        }
                }
                printf("%d\n" , p -> data)                      ;
                free(p)                                         ;
        }
}

【代码2】：

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

int main(void)
{
        typedef struct chain {
                int data                                        ;
                struct chain * next                             ;  
        } CHAIN , * PCHAIN                                      ;
        PCHAIN head , p , q                                     ;
        int c , f , i , k , n = 13 , r                          ;
        for(r = 1 , i = 0 ; i < n ; i ++) {
                if (p = (PCHAIN) malloc(sizeof(CHAIN))) {
                        p -> data = i + 1                       ;
                        if(! i) {
                                head = p                        ;
                                p -> next = p                   ;
                        } else {
                                q -> next = p                   ;
                                p -> next = head                ; 
                        }
                        q = p                                   ;
                } else {
                        fprintf(stderr , "malloc() failure.\n") ;
                        r = 0                                   ;
                }
        }
        if(r) {
                for(k = n , c = 0 , p = head ; k > 1 ; p = p -> next) {
                        if(p -> data) {
                                c ++                            ;
                                if(! (c % 3)) {
                                        p -> data = 0           ;
                                        k --                    ;
                                }
                        }
                }
                for(p = head ; ! p -> data ; p = p -> next)     ;
                printf("%d\n" , p -> data)                      ;
        }
        if(head) {
                for(p = head , f = 1 ; f ; p = q) {
                        if(p -> next == head) f = 0             ;
                        q = p -> next                           ;
                        free(p)                                 ;
                }
        }
}