20240722作业

main.c

#include"zhan.h"
int main(int argc, char const *argv[])
{
    datatype a=0,b=0;
    StackPtr S=stack_create();
    if(NULL==S)
    {
        return -1;
    }
    stack_push(S,a,b);
    stack_show(S);
    return 0;
}
 

zhan.c

#include"zhan.h"

//创建栈
StackPtr stack_create()
{
    StackPtr S=(StackPtr)malloc(sizeof(Stack));
    if(NULL==S)
    {
        printf("创建失败\n");
        return NULL;
    }
    S->data=(datatype *)malloc(sizeof(datatype)*MAX);
    if(NULL==S->data)
    {
        printf("创建失败\n");
        return NULL;
    }
    bzero(S->data,sizeof(datatype)*MAX);
    S->top=-1;
    printf("创建完成\n");
    return S;
}

//判空
int stack_empty(StackPtr S)
{
    return S->top==-1;
}

//判满
int stack_full(StackPtr S)
{
    return S->top==MAX-1;
}

//入栈
void stack_push(StackPtr S,datatype a,datatype b)
{
    printf("请输入一个整数和要转换的进制数:");
    scanf("%d %d",&a,&b);
    printf("\n");
    if(NULL==S||S->top==MAX-1||a<1||b<2)
    {
        printf("转换失败\n");
        return ;
    }
    while(a>0)
    {
        S->top++;
        S->data[S->top]=a%b;
        a/=b;        
    }
    printf("入栈成功\n");
}

//遍历
void stack_show(StackPtr S)
{
    if(NULL==S||stack_empty(S))
    {
        printf("遍历失败\n");
        return ;
    }
    printf("从栈顶到栈底元素分别是:");
    for(int i=S->top;i>=0;i--)
    {
        printf("%d\t",S->data[i]);
    }
    printf("\n");
}

zhan.h

#ifndef ZHAN_H
#define ZHAN_H
#include<head.h>

typedef int datatype;
#define MAX 8

typedef struct
{
    datatype *data;
    int top;
}Stack,*StackPtr;

//创建栈
StackPtr stack_create();

//判空
int stack_empty(StackPtr S);

//判满
int stack_full(StackPtr S);

//入栈
void stack_push(StackPtr S,datatype a,datatype b);

void stack_show(StackPtr S);

#endif

main.c

#include "xunhuan.h"
int main(int argc, char const *argv[])
{
    datatype a=0,b=0;
    NodePtr L=list_create();
    list_ysf(L,a,b);
    L=NULL;
    list_show(L);
    return 0;
}
xunhuan.h

#ifndef XUNHUAN_H
#define XUNHUAN_H
#include <head.h>

typedef int datatype;
typedef struct
{
    union
    {
        int len;
        datatype data;
    };
    struct Node *next;
}Node,*NodePtr;

//创建循环链表
NodePtr list_create();

//链表判空
int list_empty(NodePtr L);

//申请节点封装数据
NodePtr apply_node(datatype e);

void list_ysf(NodePtr L,datatype a,datatype b);

int list_show(NodePtr L);

#endif

xunhuan.c

#include "xunhuan.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;
}

void list_ysf(NodePtr L,datatype a,datatype b)
{
    printf("请输入总人数和杀人间隔:");
    scanf("%d %d",&a,&b);
    for(int i=1;i<=a;i++)
    {
    NodePtr q=list_search_pos(L,L->len);
    NodePtr p=apply_node(i);
    p->next=q->next;
    q->next=p;
    L->len++;
    }
    datatype x=0;
    while(a!=1)
    {
        if(b>a){
            b=b-a;
        }
        x+=b;
        while(x>a){
            x-=a;
        }
       NodePtr p=list_search_pos(L,x);
       NodePtr q=list_search_pos(L,x-1);
       if(x==1){
            q=list_search_pos(L,a-1);
       }
       printf("%d\n",p->data);
       q->next=p->next;
        free(p);
        p=NULL;
       L->len--;
       a--;
       x--;
    }
    free(L);
    L=NULL;
}

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");
}