数据结构day5（2023.7.19）

news2024/10/6 16:26:40

一、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;
}

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

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

相关文章

【MySQL】MySQL数据库的初阶使用

【MySQL】MySQL数据库的初阶使用

文章目录 一、MySQL服务的安装二、数据库基础1.什么是数据库&#xff1f;&#xff08;基于CS模式的一套数据存取的网络服务&#xff09;2. Linux文件系统和数据库的关系 && 主流数据库3.MySQL架构 && SQL分类 && MySQL存储引擎 三、MySQL操作库1.库结构…
阅读更多...
携带时间戳主动写入数据到prometheus service（可乱序、go）

携带时间戳主动写入数据到prometheus service（可乱序、go）

使用到的github公开项目 https://github.com/castai/promwrite Prometheus版本2.45.0 拉下来装依赖&#xff0c;然后使用 client_test.go t.Run(“write with custom options”, func(t *testing.T) 这个测试用例里面&#xff0c;删掉srv初始化的部分&#xff0c;这个是模拟一…
阅读更多...
unity02 物体运动

unity02 物体运动

旋转&#xff0c;增量旋转&#xff0c;默认增量为15度 ctrl拖拽物体旋转 设置增量旋转角度大小 edit–>grid and snap settings privot 轴心坐标系&#xff08;中心坐标系&#xff09;默认 local 世界坐标系&#xff08;局部坐标系&#xff09; ctrlD复制物体 物体激活&…
阅读更多...
uni.app如何检测小程序版本更新以及上线后如何关闭全局打印

uni.app如何检测小程序版本更新以及上线后如何关闭全局打印

uni.app如何检测小程序版本更新以及上线后如何关闭全局打印 检测小程序版本更新关闭全局打印 检测小程序版本更新 App.vue 入口文件中 添加如下代码 //检测小程序版本是否更新const updateManager wx.getUpdateManager()updateManager.onCheckForUpdate(function(res) {// 请求…
阅读更多...
Linux基础内容（26）—— 线程的互斥

Linux基础内容（26）—— 线程的互斥

Linux基础内容&#xff08;25&#xff09;—— 线程控制和线程结构_哈里沃克的博客-CSDN博客https://blog.csdn.net/m0_63488627/article/details/131372872?spm1001.2014.3001.5501 目录 1.线程互斥 1.问题引入 2.问题原因 3.安全问题 互斥 加锁 加锁后的特点 如何理…
阅读更多...
每天一道C语言编程：Cylinder（圆柱体问题）

每天一道C语言编程：Cylinder（圆柱体问题）

题目描述 使用一张纸和剪刀&#xff0c;您可以通过以下方式切出两个面形成一个圆柱体&#xff1a; 水平切割纸张&#xff08;平行于较短的边&#xff09;以获得两个矩形部分。 从第一部分开始&#xff0c;切出一个最大半径的圆。圆圈将形成圆柱体的底部。 将第二部分向上滚动&…
阅读更多...
2023网络安全面试题汇总（附答题解析+配套资料）

2023网络安全面试题汇总（附答题解析+配套资料）

随着国家政策的扶持&#xff0c;网络安全行业也越来越为大众所熟知&#xff0c;相应的想要进入到网络安全行业的人也越来越多&#xff0c;为了更好地进行工作&#xff0c;除了学好网络安全知识外&#xff0c;还要应对企业的面试。 所以在这里我归总了一些网络安全方面的常见面…
阅读更多...
牛顿修正法在二阶近似方法中的应用

牛顿修正法在二阶近似方法中的应用

使用optimtool的牛顿修正法来应用学习 pip install optimtool --upgrade pip install optimtool>2.4.2optimtool包所依据的理论支撑中&#xff0c;还没有为二阶微分方法作邻近算子的近似与修正&#xff0c;所以二阶近似方法是研究无不可微项的可微函数的算子。 牛顿修正法…
阅读更多...
docker部署mysql8主从集群（互为主从），keepalived保证高可用

docker部署mysql8主从集群（互为主从），keepalived保证高可用

一、准备2台物理机器master-1、master-2&#xff0c;目标虚拟VIP。 　　VIP:172.50.2.139 　　master-1:172.50.2.41 　　master-2:172.50.2.42 二、然后分别在2台物理机器master-1、master-2上使用docker-compose安装mysql8&#xff0c;并配置互为主从。1&#xff09;配置mas…
阅读更多...
2023-7-19-第二十式迭代器模式

2023-7-19-第二十式迭代器模式

&#x1f37f;*★,*:.☆(&#xffe3;▽&#xffe3;)/$:*.★* &#x1f37f; &#x1f4a5;&#x1f4a5;&#x1f4a5;欢迎来到&#x1f91e;汤姆&#x1f91e;的csdn博文&#x1f4a5;&#x1f4a5;&#x1f4a5; &#x1f49f;&#x1f49f;喜欢的朋友可以关注一下&#xf…
阅读更多...
深入理解Java虚拟机（五）虚拟机类加载机制

深入理解Java虚拟机（五）虚拟机类加载机制

代码编译的结果从本地机器码转变为字节码&#xff0c;是存储格式发展的一小步&#xff0c;却是编程语言发展的一大步。 一、概述 Java虚拟机把描述类的数据从Class文件加载到内存&#xff0c;并对数据进行校验、转换解析和初始化&#xff0c;最终形成可以被虚拟机直接使用的Jav…
阅读更多...
队列的表示和操作

队列的表示和操作

队列&#xff1a;队列是仅在表尾进行插入操作&#xff0c;在表头进行删除操作的线性表。 表尾即an端&#xff0c;称为队尾&#xff0c;表头即a1端&#xff0c;称为队头。 队列的存储方式&#xff1a;顺序队列和链式队列 队列顺序表示 #define MAXQSIZE 100 //最大队列长度 …
阅读更多...
Vue 1 - 安装、快速上手

Vue 1 - 安装、快速上手

文章目录 关于 Vue创建应用 关于 Vue 官网&#xff1a; https://cn.vuejs.org官方文档-快速上手&#xff1a; https://cn.vuejs.org/guide/quick-start.htmlgithub : https://github.com/vuejsVue SFC Playground : https://play.vuejs.org/ 其他 作者 尤雨溪 Evan You 主页 …
阅读更多...
如何把caj文件改成PDF格式?分享三个免费的方法！

如何把caj文件改成PDF格式?分享三个免费的方法！

在学术研究中&#xff0c;我们可能会遇到CAJ文件&#xff0c;这是一种在中国学术界广泛使用的文档格式。然而&#xff0c;与PDF文件相比&#xff0c;CAJ文件的查看和分享并不那么便捷。下面&#xff0c;我会为你介绍三种免费且简便的方法&#xff0c;帮助你将CAJ文件转化为PDF格…
阅读更多...
PSP - Jackhmmer 搜索 EMBL 序列数据库的相似序列

PSP - Jackhmmer 搜索 EMBL 序列数据库的相似序列

欢迎关注我的CSDN&#xff1a;https://spike.blog.csdn.net/ 本文地址&#xff1a;https://spike.blog.csdn.net/article/details/131817060 EMBL (European Molecular Biology Laboratory&#xff0c;欧洲分子生物实验室)&#xff1a;EMBL 数据库是一个由欧洲生物信息学研究所…
阅读更多...
Microsoft Outlook如何定时发送邮件

Microsoft Outlook如何定时发送邮件

点击New Emai 选择Options→Delay Delivery→Do not deliver before→Close
阅读更多...
基于linux下的高并发服务器开发（第二章）- 2.13 匿名管道通信案例

基于linux下的高并发服务器开发（第二章）- 2.13 匿名管道通信案例

实现 ps aux | grep xxx 父子进程间通信 子进程&#xff1a; ps aux, 子进程结束后&#xff0c;将数据发送给父进程 父进程&#xff1a;获取到数据&#xff0c;过滤 pipe() execlp() 子进程将标准输出 stdout_fileno 重定向到管道的写端。 dup2 07 / 匿名管道…
阅读更多...
java项目之班级同学录网站（ssm+mysql+jsp)

java项目之班级同学录网站（ssm+mysql+jsp)

风定落花生&#xff0c;歌声逐流水&#xff0c;大家好我是风歌&#xff0c;混迹在java圈的辛苦码农。今天要和大家聊的是一款基于ssm的班级同学录网站。技术交流和部署相关看文章末尾&#xff01; 开发环境&#xff1a; 后端&#xff1a; 开发语言&#xff1a;Java 框架&a…
阅读更多...
强化学习之DQN（deep Q-network）算法

强化学习之DQN（deep Q-network）算法

一、简介 DQN算法是深度学习领域首次广泛应用于强化学习的算法模型之一。它于2013年由DeepMind公司的研究团队提出&#xff0c;通过将深度神经网络与经典的强化学习算法Q-learning结合&#xff0c;实现了对高维、连续状态空间的处理&#xff0c;具备了学习与规划的能力。 二、…
阅读更多...
使用Pandas计算两个系统客户名称的相似度

使用Pandas计算两个系统客户名称的相似度

引言&#xff1a; 在日常业务处理中&#xff0c;我们经常会面临将不同系统中的数据进行匹配和比对的情况。特别是在涉及到客户管理的领域&#xff0c;我们需要确保两个系统中的客户记录是准确、一致和无重复的。 本文将介绍如何使用Python的Pandas库来处理这个问题。我们将以…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023