1＞ 将双向链表和循环链表自己实现一遍,至少要实现创建、增、删、改、查、销毁工作2＞ 使用循环链表完成约瑟夫环问题

头文件 :

#ifndef DOUBLELINKLIST_H
#define DOUBLELINKLIST_H
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef char datatype;
typedef struct Node {
    union {
        int len;
        datatype data;
    };
    struct Node* next;
}Node, * LinkList;
LinkList list_create();
int list_empty(LinkList L);
LinkList apply_node(datatype e);
LinkList list_search_pos(LinkList L, int pos);
int list_insert_end(LinkList L, datatype e);
int list_printf(LinkList L);
int list_delete_head(LinkList L);
void list_destroy(LinkList L);
int  list_search(LinkList L, datatype e);
int list_delete_pos(LinkList L, int pos);
int  yuesefu(LinkList L, int pos, int num);
#endif

函数：

#include"DoubleLinkList.h"
LinkList list_create() {
    LinkList L = (LinkList)malloc(sizeof(Node));
    if (NULL == L) {
        printf("err\n");
        return NULL;
    }
    L->len = 0;
    L->next = L;
    printf("successful\n");
    return L;
}
int list_empty(LinkList L) {
    return L->next == L;
}
LinkList apply_node(datatype e)
{
    LinkList p = (LinkList)malloc(sizeof(Node));
    if (NULL == p) {
        printf("err\n");
        return NULL;
    }
    p->data = e;
    p->next = NULL;
    printf("succeed!\n");
    return p;
}
LinkList list_search_pos(LinkList L, int pos) {
    if (NULL == L || pos<0 || pos>L->len) {
        printf("err\n");
        return NULL;
    }
    LinkList p = L;
    for (int i = 0; i < pos; i++)
    {
        p = p->next;
    }
    return p;
}

int list_insert_end(LinkList L, datatype e) {
    if (NULL == L) {
        printf("err\n");
        return -1;
    }
    LinkList q = apply_node(e);
    LinkList p = list_search_pos(L, L->len);
    q->next = p->next;
    p->next = q;
    L->len++;
    printf("ok\n");
    return 0;
}
int list_printf(LinkList L) {
    if (NULL == L || list_empty(L)) {
        printf("err\n");
        return -1;
    }
    LinkList p = L->next;
    while (p != L) {
        printf("%c\t", p->data);
        p = p->next;
    }
    printf("\n");
    return 0;
}

int list_delete_head(LinkList L) {
    if (NULL == L || list_empty(L)) {
        printf("err\n");
        return -1;
    }
    LinkList p = L->next;
    L->next = p->next;
    free(p);
    p = NULL;
    L->len--;
    printf("OK\n");
    return 0;

}
void list_destroy(LinkList L) {
    if (NULL == L) {
        printf("err\n");
    }
    if (!list_empty(L)) {
        list_delete_head(L);
    }
    free(L);
    L = NULL;
    printf("OK\n");
}
int  list_search(LinkList L, datatype e) {
    if (NULL == L || list_empty(L)) {
        printf("err\n");
        return -1;
    }
    LinkList p = L->next;
    for (int i = 0; i < L->len; i++) {
        if (p->data == e) {
            return i + 1;
        }
        p = p->next;
    }
    return -1;
}
int list_delete_pos(LinkList L, int pos)
{
    if (NULL == L || list_empty(L)) {
        printf("err\n");
        return -1;
    }
    LinkList p = L;
    for (int i = 1; i < pos; i++) {
        p = p->next;
    }
    LinkList q = p->next;
    p->next = p->next->next;
    free(q);
    q = NULL;
    L->len--;
    return 0;
}
int  yuesefu(LinkList L, int pos, int num) {
    if (NULL == L || list_empty(L) || pos<1 || pos>L->len) {
        printf("err\n");
        return -1;
    }
    LinkList ptr = L;
    LinkList p = L->next;

        for (int i = 1; i < pos; i++) {
            p = p->next;
        }
        while (!list_empty(L))
        {
            for (int j = 0; j < num; j++) {
                p = p->next;
                if (p == ptr) {
                    p = p->next;
                }
            }
            printf("%c\t", p->data);
            int k = list_search(L, p->data);
            LinkList q = p->next;
            if (q == L) {
                q = q->next;
            }
            //printf("%d", k);
            list_delete_pos(L, k);

            p = q;
            /*for (int j = 0; j < num; j++) {
                p = p->next;
                if (p == ptr) {
                    p = p->next;
                }
            }*/
        }
    printf("\n");
    return 0;

}
主函数：

#include"DoubleLinkList.h"
int main() {
    LinkList L = list_create();
    if (NULL == L) {
        return -1;
    }
    list_insert_end(L, 'a');
    list_insert_end(L, 'b');
    list_insert_end(L, 'c');
    list_insert_end(L, 'd');
    list_insert_end(L, 'e');
    list_insert_end(L, 'f');
    list_printf(L);
    /*list_delete_pos(L,6);
    list_printf(L);
    list_delete_pos(L, 4);*/
    yuesefu(L, 3, 2);
    //list_printf(L);
    return 0;
}

进制转化：

头文件：

#ifndef STACK_H
#define STACK_H
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef int datatype;
#define MAX 20
typedef struct {
    datatype* data;
    int top;
}Stack, * StackPtr;
StackPtr stack_create();
int stack_empty(StackPtr S);
int stack_full(StackPtr S);
void push(StackPtr S, datatype e);
void pop(StackPtr S);
void stack_printf(StackPtr S);
datatype* stack_get_top(StackPtr S);
void destroy(StackPtr S);
StackPtr jinzhi(StackPtr S, int k);
#endif
函数：

#include"stack.h"
StackPtr stack_create() {
    StackPtr S = (StackPtr)malloc(sizeof(Stack));
    if (NULL == S) {
        printf("err\n");
        return NULL;
    }
    S->data = (datatype*)malloc(sizeof(datatype) * MAX);
    if (NULL == S->data) {
        printf("err\n");
        return NULL;
    }
    memset(S->data, 0, sizeof(datatype) * MAX);
    S->top = -1;
    printf("successful\n");
    return S;
}
int stack_empty(StackPtr S) {
    return S->top == -1;
}
int stack_full(StackPtr S) {
    return S->top == MAX - 1;
}
void push(StackPtr S, datatype e) {
    if (NULL == S ||stack_full( S)) {
        printf("err\n");
        return;
    }
    S->top++;
    S->data[S->top] = e;
    
}
void pop(StackPtr S) {
    if (NULL == S || stack_empty(S)) {
        printf("err!\n");
    }
    printf("%d\t", S->data[S->top]);
    S->top--;
}
void stack_printf(StackPtr S) {
    if (NULL == S || stack_empty(S)) {
        printf("err!\n");
    }
    for (int i = S->top; i >= 0; i++) {
        printf("%d\t", S->data[i]);
    }
    printf("\n");

}
datatype* stack_get_top(StackPtr L) {
    if (NULL == L || stack_empty(L)) {
        printf("err!\n");
        return NULL;
    }
    return L->data + L->top;
}
void destroy(StackPtr S) {
    if (S != NULL) {
        free(S->data);
        S->data = NULL;
        free(S);
        S = NULL;
    }
    printf("successful!\n");
}
main主函数：

#include"stack.h"
int main() {
    StackPtr S = stack_create();
    if (NULL == S) {
        printf("err\n");
        return -1;
    }
    printf("请输入要转化的进制数（2-8）:");
    int k = 0, q = 0;
    scanf("%d",&q);
    printf("请输入要被转化的数:");
    scanf("%d", &k);
    while(k!=0){
        push(S,k%2);
        k=k/2;
    }
    while (!stack_empty(S))
    {
        pop(S);
    }
    //return 0;
}