嵌入式学习——数据结构（双向无头有环链表、内核链表、栈）——day48

1. 约瑟夫环问题——双向无头回环链表

1.1 问题描述

        给定 ( n ) 个人（编号为 ( 1, 2, \ldots, n )），他们围成一个圈。从第一个人开始报数，每报到第 ( k ) 个人时，杀掉这个人，然后从下一个人重新开始报数。重复这个过程，直到所有人都被杀死。约瑟夫环问题是要确定最后一个幸存者的编号。

1.2 实质

        每次删除循环链表中的一个节点，直到链表中仅剩一个节点结束

2. 双向无头循环链表代码

2.1 makefile

OBJ:=a.out
OBJS+=main.c doublelink.c
CCl=gcc

$(OBJ):$(OBJS)
	$(CC) $^ -o $@
.PHONY:
clean:
	rm $(OBJ)
test:
	valgrind --tool=memcheck --leak-check=full ./$(OBJ)

2.2 double.h

#ifndef _DOUBLELINK_H_
#define _DOUBLELINK_H_

typedef struct stu
{
    int id;
    char name[32];
    int score;
}DataType;

typedef struct node
{
    DataType data;
    struct node *ppre;
    struct node *pnext;
}DouNode;

typedef struct list
{
    DouNode *phead;
    int clen;
}DouList;

extern DouList *create_dou_link();
extern int is_empty_dou_link(DouList *plist);
extern void dou_link_for_each(DouList *plist, int dir);
extern int push_head_dou_link(DouList *plist, DataType data);
extern int  push_tail_dou_link(DouList *plist, DataType data);
extern int pop_head_dou_link(DouList *plist);
extern int pop_tail_dou_link(DouList *plist);
extern void loop_dou_link(DouList *plist);
extern DouNode *Joseph_loop(DouList *plist);
extern void dou_link_for_remain(DouList *plist);

#endif

2.3 double.c

#include "doublelink.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

DouList *create_dou_link()//创建标签
{
    DouList *plist = NULL;

    plist = (DouList *)malloc(sizeof(DouList));
    if (NULL == plist)
    {
        perror("fail to malloc");
        return NULL;
    }

    plist->phead = NULL;
    plist->clen = 0;

    return plist;
}

int is_empty_dou_link(DouList *plist)//判断空链表
{
    if (NULL == plist->phead)
    {
        return 1;
    }

    return 0;
}

int push_head_dou_link(DouList *plist, DataType data)//头插
{
    DouNode *pnode = NULL;

    pnode = malloc(sizeof(DouNode));
    if (NULL == pnode)
    {
        perror("fail to malloc");
        return -1;
    }

    pnode->data = data;
    pnode->ppre = NULL;
    pnode->pnext = NULL;

    if (is_empty_dou_link(plist))//空链表直接插
    {
        plist->phead = pnode;
    }
    else
    {
        pnode->pnext = plist->phead;
        plist->phead->ppre = pnode;
        plist->phead = pnode;
    }
    plist->clen++;

    return 0;
}

int push_tail_dou_link(DouList *plist, DataType data)//头插
{
    DouNode *p = NULL;
    DouNode *pnode = NULL;

    pnode = malloc(sizeof(DouNode));
    if (NULL == pnode)
    {
        perror("fail to malloc");
        return -1;
    }
    pnode->data = data;
    pnode->ppre = NULL;
    pnode->pnext = NULL;

    if (is_empty_dou_link(plist))//空链表直接插
    {
        plist->phead = pnode;
    }
    else
    {   
        p = plist->phead;
        while (p->pnext != NULL)
        {
            p = p->pnext;
        }

        p->pnext = pnode;
        pnode->ppre = p;
    }
    plist->clen++;

    return 0;
}

int pop_head_dou_link(DouList *plist)//头删
{
    if (is_empty_dou_link(plist))//空链表直接结束程序
    {
        return -1;
    }

    DouNode *pfree = NULL;
    pfree = plist->phead;

    plist->phead = pfree->pnext;//标签指向第二个节点首地址
    if (plist->phead != NULL)//判断是否空链表
    {
        plist->phead->ppre = NULL;//将第二个节点的ppre变为NULL
    }
    free(pfree);

    plist->clen--;

    return 0;
}
 
int pop_tail_dou_link(DouList *plist)//尾删
{
    if (is_empty_dou_link(plist))//空链表程序结束
    {
        return -1;
    }

    DouNode *pfree = NULL;

    pfree = plist->phead;

    while (pfree->pnext)//指针指向最后一个节点
    {
        pfree = pfree->pnext;
    }

    if (pfree->ppre != NULL)//链表有两个以上节点
    {
        pfree->ppre->pnext = NULL;
    }
    else //链表只有一个节点
    {
        plist->phead = NULL;
    }

    free(pfree);
    plist->clen--;

    return 0;
}

void loop_dou_link(DouList *plist)//将非回环链表改为双向回环链表
{
    DouNode *ptmpnode = NULL;

    ptmpnode = plist->phead;
    while (ptmpnode->pnext != NULL)//将指针移动到末尾节点
    {
        ptmpnode = ptmpnode->pnext;
    }

    ptmpnode->pnext = plist->phead;
    plist->phead->ppre = ptmpnode;
}

void dou_link_for_remain(DouList *plist)//打印约瑟夫回环一次处理后链表中剩下的成员信息
{
    int i = 0;
    DouNode *ptmpnode = plist->phead;

    for (i = 0; i < plist->clen; i++)
    {
        printf("%d  ", ptmpnode->data.id);
        printf("%s  ", ptmpnode->data.name);
        printf("%d\n", ptmpnode->data.score);
        ptmpnode = ptmpnode->pnext;
    }
    printf("=========================\n");
}

DouNode *Joseph_loop(DouList *plist)//约瑟夫回环、实质是删除链表节点直到留下最后一个节点为止
{
    DouNode *pfreenode = NULL;//
    DouNode *ptmpnode = NULL;//指向回环

    ptmpnode = plist->phead;

    while (ptmpnode != ptmpnode->pnext)//判断回环是否只剩下一个节点
    {
        
        pfreenode = ptmpnode;//指向当前所在回环的位置

        pfreenode = pfreenode->pnext->pnext;//回环向后移动两个单位
        pfreenode->ppre->pnext = pfreenode->pnext;
        pfreenode->pnext->ppre = pfreenode->ppre; 

        ptmpnode = pfreenode->pnext;//记录要删除的回环的下一个位置，保证循环的延续
        if (pfreenode == plist->phead)//判断要删除的节点是否是表头后的第一个节点、若是，给表头接入要删除节点的下一个节点
        {
            plist->phead = ptmpnode;
        }

        free(pfreenode);
        plist->clen--;
        dou_link_for_remain(plist);//打印链表中剩下的节点信息
    }

    return ptmpnode;
}

2.4 main.c

#include <stdio.h>
#include <stdlib.h>
#include "doublelink.h"

int main(void)
{
    DataType stus[] = {{1, "doinb", 100},
                        {2, "lwx", 67},
                        {3, "lqs", 99},
                        {4, "tian", 98},
                        {5, "gimgoon", 78},
                        {6, "xinyi", 88},
                        {7, "nuguri", 99},
                        {8, "khan", 77},
                        {9, "bo", 94},
                        {10, "xiaolaohu", 60}
                        };
    DouNode *ptmpnode = NULL;
    int i = 0;

    DouList *plist = create_dou_link();//表头创建
    if (NULL == plist)
    {
        return -1;
    }

    for (i = 0; i < sizeof(stus) / sizeof(stus[0]); i++)//给链表中插入结构体中的所有内容
    {
        push_tail_dou_link(plist, stus[i]);//尾插
    }
    dou_link_for_each(plist, 1);
    dou_link_for_each(plist, 0);

    loop_dou_link(plist);//创建双向回环链表
    
    ptmpnode = Joseph_loop(plist);//约瑟夫回环
    printf("%s\n", ptmpnode->data.name); 

    return 0;
}

2.5  判断单向链表是否有环

        利用快慢指针，慢指针走一步，快指针走两步

        快指针每走一步，判断是否为空或者是否与慢指针相遇，相遇为有环链表

3. 内核链表（有头、双向循环链表）

3.1 定义

        Linux内核链表是一种双向循环链表，它的实现非常简洁而高效，主要通过一些宏和内联函数来操作链表。链表节点的结构定义在头文件 <linux/list.h> 中。

3.1 offsetof宏

        获取结构体某个成员到结构体开头的偏移量

3.2 container_of宏

        通过offsetof偏移量获取结构体的首地址

3. 栈

3.1 定义

        栈（Stack）是一种抽象的数据结构，它遵循后进先出（LIFO, Last In First Out）的原则。也就是说，最后放入栈中的元素最先被取出。

3.2 栈的基本操作

        1. 入栈、压栈：将一个元素放入栈顶。

        2. 出栈、弹栈：从栈顶移除一个元素。

        3. 取栈顶元素：查看栈顶元素但不移除它。

        4. 判断栈是否为空：检查栈中是否有元素。

3.3 分类

        （1）按实现方式分类：栈分为顺序栈和链式栈

        1. 顺序栈

               使用数组实现的栈，数组中的元素按顺序存储。优点是实现简单，访问效率高；缺点是栈的容量固定，扩展不便。 

        2. 链式栈

        使用链表实现的栈，链表的每个节点存储一个栈元素。优点是栈的容量可以动态扩展；缺点是指针操作复杂，访问效率相对较低。

        （2）按用途来分类

        1. 操作系统栈

        用于管理程序执行时的函数调用，保存函数调用的返回地址、本地变量等信息。操作系统栈通常是顺序栈，采用固定大小。

                1. 局部变量

                2. 函数的形参、返回值

                3. 函数调用关系——保护现场、恢复现场

3.4 数据结构中的栈——链式栈

4. 面试考点

        区分满增栈、满减栈、空增栈、空减栈（前提：仅限于顺序栈，数组方式构成的）

4.1 满栈和空栈——判断栈顶所在位置是否存有数据而非整个栈有没有数据

        1. 满栈：栈顶所在位置有数据

                入栈操作流程：先向上移动栈顶指针，再将数据压入栈中

        2. 空栈：栈顶所在位置没有数据

                入栈操作流程：先将数据压入栈顶，再向上移动栈顶指针


 

4.2 增栈和减栈——判断栈的生长方向

        0x1000与0x2000，内存高地址为0x2000，内存低地址为0x1000

        1. 增栈：数据入栈时栈顶指针向内存高地址移动

        2. 减栈：数据入栈时栈顶指针向内存低地址移动

（1） 满增栈

        1. 出栈时：栈顶指针向内存高地址移动，再向栈顶入栈数据，

        2. 出栈时：出栈数据，栈顶指针向内存低地址移动，

（2） 满减栈

（3） 空增栈

        1. 出栈时：先向栈顶入栈数据，栈顶指针向内存高地址移动

        2. 出栈时：栈顶指针向内存低地址移动，出栈数据

（4） 空减栈

5. 数据结构中的栈——链式栈

5.1 代码

（1）makefile

OBJ:=a.out
OBJS+=main.c stack.c
CCl=gcc

$(OBJ):$(OBJS)
	$(CC) $^ -o $@
.PHONY:
clean:
	rm $(OBJ)
test:
	valgrind --tool=memcheck --leak-check=full ./$(OBJ)

注意：在终端输入make test可以测试销毁是否成功以及是否有内存泄漏

（2）stack.h

#ifndef _STACK_H_
#define _STACK_H_

typedef int DataType;

typedef struct stact_node
{
    DataType data;
    struct stact_node *pnext;
}StackNode;

typedef struct Stack
{
    StackNode *ptop;
    int clen;
}StackList;

extern StackList *create_stack();
extern int is_empty_stack(StackList *plist);
extern int push_stack(StackList *plist, DataType data);//入栈头插
extern void stack_for_each(StackList *plist);
extern int pop_stack(StackList *plist, DataType *pdata);//出栈头删
extern void clear_stack(StackList *plist);
extern void destory_stack(StackList *plist);
extern int get_stack_top(StackList *plist, DataType *pdata);

#endif

（3）stack.c

#include <stdio.h>
#include <stdlib.h>
#include "stack.h"

StackList *create_stack()
{
    StackList *plist = malloc(sizeof(StackList));
    if (NULL == plist)
    {
        perror("fail to malloc");
        return NULL;
    }
    plist->ptop = NULL;
    plist->clen = 0;
    
    return plist;
}

int is_empty_stack(StackList *plist)
{
    if (NULL == plist->ptop)
    {
        return 1;
    }

    return 0;
}

int push_stack(StackList *plist, DataType data)//入栈头插
{
    StackNode *pnode = malloc(sizeof(StackNode));
    if (NULL == pnode)
    {
        perror("fail to malloc");
        return -1;
    }
    pnode->data = data;
    pnode->pnext = NULL;

    pnode->pnext = plist->ptop;
    plist->ptop = pnode;

    plist->clen++;
    
    return 0;
}

void stack_for_each(StackList *plist)
{
	StackNode *ptmp = plist->ptop;

	while (ptmp != NULL)
	{
		printf("%d ", ptmp->data);
		ptmp = ptmp->pnext;
	}

	printf("\n");
}

int pop_stack(StackList *plist, DataType *pdata)//出栈头删
{
    if (is_empty_stack(plist))
    {
        return -1;
    }

    StackNode *pfree = plist->ptop;

    plist->ptop = pfree->pnext;
    if (pdata != NULL)//传入非空地址，将删除的节点的数据传出
    {
        *pdata = pfree->data;
    }

    free(pfree);
    plist->clen--;

    return 0;
}

void clear_stack(StackList *plist)//清空栈区
{
    while (!is_empty_stack(plist))
    {
        pop_stack(plist, NULL);
    }
}

void destory_stack(StackList *plist)
{
    if (!is_empty_stack(plist))
    {
        clear_stack(plist);
    }
    free(plist);
}

int get_stack_top(StackList *plist, DataType *pdata)//获得栈顶数据
{
    if (is_empty_stack(plist))
    {
        return -1;
    }

    *pdata = plist->ptop->data;

    return 0;
}

（4）main.c

#include <stdio.h>
#include <stdlib.h>
#include "stack.h"

int main(void)
{
    DataType tmpdata = 0;
    DataType data[] = {1, 2, 3, 4, 5};
    StackNode *ptmpnode = NULL;
    int i = 0;
    int ret = 0;

    StackList *plist = create_stack();//创建栈表头
    if (NULL == plist)
    {
        return -1;
    }
    
    for (i = 0; i < sizeof(data) / sizeof(data[0]); i++)//入栈所有数据
    {
        push_stack(plist, data[i]);//入栈头插
    }
    stack_for_each(plist);//遍历打印所有数据

#if 0
    for (i = 0; i < sizeof(data)/sizeof(data[0]); i++)//获取栈顶元素并打印，出栈数据，打印栈中的剩下元素
    {
        printf("======== %d ========", i);
        ret = get_stack_top(plist, &tmpdata);
        if (0 == ret)
        {
            printf("ptop data:%d   ", tmpdata);
        }

        pop_stack(plist, NULL);
        stack_for_each(plist);//遍历打印所有数据
    }
#endif

#if 0
    clear_stack(plist);//清理栈中所有节点
    if (is_empty_stack(plist))
    {
        printf("clear_stack success!\n");
    }
#endif

#if 1
    destory_stack(plist);
#endif

    return 0;
}

5.2  应用

                1. 撤回操作

                2. 浏览器返回上一层操作

                3. 计算器

        示例：利用链式栈实现四则运算

        1. makefile

OBJ:=a.out
OBJS+=calculate.c stack.c
CCl=gcc

$(OBJ):$(OBJS)
	$(CC) $^ -o $@
.PHONY:
clean:
	rm $(OBJ)
test:
	valgrind --tool=memcheck --leak-check=full ./$(OBJ)

        2. calculate.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "stack.h"

int is_char_num(char ch)//判断此指针是否指向数字
{
	if (ch >= '0' && ch <= '9')
	{
		return 1;
	}
	return 0;
}

int get_opt_level(char opt)//获得运算符优先级
{
	switch(opt)
	{
		case '+':
		case '-':
			return 1;
        case '*':
        case '/':
			return 2;
	}
}

int get_result(int num1, int num2, char opt)//获得运算结果
{
	switch(opt)
	{
		case '+':return num1 + num2;
		case '-':return num1 - num2;
		case '/':return num1 / num2;
		case '*':return num1 * num2;
	}
}

int main(int argc, const char *argv[])
{
	char press[128] = {0};//运算表达式
	DataType num = 0;//存储每个运算数
	DataType data;
	DataType opt;
	DataType num1;
	DataType num2;
	DataType res = 0;   //计算器返回值

	StackList *pNumStack = create_stack();//存储数字的栈
	StackList *pOptStack = create_stack();//存储运算符的栈

	fgets(press, sizeof(press), stdin);
	press[strlen(press)-1] = '\0';
	
	char *p = press;//遍历运算式字符串
	
	while (1)
	{
		if ('\0' == *p && is_empty_stack(pOptStack))//循环结束的条件，指针遍历到字符串末尾，运算符栈为空
		{
			break;
		}
        
        /*判断条件1*/
		while (is_char_num(*p))//拆解数字
		{
			num = num * 10 + (*p - '0');
			p++;
			if (!is_char_num(*p))
			{
				push_stack(pNumStack, num);//入栈数字
				num = 0;
			}
		}
		
        /*判断条件2*/
		if (is_empty_stack(pOptStack))//运算符栈为空，入栈
		{
			push_stack(pOptStack, *p);
			p++;
			continue;
		}

        /*判断条件3*/
		if ('\0' == *p && !is_empty_stack(pOptStack))//结束条件
		{
			pop_stack(pOptStack, &opt);
			pop_stack(pNumStack, &num2);
			pop_stack(pNumStack, &num1);
			res = get_result(num1, num2, opt);
			push_stack(pNumStack, res);	
			continue;
		}

        /*判断条件4*/
		get_stack_top(pOptStack, &data);
		if (get_opt_level(data) < get_opt_level(*p))//运算符栈不为空,本次运算符优先级大于栈顶中运算符优先级
		{
			push_stack(pOptStack, *p);
			p++;
		}
		else if (get_opt_level(data) >= get_opt_level(*p))
		{
			pop_stack(pOptStack, &opt);
			pop_stack(pNumStack, &num2);
			pop_stack(pNumStack, &num1);
			res = get_result(num1, num2, opt);
			push_stack(pNumStack, res);
		}
	}

	get_stack_top(pNumStack, &res);
	printf("res = %d\n", res);
	
	destaroy_stack(pNumStack);
	destaroy_stack(pOptStack);

	return 0;
}

        3. stack.c

#include "stack.h"
#include <stdlib.h>
#include <stdio.h>

StackList *create_stack()
{
	StackList *pstack = malloc(sizeof(StackList));
	if (NULL == pstack)
	{
		perror("fail malloc");
		return NULL;
	}
	pstack->ptop = NULL;
	pstack->clen = 0;

	return pstack;
}
int is_empty_stack(StackList *pstack)
{
	if (NULL == pstack->ptop)
	{
		return 1;
	}
	return 0;
}
int push_stack(StackList *pstack, DataType data)
{
	StackNode *pnode = malloc(sizeof(StackNode));
	if (NULL == pnode)
	{
		perror("fail malloc");
		return -1;
	}
	pnode->data = data;
	pnode->pnext = NULL;

	pnode->pnext = pstack->ptop;
	pstack->ptop = pnode;

	pstack->clen++;

	return 0;
}
int pop_stack(StackList *pstack, DataType *pdata)
{
	if (is_empty_stack(pstack))
	{
		return 1;
	}
	
	StackNode *pfree = pstack->ptop;
	pstack->ptop = pfree->pnext;
	if (pdata != NULL)
	{
		*pdata = pfree->data;
	}
	free(pfree);
	pstack->clen--;
	
	return 0;
}
void clear_stack(StackList * pstack)
{
	while (!is_empty_stack(pstack))
	{
		pop_stack(pstack, NULL);
	}
}
void destaroy_stack(StackList *pstack)
{
	clear_stack(pstack);
	free(pstack);
}
int get_stack_top(StackList *pstack, DataType *pdata)
{
	if (is_empty_stack(pstack))
	{
		return 1;
	}
	*pdata = pstack->ptop->data;
	return 0;
}

        4. stack.h

#ifndef __STACK_H__
#define __STACK_H__

typedef int DataType;

typedef struct stk_node
{
	DataType data;
	struct stk_node *pnext;
}StackNode;

typedef struct Stack
{
	StackNode *ptop;
	int clen;
}StackList;

StackList *create_stack();
int is_empty_stack(StackList *);
int push_stack(StackList *, DataType );
int pop_stack(StackList *, DataType *);
void clear_stack(StackList *);
void destaroy_stack(StackList *);
int get_stack_top(StackList *, DataType *);

#endif

        

        

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

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

相关文章

Softing “Ethernet-APL现场交换机”亮相ACHEMA 2024

Softing “Ethernet-APL现场交换机”亮相ACHEMA 2024

Softing工业在ACHEMA 2024上展示了新的“aplSwitch Field”。作为一个先进的16端口以太网高级物理层&#xff08;Ethernet-APL&#xff09;现场交换机&#xff0c;它配有可选的PROFIBUS Process Automation&#xff08;PA&#xff09;代理&#xff0c;适用于Zone 2环境&#xf…
阅读更多...
Windows 可变刷新率是什么？如何开启？

Windows 可变刷新率是什么？如何开启？

在现代计算设备中&#xff0c;显示屏的刷新率对用户体验起着至关重要的作用。随着显示技术的不断进步&#xff0c;固定刷新率显示器逐渐被支持可变刷新率&#xff08;Variable Refresh Rate, VRR&#xff09;技术的显示器所取代。 可变刷新率定义 可变刷新率是什么&#xff1…
阅读更多...
基于Springboot + vue 的抗疫物质管理系统的设计与实现

基于Springboot + vue 的抗疫物质管理系统的设计与实现

目录 &#x1f4da; 前言 &#x1f4d1;摘要 &#x1f4d1;系统流程 &#x1f4da; 系统架构设计 &#x1f4da; 数据库设计 &#x1f4da; 系统功能的具体实现 &#x1f4ac; 系统登录注册 系统登录 登录界面 用户添加 &#x1f4ac; 抗疫列表展示模块 区域信息管理 …
阅读更多...
vue项目集成CanvasEditor实现Word在线编辑器

vue项目集成CanvasEditor实现Word在线编辑器

CanvasEditor实现Word在线编辑器 官网文档&#xff1a;https://hufe.club/canvas-editor-docs/guide/schema.html 源码地址&#xff1a;https://github.com/Hufe921/canvas-editor 前提声明&#xff1a; 由于CanvasEditor目前不支持vue、react 等框架开箱即用版&#xff0c;所以…
阅读更多...
数据库原理与安全复习笔记（未完待续）

数据库原理与安全复习笔记（未完待续）

1 概念 产生与发展&#xff1a;人工管理阶段 → \to → 文件系统阶段 → \to → 数据库系统阶段。 数据库系统特点&#xff1a;数据的管理者&#xff08;DBMS&#xff09;&#xff1b;数据结构化&#xff1b;数据共享性高&#xff0c;冗余度低&#xff0c;易于扩充&#xff…
阅读更多...
初学51单片机之PWM实例呼吸灯以及遇到的问题（已解答）

初学51单片机之PWM实例呼吸灯以及遇到的问题（已解答）

PWM全名Pulse Width Modulation中文称呼脉冲宽度调制 如图 这是一个周期10ms、频率是100HZ的波形&#xff0c;但是每个周期内&#xff0c;高低电平宽度各不相同&#xff0c;这就是PWM的本质。 占空比是指高电平占整个周期的比列,上图第一个波形的占空比是40%&#xff0c;第二个…
阅读更多...
ROS话题通信流程自定义数据格式

ROS话题通信流程自定义数据格式

ROS话题通信流程自定义数据格式 需求流程实现步骤定义msg文件编辑配置文件编译 在 ROS 通信协议中&#xff0c;数据载体是一个较为重要组成部分&#xff0c;ROS 中通过 std_msgs 封装了一些原生的数据类型,比如:String、Int32、Int64、Char、Bool、Empty… 但是&#xff0c;这些…
阅读更多...
CST电磁仿真软件的参数类型和含义【电磁仿真入门教程】

CST电磁仿真软件的参数类型和含义【电磁仿真入门教程】

如果你是一位工程师或设计师&#xff0c;那你对电磁仿真软件CST Studio Suite一定不会感到陌生。CST软件可以帮助你模拟电磁场和电路行为&#xff0c;从而优化产品设计。本文将带你了解CST电磁仿真软件的一些关键参数&#xff0c;并解释其含义。CST电磁仿真软件的参数是指在使用…
阅读更多...
2024年文化传播与公共艺术国际会议（CCPA 2024）

2024年文化传播与公共艺术国际会议（CCPA 2024）

2024年文化传播与公共艺术国际会议&#xff08;CCPA 2024&#xff09; 2024 International Conference on Cultural Communication and Public Arts 【重要信息】 大会地点&#xff1a;桂林 大会官网&#xff1a;http://www.icccpa.com 投稿邮箱&#xff1a;icccpasub-conf.co…
阅读更多...
神经网络参数-----学习率（Learning Rate）

神经网络参数-----学习率（Learning Rate）

学习率 学习率是训练神经网络的重要超参数之一&#xff0c;它代表在每一次迭代中梯度向损失函数最优解移动的步长。它的大小决定网络学习速度的快慢。在网络训练过程中&#xff0c;模型通过样本数据给出预测值&#xff0c;计算代价函数并通过反向传播来调整参数。重复上述过程…
阅读更多...
linux系统指令查漏补缺

linux系统指令查漏补缺

目录 一.磁盘操作 二.lvm 三.top 4.nohup 一.磁盘操作 1. lsblk -f 显示磁盘和它的相关内容 2.tuen2fs -c -1 /dev/sdx 关闭某个磁盘的自检 3.修改配置&#xff0c;使文件系统不要开机自检 cat /etc/fstab 全0表示开机不自检 全1表示开机自检 同时在这个文件中可添加…
阅读更多...
欧洲杯赛况@20240623

欧洲杯赛况@20240623

估计点击标题下「蓝色微信名」可快速关注 老牌劲旅捷克队面对格鲁吉亚&#xff0c;这是两队的首次交锋&#xff0c;格鲁吉亚是很放松的状态&#xff0c;每场比赛对他们都很新鲜&#xff0c;而捷克则谨慎多&#xff0c;至今为止&#xff0c;最倒霉的球员&#xff0c;可能就是捷克…
阅读更多...
TensorFlow高阶API使用与PyTorch的安装

TensorFlow高阶API使用与PyTorch的安装

欢迎来到 Papicatch的博客 文章目录 &#x1f349;TensorFlow高阶API使用 &#x1f348;示例1&#xff1a;使用tf.keras构建模型 &#x1f34d;通过“序贯式”方法构建模型 &#x1f34d;通过“函数式”方法构建模型 &#x1f348;示例2&#xff1a;编译模型关键代码 &am…
阅读更多...
B端列表：筛选器设计的十大要点，都是干货。

B端列表：筛选器设计的十大要点，都是干货。

一、列表页的筛选器有什么作用 在B端电商平台或者企业内部管理系统中&#xff0c;列表页的筛选器是非常重要的功能之一。它能够帮助用户快速准确地找到所需的信息&#xff0c;提高工作效率&#xff0c;为企业的运营和决策提供有力支持。 首先&#xff0c;列表页的筛选器可以帮…
阅读更多...
操作系统实训复习笔记（1）

操作系统实训复习笔记（1）

目录 Linux vi/vim编辑器&#xff08;简单&#xff09; &#xff08;1&#xff09;vi/vim基本用法。 &#xff08;2&#xff09;vi/vim基础操作。 进程基础操作&#xff08;简单&#xff09; &#xff08;1&#xff09;fork()函数。 写文件系统函数&#xff08;中等&…
阅读更多...
【BES2500x系列 -- RTX5操作系统】深入探索CMSIS-RTOS RTX -- 任务管理篇 -- 线程管理 --（二）

【BES2500x系列 -- RTX5操作系统】深入探索CMSIS-RTOS RTX -- 任务管理篇 -- 线程管理 --（二）

&#x1f48c; 所属专栏&#xff1a;【BES2500x系列】 &#x1f600; 作  者&#xff1a;我是夜阑的狗&#x1f436; &#x1f680; 个人简介&#xff1a;一个正在努力学技术的CV工程师&#xff0c;专注基础和实战分享 &#xff0c;欢迎咨询&#xff01; &#x1f49…
阅读更多...
华为HCIA综合实验（结合前几期所有内容）

华为HCIA综合实验（结合前几期所有内容）

第一章 实验目的 &#xff08;1&#xff09;配置Telnet&#xff0c;要求所有网络设备支持远程管理&#xff0c;密码为admin&#xff08;2&#xff09;配置Trunk&#xff0c;交换机之间的链路均为Trunk模式&#xff08;3&#xff09;配置VLAN&#xff0c;在SW2和SW3上创建相关…
阅读更多...
QT实现人脸识别

QT实现人脸识别

QT实现人脸识别 Face.pro文件&#xff1a; QT core guigreaterThan(QT_MAJOR_VERSION, 4): QT widgetsCONFIG c11# The following define makes your compiler emit warnings if you use # any Qt feature that has been marked deprecated (the exact warnings # d…
阅读更多...
力扣141A

力扣141A

文章目录 1. 题目链接2. 题目代码3. 题目总结4. 代码分析 1. 题目链接 Amusing Joke 2. 题目代码 #include<iostream> #include<string> using namespace std;int letterOfInt[30]; int letterAtDoorOfInt[30];int main(){string guestName;string hostName;strin…
阅读更多...
Redis-在springboot环境下执行lua脚本

Redis-在springboot环境下执行lua脚本

文章目录 1、什么lua2、创建SpringBoot工程3、引入相关依赖4、创建LUA脚本5、创建配置类6、创建启动类7、创建测试类 1、什么lua “Lua”的英文全称是“Lightweight Userdata Abstraction Layer”&#xff0c;意思是“轻量级用户数据抽象层”。 2、创建SpringBoot工程 3、引入相…
阅读更多...
最新文章

Copyright @ 2022~2023