day18homework

使用循环链表完成约瑟夫环问题

1.c

#include "1.h"
//创建循环链表
NodePtr list_create()
{
    //在堆区申请一个头结点
    NodePtr L = (NodePtr)malloc(sizeof(Node));
    if (NULL == L)
    {
        printf("创建失败\n");
        return NULL;
    }
 
    //初始化
    L->len = 0;
    L->next = L; //头结点指针域指向自己
 
    printf("创建成功\n");
    return L;
}
//链表判空
int list_empty(NodePtr L)
{
    return L->next == L;
}
//链表申请空间封装节点
NodePtr apply_node(datatype e)
{
    //堆区申请一个节点的空间
    NodePtr p = (NodePtr)malloc(sizeof(Node));
    if (NULL == p)
    {
        printf("申请失败\n");
        return NULL;
    }
 
    //给节点赋值
    p->data = e;
    p->next = NULL;
 
    return p;
}
//按位置进行查找
NodePtr list_search_pos(NodePtr L, int pos)
{
    //判断逻辑
    if (NULL == L || pos < 0 || pos > L->len)
    {
        printf("查找失败\n");
        return NULL;
    }
 
    //查找逻辑
    NodePtr q = L;
    for (int i = 0; i < pos; i++)
    {
        q = q->next;
    }
 
    return q;
}
//链表尾插
int list_insert_tail(NodePtr L, datatype e)
{
    //判断逻辑
    if (NULL == L)
    {
        printf("插入失败\n");
        return -1;
    }
 
    //找到最后一个节点
    NodePtr q = list_search_pos(L, L->len);
 
    //封装节点
    NodePtr p = apply_node(e);
    if (NULL == p)
    {
        return -1;
    }
 
    //插入逻辑
    p->next = q->next;
    q->next = p;
 
    //表的变化
    L->len++;
    printf("插入成功\n");
    return 0;
}
//链表遍历
int list_show(NodePtr L)
{
    //判断逻辑
    if (NULL == L || list_empty(L))
    {
        printf("遍历失败\n");
        return -1;
    }
 
    //遍历逻辑
    NodePtr q = L->next;
    while (q != L)
    {
        printf("%d\t", q->data);
        q = q->next; //继续访问下一个
    }
    printf("\n");
}
//链表的头删
int list_delete_head(NodePtr L)
{
    //判断逻辑
    if (NULL == L || list_empty(L))
    {
        printf("删除失败\n");
        return -1;
    }
 
    //头删逻辑
    NodePtr p = L->next; //标记
    L->next = p->next;   //孤立
    free(p);             //删除
    p = NULL;
 
    //表长变化
    L->len--;
    printf("删除成功\n");
    return 0;
}
//链表销毁
void list_destroy(NodePtr L)
{
    //判断逻辑
    if (NULL == L)
    {
        printf("释放失败\n");
        return;
    }
 
    //删除节点
    while (!list_empty(L))
    {
        list_delete_head(L);
    }
 
    //释放头结点
    free(L);
    L = NULL;
    printf("销毁成功\n");
}
void create(NodePtr L, datatype n)
{
    for (int i = 1; i <= n; i++)
    {
        list_insert_tail(L, i);
    }
}
// 约瑟夫环问题求解
void josephus(NodePtr L, int m)
{
    NodePtr p = L->next; // 从第一个节点开始
    while (p->len > 1)
    {
        for (int i = 1; i < m - 1; i++)
        {
            p = p->next;
        }
        list_delete_head(p);
    }
    printf("最后活着的是: %d\n", p->data);
}

2.c

#include "1.h"
int main()
{
    NodePtr L = list_create();
    if (NULL == L)
    {
        return -1;
    }
    int n, m;
    printf("请输入总人数n和报数间隔m");
    printf("例如（m=2,从一号开始则三号死）");
    scanf("%d %d", &n,&m);
    create(L, n);
    list_show(L);
    josephus(L, m);
    //调用释放函数
    list_destroy(L);
    L = NULL;
    return 0;
}

1.h

#ifndef LINKLIST_H
#define LINKLIST_H
#include <myhead.h>
//定义数据类型
typedef int datatype;
 
//定义结点类型
typedef struct Node
{
    union
    {
        int len;       //头结点数据域
        datatype data; //普通结点数据域
    };
 
    struct Node *next; //指针域
} Node, *NodePtr;
//创建循环链表
NodePtr list_create();
//链表判空
int list_empty(NodePtr L);
//链表申请空间封装节点
NodePtr apply_node(datatype e);
//按位置进行查找
NodePtr list_search_pos(NodePtr L, int pos);
//链表尾插
int list_insert_tail(NodePtr L, datatype e);
//链表遍历
int list_show(NodePtr L);
//链表的头删
int list_delete_head(NodePtr L);
//链表销毁
void list_destroy(NodePtr L);
void create(NodePtr L, datatype n);
// 约瑟夫环问题求解
void josephus(NodePtr L, int m);
#endif

使用栈，完成进制转换

输入：一个整数，进制数

输出：该数的对应的进制数

1.c

#include"1.h"
int main() {
    int number, base;
    printf("请输入一个整数和进制数（用空格隔开）：");
    scanf("%d %d", &number, &base);
    printf("转换后的进制数为：");
    convertToBase(number, base);
    return 0;
}

2.c

#include"1.h"
void push(Stack *stack, int value)
{
    if (stack->top == MAX_SIZE - 1)
    {
        printf("栈已满，无法插入新元素");
        return;
    }
    stack->data[++stack->top] = value;
}
 
int pop(Stack *stack)
{
    if (stack->top == -1)
    {
        printf("栈为空，无法弹出元素");
        return -1;
    }
    return stack->data[stack->top--];
}
 
void convertToBase(int number, int base)
{
    Stack stack;
    stack.top = -1;
 
    while (number > 0)
    {
        push(&stack, number % base);
        number /= base;
    }
 
    while (stack.top != -1)
    {
        int digit = pop(&stack);
        if (digit < 10)
        {
            printf("%d", digit);
        }
        else
        {
            printf("%c", 'A' + digit - 10);
        }
    }
    printf("\n");
}

1.h

#ifndef SEQSTACK_H
#define SEQSTACK_H
#include<myhead.h>
#define MAX_SIZE 100
typedef struct {
    int data[MAX_SIZE];
    int top;
} Stack;
void push(Stack *stack, int value);
int pop(Stack *stack);
void convertToBase(int number, int base);
 
 
 
#endif