嵌入式开发C语言学习day18-华清作业7.22

笔记

作业

循环链表实现约瑟夫环

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

typedef int datatype;

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

//建立头节点
NodePtr list_create();

//申请普通节点
NodePtr apply_create(datatype e);

//判空
int list_empty(NodePtr L);

// 尾插录入数据
int list_input(NodePtr L, datatype e);

//遍历数据
int list_show(NodePtr L);

// 约瑟夫环
void josephus(NodePtr L, int m, int n);



#endif

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

// 申请普通节点
NodePtr apply_create(datatype e)
{
    NodePtr p = (NodePtr)malloc(sizeof(Node));
    if (NULL == p)
    {
        printf("创建节点失败\n");
        return NULL;
    }
    p->data = e;
    p->next = NULL;
    printf("创建节点成功\n");
    return p;
};

// 判空
int list_empty(NodePtr L)
{
    return L->next == L;
};

// 按位置进行查找
NodePtr list_serach_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;
    }
};

// 尾插录入数据
int list_input(NodePtr L, datatype e)
{
    // 判断逻辑
    if (NULL == L)
    {
        printf("录入数据失败\n");
        return -1;
    }
    NodePtr p = apply_create(e);
    if (NULL == p)
    {
        return -1;
    }
    if (L->len == 0)
    {
        p->next = L;
        L->next = p;
        L->len++;
    }
    else
    {

        NodePtr q = L;
        while (q->next != L)
        {
            q = q->next;
        }
        p->next = L;
        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");
    return 0;
};

// 约瑟夫环
void josephus(NodePtr L, int m, int len)
{
    
    NodePtr p = L->next;
    NodePtr prev = L;
    int count = 1;

    while (L->len > 1)
    {
        if (count == m)
        {
        
            prev->next = p->next;
            printf("删除节点: %d\n", p->data);
            free(p);
            p = prev->next;
            // 链表的长度减 1
            L->len--;
            count = 1;
        }
        else
        {
            prev = p;
            p = p->next;
            count++;
        }
    }
    printf("最后剩下的节点: %d\n", p->data);
}

#include "Joseph.h"
int main(int argc, char const *argv[])
{
    NodePtr L = list_create();
    if (NULL == L)
    {
        return -1;
    }
    int x,e;
    printf("请输入要录入的数据的个数:");
    scanf("%d",&x);
    for (int i = 0; i < x; i++)
    {
        printf("请输入第%d个数",i+1);
        scanf("%d",&e);
        list_input(L,e);
    }
    int y;//需要的间隔
    printf("请输入需要间隔的个数:");
    scanf("%d",&y);
    josephus(L,y,L->len);
    list_show(L);
}

使用栈完成二进制转换

#ifndef BINARY_H
#define BINARY_H
#include <myhead.h>
#define MAX 100

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


//创建栈
StackPtr stack_create();

//判空
int stack_empty();

//判满
int stack_full();

//入栈
void stack_push();

//出栈
void stack_pop();

//遍历栈
void stack_show();

// 销毁栈
void stack_destroy();

// 生成二进制并入栈
void binary_to_stack(StackPtr S, int x);
#endif 

#include "binary.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;
    }
    memset(S->data, 0, 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;
}

// 入栈
void stack_push(StackPtr S, datatype e)
{
    if (NULL == S || stack_full(S))
    {
        printf("入栈失败\n");
        return;
    }
    S->top++;
    S->data[S->top] = e;
    printf("入栈成功\n");
};

// 出栈
void stack_pop(StackPtr S)
{
    if (NULL == S || stack_empty(S))
    {
        printf("出栈失败\n");
        return;
    }
    printf("%d\t", S->data[S->top]);
    S->top--;
};

// 销毁栈
void stack_destroy(StackPtr S)
{
    while (S != NULL)
    {
        free(S->data);
        free(S);
        S = NULL;
    }
    printf("销毁成功\n");
};

// 生成二进制并入栈
void binary_to_stack(StackPtr S, int x)
{
    while (x)
    {
        stack_push(S, x % 2);
        x /= 2;
    }
}

#include "binary.h"

int main(int argc, char const *argv[])
{
    StackPtr S = stack_create();
    if (NULL == S)
    {
        return -1;
    }
    int x;
    printf("请输入数据:");
    scanf("%d",&x);
    binary_to_stack(S,x);
    while (!stack_empty(S))
    {
        stack_pop(S);
    }
    printf("\n");
    stack_destroy(S);
    S = NULL;

    return 0;
}