数据结构day5（2023.7.19）

一、Xmind整理：

 

双向链表的插入与删除：

 

二、课上练习：

 练习1：单链表任意元素删除

/*
 * function:    按元素删除
 * @param [ in] 
 * @param [out] 
 * @return      返回堆区首地址
 */
Linklist delete_by_data(datatype key,Linklist L)
{
    
    //1,先根据key查找位置
    int delete_pos=search_by_data(key,L);
    if(delete_pos==-1)
        return L;
    //2,元素存储
    L=delete_by_pos(delete_pos,L);
    return L;
 
/*
    int pos=0;
    Linklist p=L;
    while(L!=NULL)
    {
        pos++;
        if(L->data==key)
        {    
            p=delete_by_pos(pos,p);
            pos--;
        }
        else
        {
            L=L->next;
        }
    }
    return p;*/

}

练习2： 单链表任意元素查找

/*
 * function:    元素查找
 * @param [ in] 
 * @param [out] 
 * @return      返回位置，失败-1
 */
int search_by_data(datatype key,Linklist L)
{
    //1,判断是否为空
    if(NULL==L)
    {
        return -1;
    }
    //2,查找元素key
    int pos=0;
    while(L!=NULL)
    {
        pos++;
        if(L->data==key)
        {
            return pos;
        }
        L=L->next;
    }
    return -1;
}

练习3： 单链表逆置

/*
 * function:    逆置
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
Linklist rev_lInklist(Linklist L)
{
    //判断链表是否为空
    //判断链表甚至有一个节点
    if(NULL == L || L->next==NULL)
    {
        return L;
    }
    //链表有多个节点
    Linklist p=L->next;
    int len=Len_linklist(L)-1;
    L->next=NULL;
    for(int i=0;i<len;i++)
    {
        Linklist t=p;
        p=p->next;
        t->next=L;
        L=t;
    }
    return L;
}

练习4：单链表排序（冒泡排序）

/*
 * function:    冒泡排序
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void Bubble(Linklist L)
{
    //1,判断是否为空
    //2，判断如果链表只有一个节点
    if(NULL==L || L->next==NULL)
    {
        return ;
    }
    //冒泡排序
    int len=Len_linklist(L);
    Linklist p;
    int i,j;
    for( i=1;i<len;i++)
    {
        for( j=0,p=L;j<len-i;j++,p=p->next)
        {
            if(p->data>p->next->data)
            {
                datatype t=p->data;
                p->data=p->next->data;
                p->next->data=t;
            }
        }
    }
}

练习5： 单链表释放

/*
 * function:    释放
 * @param [ in] 
 * @param [out] 
 * @return      返回堆去首地址
 */
Linklist free_space(Linklist L)
{
    if(NULL==L)
    {
        return NULL;
    }
    int len=Len_linklist(L);
    for(int i=0;i<len;i++)
    {
        L=delete_head(L);
    }
    return L;
}

练习6：单向循环链表节点创建 

/*
 * function:    创建一个节点
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist create_node()
{
Linklist node=(Linklist)malloc(sizeof(struct Node));
    if(NULL==node)
    return NULL;
node->data=0;
node->next=node;//循环链表的每个节点指针域指向自己
    return node;//0x10
}

练习7：单向循环链表头插 

/*
 * function:    头插
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0　失败返回-1
 */
Linklist loop_insert_head(datatype e,Linklist L)
{
	//在堆区创建一个节点
	Linklist node=create_node();//在堆区申请一个节点
	if(node==NULL)
		return L;
	if(NULL==L)
	{
		L=node;
		node->data=e;
	}
	else
	{
		node->next=L->next;
		L->next=node;
		node->data=L->data;
		L->data=e;
	}
	return L;//因为自定义的函数指针的改变不影响实参，需要返回
}

练习8：单向循环链表的尾插

/*
 * function:    尾部插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist loop_insert_rear(datatype e,Linklist L)
{
	Linklist s=create_node();
	s->data=e;
	if(L==NULL)
	{
		L=s;
	}
	else
	{
		Linklist rear=L;
		while(rear->next!=L)
		{
			rear=rear->next;
		}
		rear->next=s;
		s->next=L;
	}
	return L;
}

练习9：单向循环链表的头删

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

 练习10：单向循环链表的尾删

/*
 * function:    尾部删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist delete_rear(Linklist L)
{
	//1.判断链表是否为空
	if(NULL==L)
	{
		return NULL;
	}
	//2.判断如果链表只有一个节点
	else if(L->next==L)
	{
		free(L);
		L=NULL;
	}
	else
	{
		//3.有多个节点
		//循环倒数第二个节点
		Linklist second=L;
		while(second->next->next!=L)
		{
			second=second->next;
		}
		free(second->next);
		second->next=L;
	}
	return L;
}

练习11：单向循环链表的遍历

 

/*
 * function:    循环遍历
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int loop_output(Linklist L)
{
	//判断是否创建
	//判断是否为空
	if(NULL==L)
	{
		return -1;
	}
	Linklist p=L;
	do{
		printf("%d\t",p->data);
		p=p->next;
	}while(p!=L);
	puts("");
}

练习12：约瑟夫环

约瑟夫环：用循环链表编程实现约瑟夫问题

n个人围成一圈，从某人开始报数1, 2, …, m，数到m的人出圈，然后从出圈的下一个人(m+1)开始重复此过程，直到全部人出圈，于是得到一个出圈人员的新序列

如当n=8，m=4时，若从第一个位置数起，则所得到的新的序列 为4, 8, 5, 2, 1, 3, 7, 6。

 

/*
 * function:    约瑟夫环
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void Joseph(Linklist L,int n,int m)
{
	Linklist p=L;
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m-2;j++)
		{
			p=p->next;
		}
		Linklist q=p->next;
		p->next=q->next;
		printf("%d\t",q->data);
		free(q);
		q=NULL;
		p=p->next;
	}
	printf("\n");
}

单向循环链表目前整体代码：

head.h：

#ifndef __HEAD_H__
#define __HEAD_H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef int datatype;
//定义单链表节点结构体
typedef struct Node
{
	//数据域：数据元素
	datatype data;
	//指针域：存储下一个节点的地址
	struct Node *next;	
}*Linklist;
Linklist create_node();
Linklist loop_insert_head(datatype e,Linklist L);
int loop_output(Linklist L);
Linklist loop_insert_rear(datatype e,Linklist L);
Linklist loop_delete_head(Linklist L);
Linklist delete_rear(Linklist L);
void Joseph(Linklist L,int n,int m);

#endif

test.c：

#include "head.h"
/*
 * function:    创建一个节点
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist create_node()
{
	Linklist node=(Linklist)malloc(sizeof(struct Node));
	if(NULL==node)
		return NULL;
	node->data=0;
	node->next=node;//循环链表的每个节点指针域指向自己
	return node;
}
/*
 * function:    头插
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0　失败返回-1
 */
Linklist loop_insert_head(datatype e,Linklist L)
{
	//在堆区创建一个节点
	Linklist node=create_node();//在堆区申请一个节点
	if(node==NULL)
		return L;
	if(NULL==L)
	{
		L=node;
		node->data=e;
	}
	else
	{
		node->next=L->next;
		L->next=node;
		node->data=L->data;
		L->data=e;
	}
	return L;//因为自定义的函数指针的改变不影响实参，需要返回
}
/*
 * function:    循环遍历
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int loop_output(Linklist L)
{
	//判断是否创建
	//判断是否为空
	if(NULL==L)
	{
		return -1;
	}
	Linklist p=L;
	do{
		printf("%d\t",p->data);
		p=p->next;
	}while(p!=L);
	puts("");
}
/*
 * function:    尾部插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist loop_insert_rear(datatype e,Linklist L)
{
	Linklist s=create_node();
	s->data=e;
	if(L==NULL)
	{
		L=s;
	}
	else
	{
		Linklist rear=L;
		while(rear->next!=L)
		{
			rear=rear->next;
		}
		rear->next=s;
		s->next=L;
	}
	return L;
}
/*
 * function:    头删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist loop_delete_head(Linklist L)
{
	//判断链表是否为空
	if(NULL==L)
	{
		return L;
	}
	if(L->next==L)
	{
		free(L);
		L=NULL;
	}
	else
	{
		Linklist q=L->next;
		L->data=q->data;
		L->next=q->next;
		free(q);
		q=NULL;
	}
	return L;
}
/*
 * function:    尾部删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist delete_rear(Linklist L)
{
	//1.判断链表是否为空
	if(NULL==L)
	{
		return NULL;
	}
	//2.判断如果链表只有一个节点
	else if(L->next==L)
	{
		free(L);
		L=NULL;
	}
	else
	{
		//3.有多个节点
		//循环倒数第二个节点
		Linklist second=L;
		while(second->next->next!=L)
		{
			second=second->next;
		}
		free(second->next);
		second->next=L;
	}
	return L;
}
/*
 * function:    约瑟夫环
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void Joseph(Linklist L,int n,int m)
{
	Linklist p=L;
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m-2;j++)
		{
			p=p->next;
		}
		Linklist q=p->next;
		p->next=q->next;
		printf("%d\t",q->data);
		free(q);
		q=NULL;
		p=p->next;
	}
	printf("\n");
}

main.c：

#include "head.h"
int main(int argc, const char *argv[])
{
	Linklist L=NULL;
	/*
	int n;
	datatype e;
	printf("please enter n:");
	scanf("%d",&n);

	for(int i=0;i<n;i++)
	{
		printf("please enter element:");
		scanf("%d",&e);
		//头插：在头指针当前节点插入
		L=loop_insert_head(e,L);
	}
	loop_output(L);

	//尾部插入
	for(int i=0;i<n;i++)
	{
		printf("please enter element:");
		scanf("%d",&e);
	    L=loop_insert_rear(e,L);
	}
    loop_output(L);
	
	//循环链表
	//loop_output(L);
	//头删
	//L=loop_delete_head(L);
	//loop_output(L);

	//尾删
	//L=delete_rear(L);
	//loop_output(L);
	*/

	int n,m;//n表示节点的总个数，m表示几个一出圈
	printf("输入一共有多个人：");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		L=loop_insert_rear(i+1,L);
	}

	//约瑟夫环
	printf("输入几个一出圈：");
	scanf("%d",&m);
	Joseph(L,n,m);
	return 0;
}

  

练习13：双向链表节点创建

/*
 * function:    创建节点
 * @param [ in] 
 * @param [out] 
 * @return      返回节点的地址
 */
DoubleLink create_node()
{
DoubleLink node=(DoubleLink)malloc(sizeof(struct Node));
    if(NULL==node)
    return NULL;
    //对新节点的数据域初始化
    strcpy(node->data,"");
    //对指针域赋值
node->next=node->prev=NULL;
    return node;
}

练习14：双向链表头插

/*
 * function:    双向链表头插
 * @param [ in] 
 * @param [out] 
 * @return      返回链表
 */
DoubleLink insert_head(datatype e,DoubleLink L)
{
    //1,创建新节点s
DoubleLink s=create_node();
    if(NULL==s)
    return L;
    
    strcpy(s->data,e);
    if(NULL !=L)
    {
    s->next=L;
    L->prev=s;
    }
    L=s;
    return L;
}

练习15：双向链表尾插

/*
 * function:    尾部插入
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
DoubleLink insert_rear(datatype e,DoubleLink L)
{
    //1,创建新节点s
DoubleLink s=create_node();
    if(NULL==s)
    return L;
    strcpy(s->data,e);
    //链表为空
    if(NULL==L)
    {
    L=s;
    return L;
    }
    
    //表示存在多个节点
    //找到尾部节点
DoubleLink rear=L;
    while(rear->next!=NULL)
    {
    rear=rear->next;
    }
rear->next=s;
s->prev=rear;
    return L;
}

练习16：双向链表头删

/*
 * function:    头删
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
DoubleLink delete_head(DoubleLink L)
{
    //1,如果链表为空，
    if(NULL==L)
    return L;
    //2,判断链表只有一个节点
    if(NULL==L->next)
    {
    free(L);
    L=NULL;
    return L;
    }
    //3,有多个节点
DoubleLink q=L->next;
    strcpy(L->data,q->data);
L->next=q->next;
    if(q->next!=NULL)
    q->next->prev=L;
    free(q);
q=NULL;
    return L;
}

练习17：双向链表尾删

 

/*
 * function:    尾部删除
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
DoubleLink delete_rear(DoubleLink L)
{
    //1,如果链表为空，
    if(NULL==L)
    return L;
    //2,判断链表只有一个节点
    if(NULL==L->next)
    {
    free(L);
    L=NULL;
    return L;
    }
    //3,存在多个节点
    //找到倒数第一个节点
DoubleLink rear=L;
    while(rear->next!=NULL)
    rear=rear->next;

rear->prev->next=NULL;
    free(rear);
rear=NULL;
    return L;
}

练习18：双向链表遍历

/*
 * function:    循环输出
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void output(DoubleLink L)
{
    //1,判断链表是否为空
    if(NULL==L)
    {
    return;
    }
    //正向遍历
    puts("正向遍历");
    while(L->next!=NULL)
    {
    printf("%s\t",L->data);
    L=L->next;
    }
    printf("%s\t",L->data);
    puts("\n逆向遍历");
    while(L!=NULL)
    {
        
    printf("%s\t",L->data);
    L=L->prev;
    }
    puts("");
    
}

双向链表目前整体代码：

head.h：

#ifndef __HEAD_H
#define __HEAD_H

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef char datatype[20];//datatype-->char [20]

//定义双向链表节点的结构体
typedef struct Node
{
	//数据域：数据元素
	datatype data;
	//指针域：下一个节点的地址
	struct Node *next;
	//指针域：上一个节点的地址
	struct Node *prev;
}*DoubleLink;

DoubleLink create_node();
DoubleLink insert_head(datatype e,DoubleLink L);
void output(DoubleLink L);
DoubleLink insert_rear(datatype e,DoubleLink L);
DoubleLink delete_head(DoubleLink L);
DoubleLink delete_rear(DoubleLink L);

#endif

test.c：

#include "double_head.h"
/*
 * function:    创建节点
 * @param [ in] 
 * @param [out] 
 * @return      返回节点位置
 */
DoubleLink create_node()
{
	DoubleLink node=(DoubleLink)malloc(sizeof(struct Node));
	if(NULL==node)
		return NULL;
	//对新节点的数据域初始化
	strcpy(node->data,"");
	//对指针域赋值
	node->next=node->prev=NULL;
	return node;
}
/*
 * function:    双向链表头插
 * @param [ in] 
 * @param [out] 
 * @return      返回链表
 */
DoubleLink insert_head(datatype e,DoubleLink L)
{
	//1.创建新节点s
	DoubleLink s=create_node();
	if(NULL==s)
		return L;
	strcpy(s->data,e);
	if(NULL!=L)
	{
		s->next=L;
		L->prev=s;
	}
	L=s;
	return L;
}
/*
 * function:    循环输出
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void output(DoubleLink L)
{
	//1.判断链表是否为空
	if(NULL==L)
	{
		return;
	}
	//正向遍历
	puts("正向遍历：");
	while(L->next!=NULL)
	{
		printf("%s\t",L->data);
		L=L->next;
	}
	printf("%s\t",L->data);
	puts("");
	//逆向遍历
	puts("逆向遍历");
	while(L!=NULL)
	{
		printf("%s\t",L->data);
		L=L->prev;
	}
	puts("");
}
/*
 * function:    双向链表尾插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DoubleLink insert_rear(datatype e,DoubleLink L)
{
	//1.创建新节点s
	DoubleLink s=create_node();
	if(NULL==s)
		return L;
	strcpy(s->data,e);
	//链表为空
	if(NULL==L)
	{
		L=s;
		return L;
	}
	//表示存在多个节点
	//找到尾部节点
	DoubleLink rear=L;
	while(rear->next!=NULL)
	{
		rear=rear->next;
	}
	rear->next=s;
	s->prev=rear;
	return L;
}
/*
 * function:    双向链表头删
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
DoubleLink delete_head(DoubleLink L)
{
	//1.如果链表为空
	if(NULL==L)
		return L;
	//2.判断链表只有一个节点
	if(NULL==L->next)
	{
		free(L);
		L=NULL;
		return L;
	}
	//3.存在多个节点
	DoubleLink q=L->next;
	strcpy(L->data,q->data);
	L->next=q->next;
	if(q->next!=NULL)
		q->next->prev=L;
	free(q);
	q=NULL;
	return L;
}
/*
 * function:    双向链表尾删
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
DoubleLink delete_rear(DoubleLink L)
{
	//1.如果链表为空
	if(NULL==L)
		return L;
	//2.判断链表只有一个节点
	if(NULL==L->next)
	{
		free(L);
		L=NULL;
		return L;
	}
	//3.存在多个节点
	//找到倒数第一个节点
	DoubleLink rear=L;
	while(rear->next!=NULL)
		rear=rear->next;
	rear->prev->next=NULL;
	free(rear);
	rear=NULL;
	return L;
}

main.c：

#include "double_head.h"
int main(int argc, const char *argv[])
{
	DoubleLink L=NULL;
	int n;
	datatype e;
	printf("please enter n:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("please enter element:");
		scanf("%s",e);
	  //L=insert_head(e,L);
        L=insert_rear(e,L);
	}
	//循环输出
	output(L);
	
	//头删
	//L=delete_head(L);
	//尾删
	L=delete_rear(L);
	output(L);
	
	return 0;
}

 

三、课后作业：

1.单向链表简单选择排序

void Sort(Linklist L)
{	
	//1.判断是否为空
	//2.判断如果链表只有一个节点
	if(NULL==L||L->next==NULL)
	{
		return;
	}
	//简单选择
	int len=Len_linklist(L);
	Linklist p;
	Linklist q;
	int i,j;
	for(i=0,p=L;i<len-1;i++,p=p->next)
	{
		Linklist min=p;
		for(j=i+1,q=p->next;j<len;j++,q=q->next)
		{
			if(min->data>q->data)
			{
				min=q;
			}

		}
		if(min!=p)
		{
			datatype t=p->data;
			p->data=min->data;
			min->data=t;
		}
	}
}

2.单向链表任意元素插入

/*
 * function:    按元素插入
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int insert_by_data(datatype key,datatype e,Linklist L)
{
	//1.判断元素是否为空
	if(NULL==L)
	{
		return -1;
	}
	//2.查找元素key
	Linklist p = L;
	while(p!=NULL&&p->data!=key)
	{
		p = p->next;
	}
	//若key不存在，则返回错误码-1
	if(p==NULL)
	{
		return -1;
	}
	//3.创建新节点并插入链表
	Linklist q=create_node();
	q->data=e;
	q->next=p->next;
	p->next=q;
	return 0;
}

3.单向链表任意元素修改

/*
 * function:    按元素修改
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int update_by_data(datatype key,datatype e,Linklist L)
{
	//1.判断元素是否为空
	if(NULL==L)
	{
		return -1;
	}
	//2.查找元素key
	Linklist p = L;
	while(p!=NULL&&p->data!=key)
	{
		p = p->next;
	}
	//若key不存在，则返回错误码-1
	if(p==NULL)
	{
		return -1;
	}
	p->data=e;
	return 0;
}

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

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

相关文章

物联网（IoT）：连接未来的万物之网

物联网（IoT）：连接未来的万物之网

引言&#xff1a; 物联网&#xff08;Internet of Things&#xff0c;简称IoT&#xff09;是指通过各种智能设备和传感器&#xff0c;使物体能够互联互通、收集和共享数据的网络。随着科技的不断进步和智能设备的普及&#xff0c;物联网的应用呈现出爆发式增长&#xff0c;对各…
阅读更多...
Leetcode-每日一题【109.有序链表转换二叉搜索树】

Leetcode-每日一题【109.有序链表转换二叉搜索树】

题目 给定一个单链表的头节点 head &#xff0c;其中的元素 按升序排序 &#xff0c;将其转换为高度平衡的二叉搜索树。 本题中&#xff0c;一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差不超过 1。 示例 1: 输入: head [-10,-3,0,5,9]输出: [0,-3,9,-…
阅读更多...
Es存储和查询

Es存储和查询

基本概念 Cluster 集群&#xff0c;一个ES集群是由多个节点(Node)组成的&#xff0c;每个集群都有一个cluster name 作为标识&#xff0c; 在同一网段下的Es实例会通过cluster name 决定加入哪个集群下。 node 节点&#xff0c;一个ES实例就是一个node&#xff0c;一个机器可以…
阅读更多...
SpringBoot（八）拦截器Interceptor

SpringBoot（八）拦截器Interceptor

上篇介绍了Filter过滤器的使用&#xff0c;提起过滤器&#xff0c;就不得不再提起另外一个叫做拦截器的东西。两者的作用类似&#xff0c;都可以实现拦截请求的作用&#xff0c;但其实两者有着非常大的区别。本篇&#xff0c;我们就来学习下拦截器的使用。 如果你是新手&#x…
阅读更多...
Java阶段五Day09

Java阶段五Day09

Java阶段五Day09 文章目录 Java阶段五Day09网关Gateway跨域的问题熔断限流组件sentinel微服务场景熔断降级限流降级 sentinel学习案例sentinel介绍重要的核心概念准备一个测试的工程定义资源定义规则sentinel运行原理本地文件定义规则整合nacos实现规则的远程读取规则的内容详解…
阅读更多...
【广州华锐互动】AR远程巡检系统在设备维修保养中的作用

【广州华锐互动】AR远程巡检系统在设备维修保养中的作用

随着科技的不断发展&#xff0c;AR(增强现实)远程巡检系统在设备检修中发挥着越来越重要的作用。这种系统可以将AR技术与远程通信技术相结合&#xff0c;实现对设备检修过程的实时监控和远程指导&#xff0c;提高设备检修的效率和质量。 首先&#xff0c;AR远程巡检系统可以帮助…
阅读更多...
Word字间距怎么调整？2023最新方法总结！

Word字间距怎么调整？2023最新方法总结！

“作为一个Word新手&#xff0c;里面的好多功能我都没有弄清楚。今天正好写了一篇文章&#xff0c;但不知道应该怎么调整字间距。有朋友知道Word字间距怎么调的吗&#xff1f;快教教我&#xff01;” Word作为一个便捷的办公软件&#xff0c;让我们的工作更方便。学习好Word的使…
阅读更多...
Unity自定义后处理——Vignette暗角

Unity自定义后处理——Vignette暗角

大家好&#xff0c;我是阿赵。   继续说一下屏幕后处理的做法&#xff0c;这一期讲的是Vignette暗角效果。 一、Vignette效果介绍 Vignette暗角的效果可以给画面提供一个氛围&#xff0c;或者模拟一些特殊的效果。 还是拿这个角色作为底图 添加了Vignette效果后&#xff0…
阅读更多...
svn迁移到git实际操作

svn迁移到git实际操作

1.到svn项目目录右键选中gitbash打开窗口&#xff0c;执行获取用户并映射成git样式账号命令如下: svn log -q | awk -F | /^r/ {sub("^ ", "", $2); sub(" $", "", $2); print $2" "$2" <"$2"163.cn>…
阅读更多...
【【51单片机的蜂鸣器-11】】

【【51单片机的蜂鸣器-11】】

51单片机的蜂鸣器 DS1302我一直有问题搁置了几百天了 先来看看蜂鸣器 搞了一个礼拜verilog然后出去吃饭 估计自己得有10多天没看c语言和51单片机了 现在先处理一下蜂鸣器的问题 蜂鸣器 蜂鸣器分为有源蜂鸣器和无源蜂鸣器 有源内部自带震荡源&#xff0c;将正负极接上直流电压…
阅读更多...
预处理详解（一）---预定义符号

预处理详解（一）---预定义符号

文章目录 预定义符号预定义符号的使用 预定义符号 在C语言中&#xff0c;有一些有意思的预定义符号&#xff0c;这些预定义符号都是语言内置的&#xff0c;即以及定义好的&#xff0c;我们可以直接使用。预定义符号主要有以下几个&#xff1a; __FILE__ //进行编译的源…
阅读更多...
react+unittest+flask 接口自动化测试平台

react+unittest+flask 接口自动化测试平台

目录 1 前言 2 框架 2-1 框架简介 2-2 框架介绍 2-3 框架结构 3 平台 3-1 平台组件图 1 新建用例 2 生成测试任务 3 执行并查看测试报告 3-2 用例管理 3-2-1 用例设计 3-3 任务管理 3-3-1 创建任务 3-3-2 执行任务 3-3-3 测试报告 3-3-4 邮件通知 1 前言 在现…
阅读更多...
SpringMVC:Ajax初体验

SpringMVC:Ajax初体验

阅读更多...
Python 下载安装总结

Python 下载安装总结

title: Python 下载安装总结 date: 2023-06-26 16:40:45 tags: Python categories:开发工具及环境 cover: https://cover.png feature: false 1. 下载 进入官网&#xff1a;Python.org&#xff0c;鼠标悬停在 Downloads&#xff0c;就会出现下载按钮 点击下载&#xff0c;即可…
阅读更多...
uniapp基于阿里图标库引入彩色的图标iconfont

uniapp基于阿里图标库引入彩色的图标iconfont

1.进入阿里巴巴矢量图标库链接: https://www.iconfont.cn/&#xff0c;添加图标到项目&#xff0c;然后下载至本地 2.对下载的文件进行解压&#xff0c;命令行进入解压后的文件下&#xff0c;执行一下命令&#xff0c;全局安装iconfont-tools工具 npm install -g iconfont-to…
阅读更多...
解析基因影响：孟德尔随机化的创新思维

解析基因影响：孟德尔随机化的创新思维

一、引言 在当今的遗传学和生物学研究中&#xff0c;我们对基因对个体特征和性状的影响的理解变得更加深入。然而&#xff0c;基因影响的复杂性和多样性给我们带来了巨大的挑战。为了更好地揭示基因影响的本质和机制&#xff0c;我们需要采用创新的研究思维和方法。 本文的目的…
阅读更多...
myAgv智能移动底盘的slam算法学习以及动态避障

myAgv智能移动底盘的slam算法学习以及动态避障

前言 随着科技得越来越发达&#xff0c;人工智能&#xff0c;自动驾驶导航等字眼频频出现在我们得眼前。但是目前来说自动驾驶并没有得到很全面得普及&#xff0c;还在进行不断的开发和测试当中。从小就爱好车的我&#xff0c;对这项技术也很是感兴趣。 偶然间在上网的时候买…
阅读更多...
echarts_柱状图+漏斗图

echarts_柱状图+漏斗图

目录 柱状图(bar)需求[1] 复制案例[2] 修改类目轴方向[3] 修改数据渲染方向[4] 修改坐标轴文本样式 漏斗图(funnel)漏斗图的形状 柱状图(bar) 需求 如上图&#xff0c;做一个横向柱状图&#xff0c;后端返回的数据是从小向大排列的数据&#xff0c;希望能够按照顺序进行展示。…
阅读更多...
基于MATLAB的无人机遥感数据预处理与农林植被性状估算教程

基于MATLAB的无人机遥感数据预处理与农林植被性状估算教程

详情点击链接&#xff1a;基于MATLAB的无人机遥感数据预处理与农林植被性状估算前言 遥感技术作为一种空间大数据手段&#xff0c;能够从多时、多维、多地等角度&#xff0c;获取大量的农情数据。数据具有面状、实时、非接触、无伤检测等显著优势&#xff0c;是智慧农业必须采…
阅读更多...
Redis的4种分布式限流算法

Redis的4种分布式限流算法

限流 服务系统流量多，的确是一件好事，但是如果过载，把系统打挂了，那大家都要吃席了。 所以，在各种大促活动之前，要对系统进行压测，评估整个系统的峰值QPS，要做一些限流的设置，超过一定阈值，就拒绝处理或者延后处理，避免把系统打挂的情况出现。 限流和熔断有什么区…
阅读更多...
最新文章

Copyright @ 2022~2023