7/22日作业

游标卡尺__

已于 2024-07-23 08:55:09 修改

阅读量120

点赞数 2

文章标签：数据结构

于 2024-07-22 20:57:54 首次发布

本文链接：https://blog.csdn.net/gjvrnv/article/details/140619498

版权

双向链表的增删改查

doubulelist.h

#ifndef DOUBLELIST_H
#define DOUBLELIST_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);


//链表的遍历
int list_show(NodePtr L);
//按位置查找返回节点
NodePtr list_search_pos(NodePtr L,int pos);
//链表任意位置删除
int list_delete_pos (NodePtr L,int pos);
//链表的销毁
void list_destory(NodePtr L);

doubulelist.c

#include "doublelist.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");
	}
	//申请节点封装数据函数
	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;
	
}	

//链表的遍历
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;
	}
}	

//按位置查找返回节点
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_delete_pos (NodePtr L,int pos)
{
	//判断逻辑
	if(L==NULL||list_empty(L)||pos<0||pos>L->len)
	{
		printf("删除失败\n");
		return -1;
	}	
	//找到要删除的节点
	NodePtr q=list_search_pos(L,pos);
	//删除逻辑
	if(q->next==NULL)
	{
		//尾删
		q->prio->next=NULL;
		free(q);
	}
	
	else
	{
		q->prio->next=q->next;
		q->next->prio=q->prio;
		free(q);
		q=NULL;
	}	
		//表长变化
		L->len--;
		printf("删除成功\n");
		return 0;
}	
void list_destory(NodePtr L)
{
	//判断逻辑
	if(NULL==L)
	{
		printf("删除失败\n");
		return;
	}
	//删除所有节点
	while(!list_empty(L))
	{
		list_delete_pos(L,1);
	}
	//删除头删
	free(L);
	L=NULL;
	printf("链表释放成功\n");
}

main.c

#include"doublelist.h"
#include<myhead.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,'R');
	list_insert_head(L,'Y');
	list_insert_head(L,'E');
	list_insert_head(L,'T');
	list_insert_head(L,'u');
	list_insert_head(L,'M');
	list_insert_head(L,'B');
	//调用遍历函数
	list_show(L);
	//调用删除函数
	list_delete_pos(L,1);
	list_delete_pos(L,3);
	list_delete_pos(L,L->len);
	list_show(L);
	//释放链表
	list_destory(L);
	L=NULL;
	return 0;
}

循环链表的增删改查

looplist.h

#ifndef LOOPLIST_H
#define LOOPLIST_H
#include<myhead.h>
typedef char datatype;
typedef struct Node
{
	union
	{
		int len;//链表长度
		datatype data;//普通结点数据域
	};
	struct Node *next;//指针域
}Node, *Node_ptr;
//创建链表
Node_ptr list_create();

int list_empty(Node_ptr L);
//链表申请空间封装节点
Node_ptr apply_node(datatype e);
//按位置进行查找
Node_ptr list_search_pos(Node_ptr L,int pos);
//链表尾插
int list_insert_tail(Node_ptr L,datatype e);
//链表遍历
int list_show(Node_ptr L);
//链表头删
int list_delete_head(Node_ptr L);
//链表销毁
void list_destory(Node_ptr L);


#endif

looplist.c

#ifndef LOOPLIST_H
#define LOOPLIST_H
#include<myhead.h>
typedef char datatype;
typedef struct Node
{
	union
	{
		int len;//链表长度
		datatype data;//普通结点数据域
	};
	struct Node *next;//指针域
}Node, *Node_ptr;
//创建链表
Node_ptr list_create();

int list_empty(Node_ptr L);
//链表申请空间封装节点
Node_ptr apply_node(datatype e);
//按位置进行查找
Node_ptr list_search_pos(Node_ptr L,int pos);
//链表尾插
int list_insert_tail(Node_ptr L,datatype e);
//链表遍历
int list_show(Node_ptr L);
//链表头删
int list_delete_head(Node_ptr L);
//链表销毁
void list_destory(Node_ptr L);






#endif
ubuntu@ubuntu:循环链表$ 
ubuntu@ubuntu:循环链表$ cat looplist.c
#include"looplist.h"
//创建链表
Node_ptr list_create()
{
	Node_ptr L=(Node_ptr)malloc(sizeof(Node));
	if(NULL==L)
	{
		printf("创建失败\n");
		return NULL;
	}
	//初始化
	L->len=0;
	L->next=L;//头节点指针域指向自己
	printf("创建成功\n");
	return L;
}	

int list_empty(Node_ptr L)
{
	return L->next==L;
}	
//链表申请空间封装节点
Node_ptr apply_node(datatype e)
{
	Node_ptr p=(Node_ptr)malloc(sizeof(Node));
	if(NULL==p)
	{
		printf("申请失败\n");
		return NULL;
	}
	p->data=e;//给节点赋值
	p->next=NULL;
	return p;

}	
//按位置进行查找
Node_ptr list_search_pos(Node_ptr L,int pos)
{
	if(NULL==L||pos<0||pos>L->len)
	{
		printf("查找失败\n");
		return NULL;
	}
	Node_ptr q=L;
	for(int i=0;i<pos;i++)
	{
		q=q->next;
	}
	return q;
}	
//链表尾插
int list_insert_tail(Node_ptr L,datatype e)
{
	//判断逻辑
	if(NULL==L)
	{
		printf("插入失败\n");
		return -1;
	}	
	
	//找到最好一个节点
	Node_ptr q=list_search_pos(L,L->len);

	//封装节点
	Node_ptr 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(Node_ptr L)
{
	if(NULL==L||list_empty(L))
	{
		printf("遍历失败\n");
		return -1;
	}
	Node_ptr q=L->next;
	while(q!=L)
	{
		printf("%c\t",q->data);
		q=q->next;
	}
	puts("");
}	
//链表头删
int list_delete_head(Node_ptr L)
{
	//判断逻辑
	if(NULL==L||list_empty(L))
	{
		printf("删除失败\n");
		return -1;
	}
	Node_ptr p=L->next;
	L->next=p->next;
	free(p);
	p=NULL;
	L->len--;
	printf("删除成功\n");
	return 0;
}	
//链表销毁
void list_destory(Node_ptr L)
{
	//判断逻辑
	if(NULL==L)
	{
		printf("释放失败\n");
	}	

	//删除节点
	while(!list_empty(L))
	{
		list_delete_head(L);
	}	

	//释放头节点
	free(L);
	L=NULL;
	printf("销毁成功\n");
}

main.c

#include"looplist.h"
#include<myhead.h>

int main(int argc, const char *argv[])
{
	Node_ptr L=list_create();
	if(NULL==L)
	{
		return -1;
	}	
	//调用尾插函数
	list_insert_tail(L,'Q');
	list_insert_tail(L,'L');
	list_insert_tail(L,'O');
	list_insert_tail(L,'V');
	list_insert_tail(L,'E');
	//调用遍历函数
	list_show(L);
	//调用头删函数
	list_delete_head(L);
	list_show(L);
	//调用释放函数
	list_destory(L);
	L=NULL;
	return 0;
}

2.使用栈，完成进制转换

输入：一个整数，进制数

输出：该数的对应进制数

seqstack.h

#ifndef SEQSTACK_H
#define SEQSTACK_H
#include<myhead.h>
typedef int datatype;//数据类型
//定义顺序栈的类型
#define max 8//顺序栈的最大容量
typedef struct SeqStqck
{
	datatype *data;//存储栈
	int top;//记录栈顶元素的下标
}Stack,*Stack_Ptr;
//创建栈
Stack_Ptr stack_create();
//判空
int stack_empty(Stack_Ptr S);
//判满
int stackfull(Stack_Ptr S);
//入栈
void stack_push(Stack_Ptr S,datatype e);
//出栈
void stack_pop(Stack_Ptr S);

//利用栈完成二进制的转换
void strack_converst(Stack_Ptr S,int m,int n);

#endif

seqstack.c

#include"seqstack.h"
//创建栈
Stack_Ptr stack_create()
{
	Stack_Ptr S=(Stack_Ptr)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(Stack_Ptr S)
{
	return S->top==-1;
}	
//判满
int stackfull(Stack_Ptr S)
{
	return S->top==max-1;
}	
//入栈
void stack_push(Stack_Ptr S,datatype e)
{
	//判断逻辑
	if(NULL==S||stackfull(S))
	{
		printf("入栈失败\n");
		return ;
	}	
	//入栈逻辑
		S->top++;
		S->data[S->top]=e;
}	
//出栈
void stack_pop(Stack_Ptr S)
{
	if(NULL==S||stack_empty(S))
	{
		printf("出栈失败\n");
		return ;
	}
	printf("%d\n",S->data[S->top]);
	S->top--;
}	
//利用栈完成二进制的转换
void strack_converst(Stack_Ptr S,int m,int n)
{
	//判断逻辑
	if(S==NULL)
	{
		printf("转换失败\n");
		return;
	}
	while(m>0)
	{
		stack_push(S,m%n);
		m/=n;
	}
	while(!stack_empty(S))
	{
		stack_pop(S);
	}
	puts("");
}

main.c

#include"seqstack.h"
#include<myhead.h>

int main(int argc, const char *argv[])
{
	Stack_Ptr S=stack_create();
	if(NULL==S)
	{
		return -1;
	}
	int m=0;
	printf("请输入一个整数>>>");
	scanf("%d",&m);
	int n=0;
	printf("请输入进制数>>>");
	scanf("%d",&n);
	strack_converst(S,m,n);
	stack_destory(S);
	return 0;
}