1、约瑟夫环
代码：
/*******************************************/
文件名：josepro.c
功能：函数内容
/*******************************************/
#include "josepro.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;
}
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++;
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("%c\t", q->data);
q = q->next;
}
printf("\n");
return 0;
}
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--;
return 0;
}
void josepho(NodePtr L)
{
NodePtr pt = L, q;
if (L == NULL)
{
//链表空
return;
}
int l;
printf("请输入数到几开始：");
scanf("%d", &l);
//调整初始位置到需要结点
for (int i = 0; i < l; i++)
{
pt = pt->next;
}
//n个人循环n次，n等于链表长度
int n = L->len;
int k;
printf("请输入数到几出列：");
scanf("%d", &k);
printf("\n依次出圈的人员编号是:\n");
for (int i = 0; i < n; i++)
{
//循环k-1次找到要删除的前一个结点
for (int j = 0; j < k - 1; j++)
{
pt = pt->next;
//如果找到的是头结点，绕过 （但循环次数加1）
if (pt == L)
{
j--;
}
}
// q是要删除的结点
q = pt->next;
// 如果删除的结点q是头结点，绕过
if (q == L)
{
q = L->next;
pt = L;
}
//删除
printf("%c\t", q->data);
pt->next = q->next; //孤立要删除的节点
free(q); //释放要删除的节点
L->len--;
}
printf("\n");
}
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");
}
/*******************************************/
文件名：josepro.h
功能：函数声明
/*******************************************/
#ifndef JOSEPRO_H
#define JOSEPRO_H
#include<stdio.h>
#include<stdlib.h>
typedef char 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 josepho(NodePtr L);
void list_destroy(NodePtr L);
#endif
/*******************************************/
文件名：main.c
功能：函数内容
/*******************************************/
#include "josepro.h"
int main(int argc, char const *argv[])
{
NodePtr L = list_create();
if (NULL == L)
{
return -1;
}
list_insert_tail(L, 'a');
list_insert_tail(L, 'b');
list_insert_tail(L, 'c');
list_insert_tail(L, 'd');
list_insert_tail(L, 'e');
list_insert_tail(L, 'f');
list_insert_tail(L, 'g');
list_insert_tail(L, 'h');
list_insert_tail(L, 'i');
list_insert_tail(L, 'j');
list_insert_tail(L, 'k');
list_show(L);
josepho(L);
list_destroy(L);
L = NULL;
return 0;
}
结果：
2、进制转换
代码：
/*******************************************/
文件名：josepro.c
功能：函数内容
/*******************************************/
#include "jinzhi.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 e)
{
if (NULL == S || stack_full(S))
{
printf("入栈失败\n");
return;
}
S->top++;
S->data[S->top] = e;
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", S->data[i]);
}
printf("\n");
}
void stack_destroy(StackPtr S)
{
if (S != NULL)
{
free(S->data);
S->data = NULL;
free(S);
S = NULL;
}
printf("销毁成功\n");
}
void jinzhi_change(StackPtr S)
{
int in = 0;
printf("请输入初始十进制数：");
scanf("%d", &in);
int ch = 0;
printf("请输入要转换的进制：");
scanf("%d", &ch);
int out = 0;
int temp = 0;
//in最终为0说明已经全部入栈
while (in != 0)
{
temp = in % ch;
//从最低位入栈，遍历时就会是最后显示
stack_push(S, temp);
in = in / ch;
}
}
/*******************************************/
文件名：josepro.h
功能：函数声明
/*******************************************/
#ifndef JINZHI_H
#define JINZHI_H
#include <stdio.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 stack_push(StackPtr S, datatype e);
void stack_show(StackPtr S);
void stack_destroy(StackPtr S);
void jinzhi_change(StackPtr S);
#endif
/*******************************************/
文件名：main.c
功能：函数内容
/*******************************************/
#include "jinzhi.h"
int main(int argc, char const *argv[])
{
StackPtr S = stack_create();
if (NULL == S)
{
return -1;
}
jinzhi_change(S);
stack_show(S);
stack_destory(S);
S = NULL;
return 0;
}
结果：
思维导图：
