数据结构day6（2023.7.20）

news2024/11/28 12:34:42

一、Xmind整理：

 

二、课上练习：

练习1：个栈的入栈次序ABCDE，则栈的不可能的输出序列是（D）

A.ABCDE          B.DECBA          C.EDCBA          D.DCEAB

       栈的特点是先进后出，后进先出，D不符合该思想，根据题意，可以推测D选项首先入栈的是ABCD，然后D出，C出，E进入，E出，但在这种情况下，B应当比A先出栈。

练习2：顺序栈

 

练习3：顺序栈的结构体定义

 

练习4：顺序栈的插入 


/*
 * function:    入栈
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int list_stack_push(datatype e,StackList *stack)
{
    //1.判断栈是否创建
    //2.判断栈是否为满
    if(NULL==stack || stack->top==MAXSIZE-1)
    {
    puts("push  stack  error");
    return -1;
    }
    //3.入栈：先加后压
    //stack->top++;
stack->data[++stack->top]=e;
    return 0;
}

练习5：顺序栈的删除

/*
 * function:    出栈
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int list_stack_pop(StackList *stack)
{
    //1.判断栈是否创建
    //2.判断栈是否为空
    if(NULL==stack || stack->top==-1)
    {
    puts("pop error");
    return -1;
    }
    //3.出栈：先弹后减
    printf("pop data is:%d\n",stack->data[stack->top--]);
//    stack->top--;
    return 0;
}

练习6：顺序栈的遍历

/*
 * function:    顺序栈的输出
 * @param [ in] 
 * @param [out] 
 * @return      无
 */
void stack_output(StackList *stack)
{
    //1.判断栈是否创建
    //2.判断栈是否为空
    if(NULL==stack || stack->top==-1)
    {
    puts("output error");
    return;
    }
    //3.输出
    for(int i=0;i<=stack->top;i++)
    {
    printf("%d\t",stack->data[i]);
    }
    puts("");
}

练习7：顺序栈的创建

/*
 * function:    创建栈
 * @param [ in] 
 * @param [out] 
 * @return      
 */
StackList *create_stack()
{
StackList *stack=(StackList *)malloc(sizeof(StackList));
    if(NULL == stack)
    {
    return NULL;
    }
    //栈顶置空
stack->top=-1;
    memset(stack->data,0,sizeof(stack->data));
    return stack;
}

练习8：链栈

 

练习9：链栈节点创建【单链表节点创建】

/*
 * function:    创建一个节点
 * @param [ in] 
 * @param [out] 
 * @return      
 */
LinkStack create_node()
{
LinkStack node=(LinkStack)malloc(sizeof(struct Node));
    if(NULL==node)
    return NULL;
node->data=0;
node->next=NULL;
    return node;//0x10
}

练习10：链栈插入【单链表头插】

/*
 * function:    链栈的入站
 * @param [ in] 
 * @param [out] 
 * @return      
 */

LinkStack link_stack_push(datatype e,LinkStack top)
{
    //在堆区创建一个节点
LinkStack node=create_node();//在堆区申请一个节点
node->data=e;//数据域赋值为e
    //node节点链接到链表中
node->next=top;
top=node;
    return top;//因为自定义函数指针的改变不影响实参，需要返回
}

练习11：链栈删除【单链表头删】

/*
 * function:    头删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
LinkStack link_stack_pop(LinkStack top)
{
    //判断链表是否为空
    if(NULL==top)
    {
    return top;
    }
    if(top->next==NULL)
    {
    free(L);
    L=NULL;
    }
    else
    {
    LinkStack q=top->next;
    top->data=q->data;
    top->next=q->next;
    free(q);
    q=NULL;
    }
return top;


}

练习12：链栈遍历【单链表遍历】

/*
 * function:    循环遍历
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int link_output(LinkStack top)

{
    //判断是否创建
    //判断是否为空
    if(NULL==top )
    {
    return -1;
    }
    while(top!=NULL)
    {
    printf("%d\t",top->data);
    top=top->next;
    }
    puts("");
}

栈的整体代码：

stack_head.h：

#ifndef __STACK_HEAD_H__
#define __STACK_HEAD_H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAXSIZE 4
typedef int datatype;
typedef struct
{
	//栈顶
	int top;
	//数据元素
	datatype data[MAXSIZE];
}StackList;

int list_stack_pop(StackList *stack);
StackList *create_stack();
int list_stack_push(datatype e,StackList *stack);
void stack_output(StackList *stack);

//定义单链表节点结构体
typedef struct Node
{
	//数据域：数据元素
	datatype data;
	//指针域:存储下一个节点的地址
	struct Node *next;
}*LinkStack;


LinkStack link_stack_push(datatype e,LinkStack top);
int link_output(LinkStack top);
LinkStack link_stack_pop(LinkStack L);

#endif

stack_test.c：

#include "stack_head.h"
/*
 * function:    创建栈
 * @param [ in] 
 * @param [out] 
 * @return      
 */
StackList *create_stack()
{
	StackList *stack=(StackList *)malloc(sizeof(StackList));
	if(NULL == stack)
	{
		return NULL;
	}
	//栈顶置空
	stack->top=-1;
	memset(stack->data,0,sizeof(stack->data));
	return stack;
}
/*
 * function:    入栈
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int list_stack_push(datatype e,StackList *stack)
{
	//1.判断栈是否创建
	//2.判断栈是否为满
	if(NULL==stack || stack->top==MAXSIZE-1)
	{
		puts("push  stack  error");
		return -1;
	}
	//3.入栈：先加后压
	//stack->top++;
	stack->data[++stack->top]=e;
	return 0;
}
/*
 * function:    顺序栈的输出
 * @param [ in] 
 * @param [out] 
 * @return      无
 */
void stack_output(StackList *stack)
{
	//1.判断栈是否创建
	//2.判断栈是否为空
	if(NULL==stack || stack->top==-1)
	{
		puts("output error");
		return;
	}
	//3.输出
	for(int i=0;i<=stack->top;i++)
	{
		printf("%d\t",stack->data[i]);
	}
	puts("");
}
/*
 * function:    出栈
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int list_stack_pop(StackList *stack)
{
	//1.判断栈是否创建
	//2.判断栈是否为空
	if(NULL==stack || stack->top==-1)
	{
		puts("pop error");
		return -1;
	}
	//3.出栈：先弹后减
	printf("pop data is:%d\n",stack->data[stack->top--]);
//	stack->top--;
	return 0;
}
/*
 * function:    创建一个节点
 * @param [ in] 
 * @param [out] 
 * @return      
 */
LinkStack create_node()
{
	LinkStack node=(LinkStack)malloc(sizeof(struct Node));
	if(NULL==node)
		return NULL;
	node->data=0;
	node->next=NULL;
	return node;//0x10
}/*
 * function:    链栈的入站
 * @param [ in] 
 * @param [out] 
 * @return      
 */

LinkStack link_stack_push(datatype e,LinkStack top)
{
	//在堆区创建一个节点
	LinkStack node=create_node();//在堆区申请一个节点
	node->data=e;//数据域赋值为e
	//node节点链接到链表中
	node->next=top;
	top=node;
	return top;//因为自定义函数指针的改变不影响实参，需要返回
}
/*
 * function:    循环遍历
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int link_output(LinkStack top)

{
	//判断是否创建
	//判断是否为空
	if(NULL==top )
	{
		return -1;
	}
	while(top!=NULL)
	{
		printf("%d\t",top->data);
		top=top->next;
	}
	puts("");
}
/*
 * function:    头删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
LinkStack link_stack_pop(LinkStack top)
{
	//判断链表是否为空
	if(NULL==top)
	{
		return top;
	}
	if(top->next==NULL)
	{
		free(L);
		L=NULL;
	}
	else
	{
		LinkStack q=top->next;
		top->data=q->data;
		top->next=q->next;
		free(q);
		q=NULL;
	}
	return top;


}

stack_main.c：

#include "stack_head.h"
int main(int argc, const char *argv[])
{
	/*
	StackList *stack=create_stack();
	char continu;
	datatype e;
	int flag;
	do
	{
	//入栈
		printf("please enter e:");
		scanf("%d",&e);
		flag=list_stack_push(e,stack);
		if(flag==-1)
			break;
		printf("Please enter whether you will continue");
		scanf(" %c",&continu);

	}while(continu!='N'&&continu!='n');
	
	stack_output(stack);
	do
	{
		flag=list_stack_pop(stack);

		if(flag==-1)
			break;
		printf("Please enter whether you will continue");
		scanf(" %c",&continu);

	}while(continu!='N'&&continu!='n');
	
	stack_output(stack);
	
*/
	LinkStack top=NULL;
	char continu;
	datatype e;
	int flag;
	do
	{
	//入栈
		printf("please enter e:");
		scanf("%d",&e);
		
		top=link_stack_push(e,top);
		
		printf("Please enter whether you will continue");
		scanf(" %c",&continu);

	}while(continu!='N'&&continu!='n');
	
	link_output(top);
	do
	{
		
		top=link_stack_pop(top);
		printf("Please enter whether you will continue");
		scanf(" %c",&continu);

	}while(continu!='N'&&continu!='n');
	
	link_output(top);
	return 0;
}

练习13：顺序队列

 

练习14：顺序队列创建

/*
 * function:    在堆区申请空间
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
QueueList *create_queue()
{
QueueList  *queue=(QueueList *)malloc(sizeof(QueueList));
    if(NULL==queue)
    return NULL;

queue->front=queue->rear=0;
    memset(queue->data,0,sizeof(queue->data));
    return queue;
}

练习15：顺序队列入队

/*
 * function:    入队
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int enqueue(datatype e,QueueList *queue)
{
    //1.判断是否创建
    //2.判断是否满
    if(NULL==queue || queue->rear==MAXSIZE)
    {
    puts("enqueue error");
    return -1;
    }
    //3.入队：在队尾插入
queue->data[queue->rear++]=e;
//    queue->rear++;
    return 0;
    
}

练习16：顺序队列出队

/*
 * function:    出队
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int delqueue(QueueList *queue)
{
    //1.判断是否创建
    //2.判断是否为空
    if(NULL==queue || queue->front==queue->rear)
    {
    puts("delqueue error");
    return -1;
    }
    //3.出队：出队在队头
    printf("delqueue data is:%d\n",queue->data[queue->front++]);
//    queue->front++;

}

练习17：顺序队列遍历

/*
 * function:    循环输出队列
 * @param [ in] 
 * @param [out] 
 * @return      无
 */
void output(QueueList *queue)
{
    //1.判断是否创建
    //2.判断是否为空
    if(NULL==queue || queue->front==queue->rear)
    {
    puts("output error");
    return;
    }
    //3.从队头到队尾输出
    for(int i=queue->front;i<queue->rear;i++)
    {
    printf("%d\t",queue->data[i]);
    }
    puts("");
}

练习18：循环队列

 

练习19：循环队列入队

/*
 * function:    循环队列入队
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int enqueue(datatype e,QueueList *queue)
{
    //1.判断是否创建
    //2.判断是否满
    if(NULL==queue ||queue->front==(queue->rear+1)%MAXSIZE)
    {
    puts("enqueue error");
    return -1;
    }
    //3.入队：在队尾插入
queue->data[queue->rear]=e;
queue->rear=(queue->rear+1)%MAXSIZE;
    return 0;
    
}

练习20：循环队列出队

/*
 * function:    出队
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int delqueue(QueueList *queue)
{
    //1.判断是否创建
    //2.判断是否为空
    if(NULL==queue || queue->front==queue->rear)
    {
    puts("delqueue error");
    return -1;
    }
    //3.出队：出队在队头
    printf("delqueue data is:%d\n",queue->data[queue->front]);
queue->front=(queue->front+1)%MAXSIZE;
    return 0;

}

练习21：循环队列的遍历

/*
 * function:    循环输出队列
 * @param [ in] 
 * @param [out] 
 * @return      无
 */
void output(QueueList *queue)
{
    //1.判断是否创建
    //2.判断是否为空
    if(NULL==queue || queue->front==queue->rear)
    {
    puts("output error");
    return;
    }
    //3.从队头到队尾输出
    for(int i=queue->front;i!=queue->rear;i=(i+1)%MAXSIZE)
    {
    printf("%d\t",queue->data[i]);
    }
    puts("");
}

练习22：循环队列个数计算

/*
 * function:    计算循环队列个数
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int loop_queue_count(QueueList *queue)
{
 return (MAXSIZE-queue->front+queue->rear)%MAXSIZE;
}

练习23：链式队列

 

练习24：链式队列节点创建【单链表节点创建】

//创建节点
queue  *CreateLink()
{
	//创建队列：头节点，尾节点【指向单向链表的头以及尾】
	queue *q=(queue *)malloc(sizeof(queue));
	if(q==NULL)
		return NULL;
	//创建单向链表的头节点
	Node *L=(Node *)malloc(sizeof(Node));
	if(L==NULL)
		return NULL;
	L->len=0;//对单向链表头结点的数据域赋值，链表为空
	L->next=NULL;//单向链表头结点没有后继节点
	
	q->front=L;//队头指向单向链表的第一个节点
	q->rear=L;//队尾指针指向单向链表的最后一个节点
	return q;
}

练习25：链式队列入队【单链表尾插】

void EnqueueLink(queue *q,datatype e)
{
	//1.判断队列是否创建成功
	if(q==NULL)
		return;
	//2.入队
	Node *p=(Node *)malloc(sizeof(Node));
	if(p==NULL)
		return;
	p->data=e;
	p->next=NULL;
	
	//3.入队
	q->rear->next=p;
	q->rear=p;
	q->front->len++;
}

练习26：链式队列出队【单链表头删】

//链式队列的出队
//成功返回出队的数据,
int dequeueLink(queue *q)
{
	//1.判断队列是否存在
	//2.判断队列是否为空
	if(q==NULL || q->front->next==NULL)
		return -1;
	//3.出队
	Node *p=q->front->next;
	int data=p->data;
	q->front->next=p->next;
	free(p);
	p=NULL;
	q->front->len--;
	return data;
}

练习27：链式队列遍历【单链表的输出】

//链是队列的遍历
void LinkShow(queue *q)
{
	printf("\n");
	Node *p=q->front;
	while(p->next)
	{
		p=p->next;
		printf("%d\t",p->data);
	}
	printf("\n");
}

练习28：释放空间

//释放头节点后面的节点
	int t=q->front->len;
	for(int i=0;i<t;i++)
	{
		dequeueLink(q);
	}
	free(q->front);//删除头节点
	free(q);//释放队列的空间
	q=NULL;//q释放没有指向，防止野指针

练习29：直接插入排序

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, const char *argv[])
{
	int m,t,j;
	int arr[100];
	printf("请问你要插入几个数：");
	scanf("%d",&m);
	for(int i=0;i<m;i++)
	{
		printf("请输入第%d个数：",i+1);
		scanf("%d",&arr[i]);
	}
	int *p=arr;
	for(int i=1;i<m;i++)
	{
		t=*(p+i);
		for(j=i-1;j>=0;j--)
		{
			if(t<*(p+j))
			{
				*(p+j+1)=*(p+j);
			}
			else
				break;
		}
		*(p+j+1)=t;
	}
	for(int i=0;i<m;i++)
		printf("%d\t",*(p+i));
	puts("");
	return 0;
}

三、课后作业：

实现双向链表的逆置

方法一：
DoubleLink rev_doublelink(DoubleLink L)
{
	//判断链表是否为空
	if(NULL==L)
		return L;
	//判断链表只有一个节点
	if(NULL == L || L->next==NULL)
	{
		return L;
	}
    //先找最后一个节点的位置
	DoubleLink p=L;
	while(p->next!=NULL)
	{
		p=p->next;
	}
	DoubleLink q=L;
	DoubleLink s=NULL;
	while(q!=NULL)
    {
        s=q->next;
		q->next=q->prev;
		q->prev=s;
		q=s;
    }
    return p;
}
方法二：
DoubleLink rev_doublelink(DoubleLink L)
{
	//判断链表是否为空
	if(NULL==L)
		return L;
	//判断链表只有一个节点
	if(NULL == L || L->next==NULL)
	{
		return L;
	}
	DoubleLink p=L;
	DoubleLink q=NULL;
	while (p!=NULL)
	{
		q=p->prev;
		p->prev=p->next;
		p->next=q;
		p=p->prev;
	}
	// 更新头节点的prev指针为NULL
	if(q!=NULL)
	{
		L=q->prev;
		L->prev=NULL;
	}
	return L;
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Electron 系统通知 Notification 实践指南

Electron 系统通知 Notification 实践指南

系统通知是桌面应用的常见功能&#xff0c;用于给用户发送提醒&#xff08;刷下存在感 &#x1f642;&#xff09;&#xff0c;还能帮定点击事件以便后续的操作。 Electron 自带通知模块&#xff0c;下方代码是一个简单的示例 const { Notification } require(electron)cons…
阅读更多...
Postman学习之常用断言

Postman学习之常用断言

什么是断言&#xff1f; 断言——就是结果中的特定属性或值与预期做对比&#xff0c;如果一致&#xff0c;则用例通过&#xff0c;如果不一致&#xff0c;断言失败&#xff0c;用例失败。断言&#xff0c;是一个完整测试用例所不可或缺的一部分&#xff0c;没有断言的测试用例…
阅读更多...
SZ：zip/内部函数外部函数/VGG模型/nn

SZ：zip/内部函数外部函数/VGG模型/nn

zip&#xff1a; -r recursion-d delete-m move (move隐藏的意思是&#xff0c;原文件会消失&#xff09;想增加文件&#xff0c;不需要加参数什么参数也没有。如果zip压缩文件不存在&#xff0c;执行以上命令将会创建一个新的zip文件并将指定的文件添加进去。如果zip压缩文件…
阅读更多...
SpringBoot+Jpa+Thymeleaf实现增删改查

SpringBoot+Jpa+Thymeleaf实现增删改查

SpringBootJpaThymeleaf实现增删改查 这篇文章介绍如何使用 Jpa 和 Thymeleaf 做一个增删改查的示例。 1、pom依赖 pom 包里面添加Jpa 和 Thymeleaf 的相关包引用 <?xml version"1.0" encoding"UTF-8"?> <project xmlns"http://maven.…
阅读更多...
网络层IP协议的基本原理 数据链路层ARP协议 域名解析以及一些重要技术

网络层IP协议的基本原理 数据链路层ARP协议 域名解析以及一些重要技术

目录 1 网络层IP协议协议头格式网段划分DHCPCIDR&#xff1a;基于子网掩码的划分方式特殊的IP号IP地址的数量限制私有IP地址和公网IP地址路由路由表 2 数据链路层 — 局域网的转发问题以太网认识以太网以太网帧格式局域网通信原理 MTUMTU对IP协议的影响MTU对UDP协议的影响MTU对…
阅读更多...
重要消息：这类PEFC证书即将失效！

重要消息：这类PEFC证书即将失效！

【重要消息&#xff1a;这类PEFC证书即将失效&#xff01;】 所有按照2013年版标准颁发的PEFC证书都将于 2023年11月14日失效。 在此之前&#xff0c;PEFC执行标准为PEFC ST 2002:2013&#xff0c;现更改为PEFC ST 2002:2020&#xff0c;即从2013年版改为2020年版。 1. 如果您的…
阅读更多...
中国嗅觉经济产业分析

中国嗅觉经济产业分析

随着人们对健康和福祉的重视程度不断提升&#xff0c;嗅觉行业也开始关注个人的舒适感和情绪平衡。香氛产品、空气清新剂和芳香疗法等产品受到越来越多人的青睐&#xff0c;帮助人们创造舒适、放松和愉悦的环境。也越来越多中国消费者对香水香氛有自己独特的作用感知。我们将这…
阅读更多...
Windows Active Directory密码同步

Windows Active Directory密码同步

大多数 IT 环境中&#xff0c;员工需要记住其默认 Windows Active Directory &#xff08;AD&#xff09; 帐户以外的帐户的单独凭据&#xff0c;最重要的是&#xff0c;每个密码还受不同的密码策略和到期日期的约束&#xff0c;为不同的帐户使用单独的密码会增加用户忘记密码和…
阅读更多...
高校在线心理咨询系统的设计与实现(论文+源码)_kaic

高校在线心理咨询系统的设计与实现(论文+源码)_kaic

高校在线心理咨询系统的设计与实现 摘 要 近年来,随着社会的发展&#xff0c;大学生面临的各方面压力越来越大&#xff0c;比如学习生 活的压力、角色转换、交际困难、情感困惑、就业困难等等&#xff0c; 因对这些压力处理 不当而导致的大学生心理健康问题越来越多&#xff0…
阅读更多...
案例解析|河道水位及水资源远程监控方案

案例解析|河道水位及水资源远程监控方案

随着国家工业的发展&#xff0c;水资源越来越紧张&#xff0c;同时对于水污染加重&#xff0c;也导致可利用水资源越发稀缺&#xff0c;因此对河道水位进行监测&#xff0c;实现水资源的远程监控就显得非常重要。 河道水位及水资源远程监控方案&#xff0c;不仅可以对河道的水…
阅读更多...
CASAtomic原子操作详解

CASAtomic原子操作详解

一、CAS&#xff08;Compare And Swap&#xff09; 1、CAS介绍 CAS原理&#xff1a;假设有三个值&#xff0c;E&#xff08;旧值&#xff09;、U&#xff08;需要更新的值&#xff09;、V&#xff08;内存中真实的值&#xff09;&#xff0c;具体参照下图&#xff1a; 作用&a…
阅读更多...
图论算法|深度优先搜索理论基础|797.所有可能的路径|广度优先搜索BFS理论基础|200. 岛屿数量

图论算法|深度优先搜索理论基础|797.所有可能的路径|广度优先搜索BFS理论基础|200. 岛屿数量

深度优先搜索&#xff08;dfs&#xff09;理论基础 dfs是可一个方向去搜&#xff0c;不到黄河不回头&#xff0c;直到遇到绝境了&#xff0c;搜不下去了&#xff0c;在换方向&#xff08;换方向的过程就涉及到了回溯&#xff09;。递归和回溯是相辅相成的 void dfs(参数) {if…
阅读更多...
史上最全，接口测试-Fiddler抓包常用功能总结（超详细）

史上最全，接口测试-Fiddler抓包常用功能总结（超详细）

目录&#xff1a;导读 前言一、Python编程入门到精通二、接口自动化项目实战三、Web自动化项目实战四、App自动化项目实战五、一线大厂简历六、测试开发DevOps体系七、常用自动化测试工具八、JMeter性能测试九、总结&#xff08;尾部小惊喜&#xff09; 前言 Fiddler中常用的功…
阅读更多...
三、函数-1.概念和分类

三、函数-1.概念和分类

一、定义 函数——是指一段可以直接被另一段程序调用的程序或代码。 程序或代码在MySQL内置了&#xff0c;可以直接调用这些函数。 二、作用 三、分类 字符串函数数值函数日期函数流程函数
阅读更多...
性能测试之并发用户数的估计

性能测试之并发用户数的估计

在计算并发用户数之前&#xff0c;需要先了解2个概念。 并发用户&#xff1a;指的是现实系统中同时操作业务的用户&#xff0c;在性能测试工具中一般称为虚拟用户。并发用户这些用户的最大特征是和服务器产生了交互&#xff0c;这种交互既可以是单向的传输数据&#xff0c;也可…
阅读更多...
【社媒营销】如何提升销量和品牌推广？

【社媒营销】如何提升销量和品牌推广？

随着社交媒体的普及和发展&#xff0c;社媒营销已经成为了提升销量和品牌推广的重要方式。社媒营销不仅可以为企业带来更多的曝光率和知名度&#xff0c;还可以帮助企业与消费者建立更加亲密的联系&#xff0c;提升消费者忠诚度和购买意愿。本文一秒推小编将从以下几个方面探讨…
阅读更多...
【论文阅读】Feature Inference Attack on Shapley Values

【论文阅读】Feature Inference Attack on Shapley Values

摘要 研究背景 近年来&#xff0c;解释性机器学习逐渐成为一个热门的研究领域。解释性机器学习可以帮助我们理解机器学习模型是如何进行预测的&#xff0c;它可以提高模型的可信度和可解释性。Shapley值是一种解释机器学习模型预测结果的方法&#xff0c;它可以计算每个特征对…
阅读更多...
Fragment的基本用法、Fragment和活动间的通信、Fragment的生命周期、动态加载布局的技巧

Fragment的基本用法、Fragment和活动间的通信、Fragment的生命周期、动态加载布局的技巧

一、Fragment的简单用法 1、制作Fragment 1.1 新建一个布局文件left_fragment.xml <?xml version"1.0" encoding"utf-8"?> <LinearLayout xmlns:android"http://schemas.android.com/apk/res/android"android:orientation"ve…
阅读更多...
【小白必看】轻松获取王者荣耀英雄皮肤图片的Python爬虫程序

【小白必看】轻松获取王者荣耀英雄皮肤图片的Python爬虫程序

文章目录 前言项目运行效果图导入模块和库伪装请求头获取英雄列表遍历英雄列表创建英雄目录访问英雄主页并解析HTML代码获取皮肤名称下载皮肤图片完整代码总结 前言 当谈到王者荣耀游戏时&#xff0c;无法忽视的是其丰富多样的英雄皮肤。这些皮肤不仅为玩家提供了个性化的游戏…
阅读更多...
文本预处理——文本特征处理

文本预处理——文本特征处理

目录 文本特征处理n-gram特征文本长度规范 文本特征处理 n-gram特征 文本长度规范
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023