2024.7.22

最新推荐文章于 2024-07-24 10:46:51 发布

Tak1Na

最新推荐文章于 2024-07-24 10:46:51 发布

阅读量119

点赞数 2

文章标签： c语言

本文链接：https://blog.csdn.net/Tak1Na/article/details/140617005

版权

使用栈，完成进制转换

输入：一个整数，进制数

输出：该数的对应的进制数

stack.h
#ifndef STACK_H
#define STACK_H
#include<myhead.h>
#define MAX 100
typedef int datatype;
typedef struct 
{
	datatype *data;
	int top;
}stack,*stackPtr;

stackPtr create();

int empty(stackPtr S);

int full(stackPtr S);

void input(stackPtr S);

void output(stackPtr S);

void show(stackPtr S);

void destroy(stackPtr S);
#endif

stack.c
#include "stack.h"
stackPtr 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 empty(stackPtr S)
{
	return S->top == -1;
}

int full(stackPtr S)
{
	return S->top == MAX-1;
}

void input(stackPtr S)
{
	if(NULL==S||full(S))
	{
		printf("入栈失败\n");
		return;
	}
	printf("请输入要转化成二进制的数：");
	int e=0;
	scanf("%d",&e);
	while(e!=0)
	{	
		S->top++;
		S->data[S->top] = e%2;
		e = e/2;
	}
}

void output(stackPtr S)
{

}
void show(stackPtr S)
{
	if(NULL==S||empty(S))
	{
		printf("遍历失败\n");
		return;
	}
	printf("二进制数为：");
	for(int i=S->top;i>=0;i--)
	{
		printf("%d\t",S->data[i]);
	}
	printf("\n");
}
void destroy(stackPtr S)
{
	if(NULL==S)
	{
		printf("销毁失败\n");
		return;
	}
	free(S->data);
	free(S);
	S=NULL;
	printf("销毁成功\n");
}

main.c
#include"stack.h"
int main(int argc, const char *argv[])
{
	stackPtr S = create();
	if(NULL==S)
	{
		return -1;
	}
	input(S);
	show(S);
	destroy(S);
	return 0;
}

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

lplink.h
#ifndef LPLINK_H
#define LPLINK_H
#include<myhead.h>
//定义数据类型
typedef int 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);

//链表遍历
int list_show(NodePtr L);

//链表的头删
int list_delete_head(NodePtr L);

//链表的销毁
void list_destroy(NodePtr L);

int kill(NodePtr L);
#endif

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

//链表尾插
int list_insert_tail(NodePtr L)
{
	//判断逻辑
	if(NULL==L)
	{
		printf("插入失败\n");
		return -1;
	}
	printf("请输入总人数：");
	int sum=0;
	scanf("%d",&sum);
	for(int i=0;i<sum;i++)
	{
		int e=0;
		printf("请输入第%d个人的序号：",i+1);
		scanf("%d",&e);
		//找到最后一个节点
		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("%d\t",q->data);
		q = q->next;
	}
	printf("\n");
}

//链表的头删
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--;
	printf("删除成功\n");
	return 0;
}

//链表的销毁
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");
}

int kill(NodePtr L)
{
	if(NULL==L||list_empty(L))
	{
		printf("error\n");
		return -1;
	}
	NodePtr a = list_search_pos(L,L->len);
	a->next = L->next; 			//把最后一个节点指向第一
								//个有数据的节点
	printf("请输入报数长度：");
	int M = 0;
	scanf("%d",&M);
	NodePtr p = L;
	for(int i=1;i<=M;i++)//找到第M个节点
	{
		p=p->next;
	}
	while(L->len!=1)
	{

		printf("%d\n",p->data);
		NodePtr q = p;
		for(int i=1;i<L->len;i++) //找到p的前一个节点
		{
			q=q->next;
		}
		//printf("p=%d,q=%d\n",p->data,q->data);
		NodePtr t = p;
		p=p->next;
		q->next = t->next;//删除p
		free(t);
		t=NULL;
		L->len--;
		for(int i=1;i<M;i++)//找到第M个节点
		{
			p=p->next;
		}
	}
    p->next=L;
	return 0;
}

main.c
#include"lplink.h"

int main(int argc, const char *argv[])
{
	//调用创建函数
	NodePtr L = list_create();
	if(NULL == L)
	{
		return -1;
	}
	list_insert_tail(L);
	list_show(L);
	kill(L);
//	list_destroy(L);
//	L=NULL;
	return 0;
}

将双向链表和循环链表自己实现一遍，至少要实现创建、增、删、改、查、销毁工作

双向链表

dlink.h
#ifndef DLINK_H
#define DLINK_H
#include<myhead.h>
typedef char datatype;//数据域的类型

//定义节点类型
typedef struct Node
{
	union
	{
		int len;//头结点数据域
		datatype data;//普通节点数据域
	};
	struct Node *prio;//前驱指针
	struct Node *next;//后继指针
}Node,*NodePtr;

//创建双向链表
NodePtr list_create();

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

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

//链表头插
int list_insert_head(NodePtr L,datatype e);

//按位置查找返回节点
NodePtr list_search_pos(NodePtr L,int pos);

//链表遍历
int list_show(NodePtr L);

//链表任意位置删除
int list_delete_pos(NodePtr L,int pos);

//链表删除
void list_destroy(NodePtr L);
#endif

dlink.c
#include"dlink.h"
//创建双向链表
NodePtr list_create()
{
	//在堆区申请一个头节点
	NodePtr L=(NodePtr)malloc(sizeof(Node));
	if(NULL==L)
	{
		printf("创建失败\n");
		return NULL;
	}

	//说明链表创建成功
	L->len=0; 			//链表长度为0
	L->prio=NULL; 		//前驱指针为空
	L->next=NULL; 		//后继指针为空

	printf("创建成功\n");
	return L;
}

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

//申请节点封装数据
NodePtr apply_node(datatype e)
{
	//申请节点空间的大小
	NodePtr p =(NodePtr)malloc(sizeof(Node));
	if(NULL == p)
	{
		printf("节点申请失败\n");
		return NULL;
	}
	//给节点赋值
	p->data = e;
	p->prio = NULL;
	p->next = NULL;

	return p;
}

//链表头插
int list_insert_head(NodePtr L,datatype e)
{
	//判断逻辑
	if(NULL==L)
	{
		printf("插入失败\n");
		return -1;
	}
	//申请节点封装数据
	NodePtr p = apply_node(e);
	if(NULL==p)
	{
		return -1;
	}
	//头插逻辑
	if(list_empty(L))
	{
		p->prio=L;
		L->next=p;
	}
	else
	{
		p->prio=L;
		p->next=L->next;
		L->next->prio=p;
		L->next=p;
	}
	printf("插入成功\n");
	L->len++;
	return 0;
}

//按位置查找返回节点
NodePtr list_search_pos(NodePtr L,int pos)
{
	//判断逻辑
	if(NULL==L||list_empty(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_show(NodePtr L)
{
	//判断逻辑
	if(NULL==L||list_empty(L))
	{
		printf("遍历失败\n");
		return -1;
	}
	//遍历逻辑
	NodePtr q = L->next;//从第一个节点出发
	while(q)
	{
		//输出数据域
		printf("%c\n",q->data);
		//遍历指针后移
		q=q->next;
	}
	printf("\n");
}

//链表任意位置删除
int list_delete_pos(NodePtr L,int pos)
{
	//判断逻辑
	if(NULL==L||list_empty(L)||pos<1||pos>L->len)
	{
		printf("删除失败\n");
		return -1;
	}
	//找到要删除的节点
	NodePtr q = list_search_pos(L,pos);
	//删除逻辑
	if(q->next==NULL)
	{
		q->prio->next=NULL;
		free(q);
		q=NULL;
	}
	else
	{
		q->next->prio=q->prio;
		q->prio->next=q->next;
		free(q);
		q=NULL;
	}
	//表长变化
	L->len--;
	return 0;
}

//链表删除
void list_destroy(NodePtr L)
{
	//判断逻辑
	if(NULL==L)
	{
		printf("删除失败\n");
		return;
	}
	//删除所有节点
	while(!list_empty(L))
	{
		list_delete_pos(L,1);
	}
	//删除头节点
	free(L);
	L=NULL;
	printf("链表释放成功\n");
	
}

mian.c
#include"dlink.h"
int main(int argc, const char *argv[])
{
	//调用创建函数
	NodePtr L = list_create();
	if(NULL==L)
	{
		return -1;
	}

	//调用头插函数
	list_insert_head(L,'Q');
	list_insert_head(L,'W');
	list_insert_head(L,'E');
	list_insert_head(L,'R');

	//调用遍历函数
	list_show(L);
	list_delete_pos(L,2);
	list_show(L);
	list_destroy(L);
	L=NULL;
	list_show(L);
	return 0;
}

循环链表

lplink.h
#ifndef LPLINK_H
#define LPLINK_H
#include<myhead.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 list_destroy(NodePtr L);
#endif

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

//链表尾插
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++;
	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("%c\t",q->data);
		q = q->next;
	}
	printf("\n");
}

//链表的头删
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--;
	printf("删除成功\n");
	return 0;
}

//链表的销毁
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");
}

main.c
#include"lplink.h"

int main(int argc, const char *argv[])
{
	//调用创建函数
	NodePtr L = list_create();
	if(NULL == L)
	{
		return -1;
	}
	//调用尾插函数
	list_insert_tail(L,'Q');
	list_insert_tail(L,'W');
	list_insert_tail(L,'E');
	list_insert_tail(L,'R');
	list_show(L);
	list_destroy(L);
	L=NULL;
	return 0;
}