约瑟夫环 和 进制转换（栈）

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

#include <stdio.h>
#include <stdlib.h>
 
typedef struct node {
    int number;
    struct node* next;
} Node;
 
// 初始化一个循环链表，表示圆桌上的人
Node* initlink(int n) {
    Node* head = (Node*)malloc(sizeof(Node));
    head->number = 1;
    head->next = NULL;
    Node* bbc = head;
    
    // 创建 n-1 个节点，并连接成循环链表
    for (int i = 2; i <= n; i++) {
        Node* body = (Node*)malloc(sizeof(Node));
        body->number = i;
        body->next = NULL;
        bbc->next = body;
        bbc = bbc->next; 
    }
    
    bbc->next = head;
    return head;
}
 
// 找到第 k 个人并开始报数，数到第 m 个人出列
void find_kill(Node* head, int k, int m) {
    Node* tail = head;
    while (tail->next != head) {
        tail = tail->next;
    }
    
    Node* p = head;
    while (p->number != k) {
        tail = p;
        p = p->next;
    }
    
    // 从第 k 个人开始报数，直到只剩下一个人
    while (p->next != p) {
        for (int i = 1; i < m; i++) {
            tail = p;
            p = p->next;
        }
        
        // 删除第 m 个人出列，并释放内存
        tail->next = p->next;
        printf("出列人的编号为: %d\n", p->number);
        
        Node* temp = p;
        p = p->next;
        free(temp);
    }
    
    printf("出列人的编号为: %d\n", p->number);
    free(p);
}
 
int main() {
    printf("输入圆桌上的人数 n: ");
    int n;
    scanf("%d", &n);
    Node* head = initlink(n);
    
    printf("从第 k 人开始报数 (k >= 1 且 k <= %d): ", n);
    int k;
    scanf("%d", &k);
    
    printf("数到第 m 个人出列：");
    int m;
    scanf("%d", &m);
    
    find_kill(head, k, m);
    
    return 0; 
}

1.1运行结果：

2.使用栈完成进制转换

   zhuan.h

#ifndef ZHUAN_H
#define ZHUAN_H
#include<myhead.h>

typedef int datatype;
#define MAX 50

typedef struct 
{
    datatype *data;
    int top;
}Convert,*Convertptr;

//创建栈
Convertptr con_create();

//判空
int con_empty(Convertptr L);

//判满
int con_full(Convertptr L);

//入栈
void con_push(Convertptr L,datatype e);

//出栈
void con_pop(Convertptr L);

//二进制转换
void con_zhuan2(Convertptr L,int n);

//四进制转换
void con_zhuan4(Convertptr L,int n);

//八进制转换
void con_zhuan8(Convertptr L,int n);

//遍历栈
void con_show(Convertptr L);

//销毁栈
void con_destroy(Convertptr L);

#endif

  zhuan.c

#include"zhuan.h"

//创建栈
Convertptr con_create()
{
    //在堆区申请一个栈的大小
    Convertptr L=(Convertptr)malloc(sizeof(Convert));
    if(NULL==L)
    {
        printf("栈创建失败\n");
        return NULL;
    }
    //程序执行至此,表示栈已申请出来了,但是存储栈的空间还没申请
    L->data=(datatype*)malloc(sizeof(datatype)*MAX);
    if(NULL==L->data)
    {
        printf("存储空间创建失败\n");
        return NULL;
    }
    //给空间内容初始化
    memset(L->data,0,sizeof(datatype)*MAX);
    //栈顶元素变量初始化
    L->top=-1;
    printf("创建成功\n");
    return L;
}

//判空
int con_empty(Convertptr L)
{
    return L->top==-1;
}

//判满
int con_full(Convertptr L)
{
    return L->top==MAX-1;
}

//入栈
void con_push(Convertptr L,datatype e)
{
    //判断逻辑
    if(NULL==L || con_full(L))
    {
        printf("入栈失败:栈无效或已满\n");
        return;
    }
    //入栈逻辑
    L->top++;
    L->data[L->top]=e;
}

//出栈
void con_pop(Convertptr L)
{
    if(NULL==L|| con_empty(L))
    {
        printf("出栈失败\n");
        return ;
    } 
    //出栈逻辑
    L->top--;
}

//2进制转换
void con_zhuan2(Convertptr L,int n)
{
    if(NULL==L || n<0 || con_full(L))
    {
        printf("转换失败\n");
        return ;
    }
    datatype q=0;
    while(n!=0)
    {
        q=n%2;
        con_push(L,q);
        n=n/2;
    }
    //调用遍历函数
    printf("该整数转换为二进制数为:");
    con_show(L);
    int x=L->top;
    for(int i=0;i<=x;i++)
    {
        con_pop(L);
    }
}

//4进制转换
void con_zhuan4(Convertptr L,int n)
{
    if(NULL==L || n<0 || con_full(L))
    {
        printf("转换失败\n");
        return ;
    }
    datatype q=0;
    while(n!=0)
    {
        q=n%4;
        con_push(L,q);
        n=n/4;
    }
    printf("该整数转换为四进制数为:");
    //调用遍历函数
    con_show(L);
    int x=L->top;
    for(int i=0;i<=x;i++)
    {
        con_pop(L);
    }
}

//8进制转换
void con_zhuan8(Convertptr L,int n)
{
    if(NULL==L || n<0 || con_full(L))
    {
        printf("转换失败\n");
        return ;
    }
    datatype q=0;
    while(n!=0)
    {
        q=n%8;
        con_push(L,q);
        n=n/8;
    }
    printf("该整数转换为八进制数为:");
    //调用遍历函数
    con_show(L);
}



//遍历栈
void con_show(Convertptr L)
{
    //判断逻辑
    if(NULL==L || con_empty(L))
    {
        printf("遍历失败\n");
        return;
    }
    for(int i=L->top;i>=0;i--)
    {
        printf("%d",L->data[i]);
    }
    printf("\n");
}

//销毁栈
void con_destroy(Convertptr L)
{
    //判断逻辑
    if(L!=NULL)
    {
        //销毁栈的储存空间
        free(L->data);
        L->data=NULL;
        //销毁栈
        free(L);
        L=NULL;
    }
    printf("销毁成功\n");
}

  main.c

#include"zhuan.h"
#include<myhead.h>

int main(int argc, char const *argv[])
{
    Convertptr L=con_create();
    if(NULL==L)
    {
        return -1;
    }

    int n=0;
    printf("输入你要转换的整数:");
    scanf("%d",&n);
    //调用数据转换函数
    con_zhuan2(L,n);
    con_zhuan4(L,n);
    con_zhuan8(L,n);


    //调用销毁栈函数
    con_destroy(L);
    L=NULL;



    return 0;
}

2.1运行结果