习题8-4 报数-用链表法实现（浙大版《C语言程序设计（第3版）》题目集）

于 2023-07-15 08:36:15 发布
阅读量189 收藏
点赞数
分类专栏： 浙大PTA C语言程序设计(第3版)题目集 c语言 文章标签： 链表 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xuejin002/article/details/131734641
版权

做题时只提交核心函数的代码即可

下面是用链表法解题的，算法复杂度会比较高，但是时间复杂度会很低，也可以参考另一个算法复杂度比较低的数组法

// 核心函数

#include <stdlib.h>

struct Node // 定义一个结构体，结构体中包含两个成员变量，一个是Data类型，一个是Pointer类型
{
    union Data
    {
        int value;
        int size;
    } var;
    union Pointer
    {
        struct Node *head;
        struct Node *next;
    } ptr;
};

typedef struct Node ListNode;
typedef ListNode *ListHead;

ListHead CreateList(int length);
void FreeList(ListHead head);

ListHead CreateList(int length) // CreateList函数的实现
{
    ListHead list = (ListHead)malloc(sizeof(ListNode));
    list->var.size = 0; // 将链表的长度保存在头节点的var.size中
    list->ptr.head = NULL;

    ListNode *pTailNode = NULL;
    for (int idx = 0; idx < length; ++idx)
    {
        ListNode *newNode = (ListNode *)malloc(sizeof(ListNode)); // 为链表中的每个节点分配内存
        if (newNode == NULL)
        {
            printf("Memory allocation failed.\n");
            exit(0);
        }
        newNode->var.value = idx; // 为链表中的每个节点赋值
        newNode->ptr.next = NULL;

        if (NULL == list->ptr.head) // 如果表头节点的ptr.head为NULL，则将ptr.head指向当前节点，
        {                           // 将pTailNode指向当前节点，跳过本次循环，继续下一次循环
            list->ptr.head = newNode;
            list->var.size = 1;
            pTailNode = newNode;
            continue;
        }

        pTailNode->ptr.next = newNode;
        pTailNode = newNode;
        ++(list->var.size);
    }

    pTailNode->ptr.next = list->ptr.head; // 将尾节点的next指针指向头节点，形成一个循环链表

    return list;
}

void FreeList(ListHead list)
{
    ListNode *pCurrentNode = list->ptr.head;
    free(list); // 释放指向循环链表的表头节点

    if (NULL == pCurrentNode) // 如果循环链表的头节点为NULL，则直接返回
    {
        return;
    }

    ListNode *pHead = pCurrentNode;
    pCurrentNode = pCurrentNode->ptr.next;
    while (pCurrentNode != pHead) // 循环条件为pCurrentNode不等于pHead
    {
        ListNode *pTemp = pCurrentNode;
        pCurrentNode = pCurrentNode->ptr.next;
        free(pTemp);
    }

    free(pHead); // 释放循环链表的头节点
}

void CountOff(int length, int m, int out[]) // CountOff函数的实现
{
    if (m < 1) // 如果m小于1，则直接返回
    {
        return;
    }

    ListHead list = CreateList(length);             // 创建一个长度为length的循环链表
    if ((NULL == list) && (NULL == list->ptr.head)) // 如果创建循环链表失败，则直接返回
    {
        return;
    }

    if (1 == length) // 如果循环链表的长度为1，则直接将第一个节点的值保存在out数组中，释放循环链表，直接返回
    {
        out[list->ptr.head->var.value] = 1;
        FreeList(list);
        return;
    }

    ListNode *pCurrentNode = list->ptr.head;
    ListNode *pPreNode = pCurrentNode;
    while (pPreNode->ptr.next != pCurrentNode)
    {
        pPreNode = pPreNode->ptr.next; // 找到循环链表的头节点的上一个节点
    }
    for (int cnt = 0; cnt < length; ++cnt)
    {
        if (1 == list->var.size) // 如果循环链表的长度为1，将最后一个节点的值保存在out数组中，释放循环链表，直接返回
        {
            out[pCurrentNode->var.value] = cnt + 1;
            FreeList(list);
            return;
        } // 卫语句

        // int remainder = (m - 1) % list->var.size; // (m-1)对length取余，防止(m-1)大于length

        for (int step = 0; step < (m - 1); ++step) // 找到第m个节点
        {
            pPreNode = pCurrentNode;
            pCurrentNode = pCurrentNode->ptr.next;
        }

        out[pCurrentNode->var.value] = cnt + 1; // 将第m个节点的值保存在out数组中
        --(list->var.size);                     // 将循环链表的长度减1

        ListNode *pTemp = pCurrentNode;        // 保存第m个节点
        pCurrentNode = pCurrentNode->ptr.next; // 将当前节点指向后一个节点
        pPreNode->ptr.next = pCurrentNode;     // 将第m个节点的前一个节点的next指针指向第m个节点的next指针指向的节点
        if (pTemp == list->ptr.head)           // 如果第m个节点为头节点，则将头节点指向第m个节点的next指针指向的节点
        {
            list->ptr.head = pCurrentNode;
        }
        free(pTemp); // 释放第m个节点
    }

    FreeList(list); // 释放循环链表
}

报数游戏是这样的：有n个人围成一圈，按顺序从1到n编好号。
从第一个人开始报数，报到m（<n）的人退出圈子；下一个人从1开始报数，报到m的人退出圈子。如此下去，直到留下最后一个人。

本题要求编写函数，给出每个人的退出顺序编号。

函数接口定义：

void CountOff( int n, int m, int out[] );

其中n是初始人数；m是游戏规定的退出位次（保证为小于n的正整数）。函数CountOff将每个人的退出顺序编号存在数组out[]中。因为C语言数组下标是从0开始的，所以第i个位置上的人是第out[i-1]个退出的。

完整的可执行代码(可以直接在本地编译并运行)：

#include <stdio.h> // printf, scanf的函数声明在此头文件中

#define MAX_NUMBER 20 // 宏定义，MAX_NUMBER的值为20

void CountOff(int length, int m, int out[]); // 函数声明

int main(void) // main函数，程序入口
{
    int out[MAX_NUMBER] = {0}; // 定义一个长度为MAX_NUMBER的数组，数组中的每个元素都初始化为0
    int n = 0;                 // 定义一个整型变量n，初始化为0
    int m = 0;                 // 定义一个整型变量m，初始化为0

    scanf("%d %d", &n, &m);           // 从标准输入中读取两个整数，分别赋值给n和m
    CountOff(n, m, out);              // 调用CountOff函数，计算出out数组中的值
    for (int idx = 0; idx < n; ++idx) // 遍历out数组，输出数组中的值
    {
        printf("%d ", out[idx]);
    }
    printf("\n"); // 输出一个换行符

    return 0;
}

#include <stdlib.h>

struct Node // 定义一个结构体，结构体中包含两个成员变量，一个是Data类型，一个是Pointer类型
{
    union Data
    {
        int value;
        int size;
    } var;
    union Pointer
    {
        struct Node *head;
        struct Node *next;
    } ptr;
};

typedef struct Node ListNode;
typedef ListNode *ListHead;

ListHead CreateList(int length);
void FreeList(ListHead head);

ListHead CreateList(int length) // CreateList函数的实现
{
    ListHead list = (ListHead)malloc(sizeof(ListNode));
    list->var.size = 0; // 将链表的长度保存在头节点的var.size中
    list->ptr.head = NULL;

    ListNode *pTailNode = NULL;
    for (int idx = 0; idx < length; ++idx)
    {
        ListNode *newNode = (ListNode *)malloc(sizeof(ListNode)); // 为链表中的每个节点分配内存
        if (newNode == NULL)
        {
            printf("Memory allocation failed.\n");
            exit(0);
        }
        newNode->var.value = idx; // 为链表中的每个节点赋值
        newNode->ptr.next = NULL;

        if (NULL == list->ptr.head) // 如果表头节点的ptr.head为NULL，则将ptr.head指向当前节点，
        {                           // 将pTailNode指向当前节点，跳过本次循环，继续下一次循环
            list->ptr.head = newNode;
            list->var.size = 1;
            pTailNode = newNode;
            continue;
        }

        pTailNode->ptr.next = newNode;
        pTailNode = newNode;
        ++(list->var.size);
    }

    pTailNode->ptr.next = list->ptr.head; // 将尾节点的next指针指向头节点，形成一个循环链表

    return list;
}

void FreeList(ListHead list)
{
    ListNode *pCurrentNode = list->ptr.head;
    free(list); // 释放指向循环链表的表头节点

    if (NULL == pCurrentNode) // 如果循环链表的头节点为NULL，则直接返回
    {
        return;
    }

    ListNode *pHead = pCurrentNode;
    pCurrentNode = pCurrentNode->ptr.next;
    while (pCurrentNode != pHead) // 循环条件为pCurrentNode不等于pHead
    {
        ListNode *pTemp = pCurrentNode;
        pCurrentNode = pCurrentNode->ptr.next;
        free(pTemp);
    }

    free(pHead); // 释放循环链表的头节点
}

void CountOff(int length, int m, int out[]) // CountOff函数的实现
{
    if (m < 1) // 如果m小于1，则直接返回
    {
        return;
    }

    ListHead list = CreateList(length);             // 创建一个长度为length的循环链表
    if ((NULL == list) && (NULL == list->ptr.head)) // 如果创建循环链表失败，则直接返回
    {
        return;
    }

    if (1 == length) // 如果循环链表的长度为1，则直接将第一个节点的值保存在out数组中，释放循环链表，直接返回
    {
        out[list->ptr.head->var.value] = 1;
        FreeList(list);
        return;
    }

    ListNode *pCurrentNode = list->ptr.head;
    ListNode *pPreNode = pCurrentNode;
    while (pPreNode->ptr.next != pCurrentNode)
    {
        pPreNode = pPreNode->ptr.next; // 找到循环链表的头节点的上一个节点
    }
    for (int cnt = 0; cnt < length; ++cnt)
    {
        if (1 == list->var.size) // 如果循环链表的长度为1，将最后一个节点的值保存在out数组中，释放循环链表，直接返回
        {
            out[pCurrentNode->var.value] = cnt + 1;
            FreeList(list);
            return;
        } // 卫语句

        // int remainder = (m - 1) % list->var.size; // (m-1)对length取余，防止(m-1)大于length

        for (int step = 0; step < (m - 1); ++step) // 找到第m个节点
        {
            pPreNode = pCurrentNode;
            pCurrentNode = pCurrentNode->ptr.next;
        }

        out[pCurrentNode->var.value] = cnt + 1; // 将第m个节点的值保存在out数组中
        --(list->var.size);                     // 将循环链表的长度减1

        ListNode *pTemp = pCurrentNode;        // 保存第m个节点
        pCurrentNode = pCurrentNode->ptr.next; // 将当前节点指向后一个节点
        pPreNode->ptr.next = pCurrentNode;     // 将第m个节点的前一个节点的next指针指向第m个节点的next指针指向的节点
        if (pTemp == list->ptr.head)           // 如果第m个节点为头节点，则将头节点指向第m个节点的next指针指向的节点
        {
            list->ptr.head = pCurrentNode;
        }
        free(pTemp); // 释放第m个节点
    }

    FreeList(list); // 释放循环链表
}

输入样例：

11 3

输出样例：

4 10 1 7 5 2 11 9 3 6 8
James_Xue_2023
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

James_Xue_2023

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值