华清数据结构day5 24-7-22

1>使用栈，完成进制转换输入：一个整数，进制数输出：该数的对应的进制数

seqstack.h

#ifndef SEQSTACK_H
#define SEQSTACK_H
#define MAX 10
#include"myhead.h"
typedef int datatype;

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_pop(StackPtr S);
//遍历栈
void stack_show(StackPtr S);
//获取栈顶元素
datatype* stack_get_top(StackPtr S);
//求栈的大小
int stack_size(StackPtr S);
//销毁栈
void stack_destroy(StackPtr S);
//进制转换
void base_conversion(StackPtr S);
#endif

seqstack.c

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

void stack_pop(StackPtr S)
{
	if(NULL == S||stack_empty(S))
	{
		printf("出栈失败\n");
		return;
	}
	S->top--;
}

void stack_show(StackPtr S)
{
	if(NULL == S|| stack_empty(S))
	{
		printf("遍历失败\n");
		return;
	}
	for(int i = S->top;i>=0;i--)
	{
		printf("%c\t",S->data[i]+48);
	}
	printf("\n");
}

datatype* stack_get_top(StackPtr S)
{
	if(NULL == S||stack_empty(S))
	{
		printf("操作失败\n");
		return NULL;
	}
	return &S->data[S->top];
}

int stack_size(StackPtr S)
{
	if(NULL == S)
	{
		printf("操作失败\n");
	}
	return S->top+1;
}

void stack_destroy(StackPtr S)
{
 	if(S!=NULL)
	{
		free(S->data);
		free(S);
		S=NULL;
	}
}

void base_conversion(StackPtr S)
{
	int num = 0,base = 0;
	printf("请输入一个数(10进制):");
	scanf("%d",&num);
	printf("请输入你想要将他转换成为的进制:");
	scanf("%d",&base);
	while(num)
	{
		if (num%base >9)
		{
			stack_push(S,num%base+7);
		}
		else
		{
				stack_push(S,num%base);
		}	
		num=num/base;
	}
		stack_show(S);
}

main.c

#include"seqstack.h"
#include<myhead.h>
int main(int argc, const char *argv[])
{
	StackPtr S = stack_create();
	if(NULL == S)
	{
		return -1;
	}
	base_conversion(S);
    //调用销毁函数
    stack_destroy(S);
    S = NULL;

	return 0;
}

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

双向链表

doublelinklist.h

#ifndef DOUBLELINKLIST_H
#define DOUBLELINKLIST_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_destroy(NodePtr L);
int list_update_pos(NodePtr L, int pos, datatype e);
#endif

doublellinklist.c

#include"doublelinklist.h"

NodePtr list_create()
{
	NodePtr L = (NodePtr)malloc(sizeof(Node));
	if(L == NULL)
	{
		printf("申请失败\n");
		return NULL;
	}
	L->len = 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;
	}
	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)
	{
		printf("%c\t",q->data);
		q=q->next;
	}
	printf("\n");
	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_update_pos(NodePtr L, int pos, datatype e)
{
	if (NULL == L || list_empty(L)|| pos<0||pos>L->len)
	{
		printf("修改失败\n");
		return -1;
	}
	NodePtr p = list_search_pos(L,pos);
	p->data = e;
	printf("修改成功\n");
	return 0;
}
int list_delete_pos(NodePtr L,int pos)
{   
	if(NULL == L|| list_empty(L) || pos<0||pos>L->len)
	{
		printf("删除失败\n");
		return -1;
	}
	NodePtr p = list_search_pos(L,pos);
	if(NULL == p->next)
	{
		p->prio->next = NULL;
		free(p);
	}
	else
	{
		p->prio->next = p->next;
		p->next->prio = p->prio;
		free(p);
	}
	L->len--;
	printf("删除成功\n");
	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");
	return;
}

main.c

#include"doublelinklist.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_update_pos(L,2,'F');
	list_show(L);
	list_delete_pos(L,4);
	list_show(L);
	list_destroy(L);
	return 0;
}

循环链表

looplinklist.h

#ifndef LOOPLINKLIST_H
#define LOOPLINKLIST_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);
//按位置查找
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);
//链表任意位置删除
int list_delete_pos(NodePtr L, int pos);
//链表按位置进行修改
int list_update_pos(NodePtr L, int pos, datatype e);
//链表销毁
void list_destory(NodePtr L);
#endif

looplinklist.c

#include"looplinklist.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 == L)
	{
		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 q = L->next;
	L->next = q->next;
	free(q);
	q=NULL;
	L->len--;
	printf("删除成功\n");
}
//链表销毁
void list_destory(NodePtr L)
{
	if(NULL == L)
	{
		printf("释放失败\n");
		return;
	}
	while(!list_empty(L))
	{
		list_delete_head(L);
	}
	free(L);
	L = NULL;
	printf("销毁成功\n");
}
//链表任意位置删除
int list_delete_pos(NodePtr L, int pos)
{
	if (NULL == L||pos<0 ||pos>L->len||list_empty(L))
	{
		printf("删除失败\n");
		return -1;
	}
	NodePtr p = list_search_pos(L,pos-1);
	NodePtr q = p->next;
	p->next = q->next;
	free(q);
	q=NULL;
	printf("删除成功\n");
	L->len--;  
	return 0;
}
//链表按位置进行修改
int list_update_pos(NodePtr L, int pos, datatype e)
{
	if (NULL == L||pos<0 ||pos>L->len||list_empty(L))
	{
		printf("修改失败\n");
		return -1;
	}
	NodePtr p = list_search_pos(L,pos);
	p->data = e;
	printf("修改成功\n");
	return 0;
}

main.c

#include"looplinklist.h"
#include<myhead.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_insert_tail(L,'T');
	list_show(L);
	list_update_pos(L,2,'P');
	list_show(L);
	list_delete_pos(L,3);
	list_show(L);
	list_destory(L);
	L=NULL;
	return 0;
}

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

looplinklist.h

#ifndef LOOPLINKLIST_H
#define LOOPLINKLIST_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);
//按位置查找
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);
//链表任意位置删除
int list_delete_pos(NodePtr L, int pos);
//链表按位置进行修改
int list_update_pos(NodePtr L, int pos, datatype e);
//链表销毁
void list_destory(NodePtr L);
//约瑟夫
void Josephus_problem(NodePtr L);
#endif

looplinklist.c

#include"looplinklist.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 == L)
	{
		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 q = L->next;
	L->next = q->next;
	free(q);
	q=NULL;
	L->len--;
}
//链表销毁
void list_destory(NodePtr L)
{
	if(NULL == L)
	{
		printf("释放失败\n");
		return;
	}
	while(!list_empty(L))
	{
		list_delete_head(L);
	}
	free(L);
	L = NULL;
	printf("销毁成功\n");
}
//链表任意位置删除
int list_delete_pos(NodePtr L, int pos)
{
	if (NULL == L||pos<0 ||pos>L->len||list_empty(L))
	{
		printf("删除失败\n");
		return -1;
	}
	NodePtr p = list_search_pos(L,pos-1);
	NodePtr q = p->next;
	p->next = q->next;
	free(q);
	q=NULL;
	printf("删除成功\n");
	L->len--;  
	return 0;
}
//链表按位置进行修改
int list_update_pos(NodePtr L, int pos, datatype e)
{
	if (NULL == L||pos<0 ||pos>L->len||list_empty(L))
	{
		printf("修改失败\n");
		return -1;
	}
	NodePtr p = list_search_pos(L,pos);
	p->data = e;
	printf("修改成功\n");
	return 0;
}
void Josephus_problem(NodePtr L)
{
	int count = 0,num = 0;
	printf("请输入数到几退出:");
	scanf("%d",&num);
	NodePtr p = L;
	while (!list_empty(L))
	{	
		if (p->next == L)
		{
			p = p->next;
		}	
		if (num ==1)
		{
			printf("%c\t",list_search_pos(L,1)->data);
			list_delete_head(L);
		}
		else	if(count == num-1) 
		{
			printf("%c\t",p->next->data);
			NodePtr q = p->next;
			p->next = q->next;
			free(q);
			q=NULL;
			L->len--;  
			count = 0;
		}
		count++;
		p = p->next;
	}
	printf("\n");
}

main.c

#include"looplinklist.h"
#include<myhead.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_insert_tail(L,'T');
	// list_show(L);
	// list_update_pos(L,2,'P');
	// list_show(L);
	// list_delete_pos(L,3);
	// list_show(L);
	Josephus_problem(L);
	list_destory(L);
	L=NULL;
	return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/869769.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

巴黎奥运启幕 PLM系统助力中国制造闪耀全球

巴黎奥运启幕 PLM系统助力中国制造闪耀全球

2024巴黎奥运会将于法国当地时间7月26日在塞纳河畔正式开幕。即将亮相巴黎奥运会赛场的除了中国运动员之外&#xff0c;还有一批批中国制造企业为奥运会设计并制造的体育设备也将惊艳亮相&#xff0c;成为赛场上另一道亮丽的风景线。 在新时代的浪潮中&#xff0c;中国制造业坚…
阅读更多...
算法 —— 暴力枚举

算法 —— 暴力枚举

目录 循环枚举 P2241 统计方形&#xff08;数据加强版&#xff09; P2089 烤鸡 P1618 三连击&#xff08;升级版&#xff09; 子集枚举 P1036 [NOIP2002 普及组] 选数 P1157 组合的输出 排列枚举 P1706 全排列问题 P1088 [NOIP2004 普及组] 火星人 循环枚举 顾名思…
阅读更多...
uniapp中@click或者@tap多层嵌套的问题解决方法

uniapp中@click或者@tap多层嵌套的问题解决方法

我们在开发页面的过程中。例如要设计一个九宫格的相册&#xff0c;并且加上删除上传图片和点击图片后预览图片大图的功能例如下图的演示功能。 点击图片后显示大图预览图片&#xff0c;点击x号后要删除掉当前的图片&#xff0c;那么我们设计的时候如果我们代码写成如下的格式 …
阅读更多...
node和npm安装；electron、 electron-builder安装

node和npm安装；electron、 electron-builder安装

1、node和npm安装 参考&#xff1a; https://blog.csdn.net/sw150811426/article/details/137147783 下载&#xff1a; https://nodejs.org/dist/v20.15.1/ 安装&#xff1a; 点击下载msi直接运行安装 安装完直接cmd打开可以&#xff0c;默认安装就已经添加了环境变量&…
阅读更多...
bug诞生记——动态库加载错乱导致程序执行异常

bug诞生记——动态库加载错乱导致程序执行异常

大纲 背景问题发生问题猜测和分析过程是不是编译了本工程中的其他代码是不是有缓存是不是编译了非本工程的文件是不是调用了其他可执行文件查看CMakefiles分析源码检查正在运行程序的动态库 解决方案 这个案例发生在我研究ROS 2的测试Demo时发生的。 整体现象是&#xff1a;修改…
阅读更多...
【Linux】进程信号 --- 信号处理

【Linux】进程信号 --- 信号处理

&#x1f466;个人主页&#xff1a;Weraphael ✍&#x1f3fb;作者简介&#xff1a;目前正在学习c和算法 ✈️专栏&#xff1a;Linux &#x1f40b; 希望大家多多支持&#xff0c;咱一起进步&#xff01;&#x1f601; 如果文章有啥瑕疵&#xff0c;希望大佬指点一二 如果文章对…
阅读更多...
vue.js入门

vue.js入门

目录 一. 框架概述 二. vue常用命令 2.1 插值表达式 2.2 v-text 2.3 v-html 2.4 v-on 2.5 v-model 2.6 v-show 2.7 v-if 2.8 v-else 2.9 v-bind 2.10 v-for 三. vue生命周期函数 目录 一. 框架概述 二. vue常用命令 2.1 插值表达式 2.2 v-text 2.3 v-html 2…
阅读更多...
Chapter 5: 二叉树详解

Chapter 5: 二叉树详解

在探索计算机科学和编程世界的旅途中&#xff0c;数据结构是构成程序骨干的重要组成部分。它们不仅仅是存储数据的容器&#xff0c;更是提高算法效率、优化资源使用的关键。在众多的数据结构中&#xff0c;二叉树以其独特的结构和灵活性&#xff0c;成为了实现高效算法和解决复…
阅读更多...
智能编程，一触即发：使用AIGC优化CSS——提升前端开发效率与质量

智能编程，一触即发：使用AIGC优化CSS——提升前端开发效率与质量

文章目录 一、AIGC在CSS优化中的应用场景智能代码生成自动布局调整性能优化建议样式和色彩建议 二、使用AIGC优化CSS的具体步骤明确需求选择AIGC工具输入描述或设计稿审查和调整集成和测试 三、AIGC优化CSS的优势与挑战优势&#xff1a;挑战&#xff1a; 《CSS创意项目实践&…
阅读更多...
按图搜索新体验：阿里巴巴拍立淘API返回值详解

按图搜索新体验：阿里巴巴拍立淘API返回值详解

阿里巴巴拍立淘API是一项基于图片搜索的商品搜索服务&#xff0c;它允许用户通过上传商品图片&#xff0c;系统自动识别图片中的商品信息&#xff0c;并返回与之相关的搜索结果。以下是对阿里巴巴拍立淘API返回值的详细解析&#xff1a; 一、主要返回值内容 商品信息 商品列表…
阅读更多...
＜PLC＞＜HMI＞＜汇川＞在汇川HMI画面中，如何为UI设置全局样式？

＜PLC＞＜HMI＞＜汇川＞在汇川HMI画面中，如何为UI设置全局样式？

前言 汇川的HMI软件是使用了Qt来编写的，因此在汇川的HMI程序编写过程，是支持使用qt的样式来自定义部件样式的，即qss格式。 概述 汇川的软件本身提供三个系统的style样式，我们可以直接使用，但是，如果系统提供的样式不符合你的需求，那么你可以对其进行修改，或者自己新建…
阅读更多...
Docker无法拉取镜像!如何解决?

Docker无法拉取镜像!如何解决?

问题现象 继去年Docker Hub被xxx后&#xff0c;各大NAS的注册表均出现问题&#xff0c;例如群晖的Docker套件注册表无法连接&#xff08;更新至DSM7.2版本后恢复&#xff09;。而在今年2024年6月初&#xff08;约2024.06.06&#xff09;&#xff0c;NAS中最重要的工具Docker又…
阅读更多...
RV1126 Linux 系统，接外设，时好时坏（二）排查问题的常用命令

RV1126 Linux 系统，接外设，时好时坏（二）排查问题的常用命令

在 RV1126 Linux 系统中，排查外设连接问题时，可以使用多种命令来诊断和调试。以下是一些常用的命令和工具： 1. 查看系统日志 dmesg: 显示内核环形缓冲区的消息，通常包含设备初始化、驱动加载和错误等信息。 dmesg | grep <设备名或相关关键字>journalctl: 查看系统…
阅读更多...
内网横向：PTHPTKPTT

内网横向：PTHPTKPTT

1.PHT横向 2.PTK横向 3.PTT横向 1.PHT横向&#xff1a; 条件&#xff1a;有管理员的NTLM Hash 并且目标机器开 放445端口 在工作组环境中&#xff1a; Windows Vista 之前的机器&#xff0c;可以使用本地管理员组内用户进行攻击。 WindowsVista 之后的机器&#xff0c;只能是…
阅读更多...
怎么将图片转为pdf？教你5种图片转pdf小技巧

怎么将图片转为pdf？教你5种图片转pdf小技巧

在日常的学习办公中&#xff0c;图片转PDF的需求日益增多&#xff0c;无论是整理旅行照片、工作报告还是学习资料&#xff0c;将图片转换为PDF格式都能让文件更加规范、易于分享和保存。下面给大家分享5种能够将图片转为PDF格式的方法&#xff0c;让你的文档处理变得轻松又高效…
阅读更多...
HTTP 缓存

HTTP 缓存

缓存 web缓存是可以自动保存常见的文档副本的HTTP设备&#xff0c;当web请求抵达缓存时&#xff0c;如果本地有已经缓存的副本&#xff0c;就可以从本地存储设备而不是从原始服务器中提取这个文档。使用缓存有如下的优先。 缓存减少了冗余的数据传输缓存环节了网络瓶颈的问题…
阅读更多...
UI界面卡顿检测工具--UIHaltDetector

UI界面卡顿检测工具--UIHaltDetector

引言&#xff1a; 在日常工作当中&#xff0c;我们经常会遇到软件的界面出现卡顿的问题&#xff0c;而为了确定卡顿原因&#xff0c;我特地写了一个UI界面卡顿的小工具&#xff1a;UIHaltDetector&#xff1b;该工具可以在检测到目标窗口出现卡顿的时候直接打印堆栈日志和输出…
阅读更多...
Android 15 适配整理——实践版

Android 15 适配整理——实践版

背景 谷歌发布Android 15后&#xff0c;国内的手机厂商迅速行动&#xff0c;开始了新系统的适配工作。小米、OPPO、vivo和联想等金标联盟成员联合发布了适配公告&#xff0c;督促APP开发者在2024年8月31日前完成适配工作&#xff0c;否则将面临搜索标签提示、应用降级、分机型…
阅读更多...
邮件安全篇：邮件反垃圾系统运作机制简介

邮件安全篇：邮件反垃圾系统运作机制简介

1. 什么是邮件反垃圾系统&#xff1f; 邮件反垃圾系统是一种专门设计用于检测、过滤和阻止垃圾邮件的技术解决方案。用于保护用户的邮箱免受未经请求的商业广告、诈骗信息、恶意软件、钓鱼攻击和其他非用户意愿接收的电子邮件的侵扰。 反垃圾系统的常见部署形式 2. 邮件反垃圾…
阅读更多...
win11 安装 Gradle

win11 安装 Gradle

一、win11 安装Gradle(7.5.1)&#xff1a; 1.1、下载二进制包 Gradle下载页面 1.2、配置环境变量 变量名&#xff1a;GRADLE_HOME 变量值&#xff08;二进制包解压路径&#xff09;&#xff1a;D:\develop-tool\gradle-7.5.1 变量名&#xff1a;GRADLE_USER_HOME 变量值&a…
阅读更多...
最新文章

Copyright @ 2022~2023