【头歌】顺序栈的基本操作及应用

news2024/9/29 4:04:26

第1关：顺序栈的基本操作

任务描述

本关任务是实现顺序栈的基本操作函数，以实现判断栈是否为满、是否为空、求栈元素个数、进栈和出栈等功能。

相关知识

栈的基本概念

栈是一种特殊的线性表，其特殊性体现在元素插入和删除运算上，它的插入和删除运算仅限定在表的某一端进行，不能在表中间和另一端进行。

栈的插入操作称为进栈（或入栈），删除操作称为出栈（或退栈）。

允许进行插入和删除的一端称为栈顶，另一端称为栈底。

处于栈顶位置的数据元素称为栈顶元素。

不含任何数据元素的栈称为空栈。

栈的示意图：

栈的基本运算

栈的基本运算主要包括以下6种：

  1. 初始化栈InitStack(st)。建立一个空栈st。

  1. 销毁栈DestroyStack(st)。释放栈st占用的内存空间。

  1. 进栈Push(st,x)。将元素x插入栈st中，使x成为栈st的栈顶元素。

  1. 出栈Pop(st,x)。当栈st不空时，将栈顶元素赋给x，并从栈中删除当前栈顶。

  1. 取栈顶元素GetTop(st,x)。若栈st不空，取栈顶元素x并返回1；否则返回0。

  1. 判断栈空StackEmpty(st)。判断栈st是否为空栈。

栈既可以采用顺序存储，也可以采用链接存储来实现。栈的顺序存储结构称为顺序栈。

顺序栈的类型定义

下面给出了一种基于顺序存储的栈的实现方案，将栈元素存储在一片连续的空间：

#define  STACK_INIT_SIZE   100  //存储空间初始分配量 
#define  STACKINCREMENT    10   //存储空间分配增量  
typedef int SElemType; // 定义栈元素类型为整型
typedef   struct
{          
    SElemType     *base;    //栈的基址即栈底指针          
    SElemType     *top;     //栈顶指针          
   int      stacksize;       //当前分配的空间 
}SqStack; 
void input(SElemType &s);
void output(SElemType s);

编程要求

根据提示，在右侧编辑器补充代码，编写顺序栈的基本运算操作函数。

void InitStack(SqStack &S);    // 构造一个空栈S
void DestroyStack(SqStack &S); // 销毁栈S，S不再存在
void ClearStack(SqStack &S);   // 把S置为空栈
int StackEmpty(SqStack S);     // 若栈S为空栈，则返回TRUE，否则返回FALSE
int StackLength(SqStack S);    // 返回S的元素个数，即栈的长度
int GetTop(SqStack S,SElemType &e);  // 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
void Push(SqStack &S,SElemType e);    // 插入元素e为新的栈顶元素
int Pop(SqStack &S,SElemType &e);     // 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
void StackTraverse(SqStack S,void(*visit)(SElemType)); // 从栈底到栈顶依次对栈中每个元素调用函数visit()输出

测试说明

平台会对你编写的代码进行测试：

测试输入：

12

12 47 5 8 6 92 45 63 75 38 4 29

预期输出：

栈中元素依次为：12 47 5 8 6 92 45 63 75 38 4 29

弹出的栈顶元素 e=29

栈空否：0(1:空 0:否)

栈顶元素 e=4

栈的长度为11

清空栈后，栈空否：1(1:空 0:否)

销毁栈后，s.top=0 s.base=0 s.stacksize=0

输入说明 第一行输入顺序栈的数据元素的个数n； 第二行输入顺序栈的n个整数。
输出说明 第一行输出顺序栈的所有数据元素； 第二行输出出栈的数据元素； 第三行判断栈是否为空； 第四行输出当前的栈顶元素及栈的长度； 第五行清空栈后，判断栈是否为空； 第六行销毁栈后输出栈顶、栈底及栈的容量。

开始你的任务吧，祝你成功！

代码示例

#include <stdio.h>
#include<stdlib.h>
#include <iostream>
using namespace std;

 // 函数结果状态代码
 #define TRUE 1
 #define FALSE 0
 #define OK 1
 #define ERROR 0
 #define OVERFLOW -1
 
#define  STACK_INIT_SIZE   100  //存储空间初始分配量 
#define  STACKINCREMENT    10   //存储空间分配增量  
typedef int SElemType; // 定义栈元素类型为整型
/* 顺序栈类型定义 */
typedef   struct
{          
    SElemType     *base;    //栈的基址即栈底指针          
    SElemType     *top;     //栈顶指针          
   int      stacksize;       //当前分配的空间 
}SqStack; 

void input(SElemType &s);
void output(SElemType s);

void InitStack(SqStack &S);// 构造一个空栈S
void DestroyStack(SqStack &S); // 销毁栈S，S不再存在
void ClearStack(SqStack &S); // 把S置为空栈
int StackEmpty(SqStack S); // 若栈S为空栈，则返回TRUE，否则返回FALSE
int StackLength(SqStack S); // 返回S的元素个数，即栈的长度
int GetTop(SqStack S,SElemType &e);  // 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
void Push(SqStack &S,SElemType e);    // 插入元素e为新的栈顶元素
int Pop(SqStack &S,SElemType &e);   // 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
void StackTraverse(SqStack S,void(*visit)(SElemType)); // 从栈底到栈顶依次对栈中每个元素调用函数visit()


int main()
 {
   int j;
   SqStack s;
   SElemType e;
   InitStack(s);
   int i;
   cin>>i;
   for(j=0;j<i;j++)  
   {  
       input(e);  
       Push(s,e);  
   }  
   printf("栈中元素依次为：");
   StackTraverse(s,output);
   Pop(s,e);
   cout<<endl;
   printf("弹出的栈顶元素 e=%d\n",e);
   printf("栈空否：%d(1:空 0:否)\n",StackEmpty(s));
   GetTop(s,e);
   printf("栈顶元素 e=%d 栈的长度为%d\n",e,StackLength(s));
   ClearStack(s);
   printf("清空栈后，栈空否：%d(1:空 0:否)\n",StackEmpty(s));
   DestroyStack(s);
   printf("销毁栈后，s.top=%u s.base=%u s.stacksize=%d\n",s.top,s.base, s.stacksize);
 }
/*****SElemType类型元素的基本操作*****/
void input(SElemType &s)
{
    cin>>s;
}
void output(SElemType s)
{
    cout<<s<<" ";
}

/*****顺序栈的基本操作*****/
void InitStack(SqStack &S)
{ 
	// 构造一个空栈S
    /********** Begin **********/ 
    S.base=new SElemType[STACK_INIT_SIZE];
	if(!S.base) exit(OVERFLOW);
	S.top=S.base;
	S.stacksize=STACK_INIT_SIZE;
    /********** End **********/  
}

void DestroyStack(SqStack &S)
{ 
	// 销毁栈S，S不再存在
    /********** Begin **********/ 
	if(S.base)
	{
		delete S.base;
		S.base=S.top=NULL;
		S.stacksize=0;
	}
    /********** End **********/ 	
}

void ClearStack(SqStack &S)
{ 
 	// 把S置为空栈
    /********** Begin **********/ 
	if(S.base) S.top=S.base;

    /********** End **********/ 
}


int StackEmpty(SqStack S)
{
 	// 若栈S为空栈，则返回TRUE，否则返回FALSE
    /********** Begin **********/ 
	if(S.top==S.base)
		return true;
	else return false;
    /********** End **********/	
 }


int StackLength(SqStack S)
{ 
	// 返回S的元素个数，即栈的长度
    /********** Begin **********/ 
	return S.top-S.base+1;
    /********** End **********/  
}


int GetTop(SqStack S,SElemType &e)
{ 
    // 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
    /********** Begin **********/ 
	if(S.base!=S.top)
	{
		e=*S.top;
		return OK;
	}
	else return false; 
    /********** End **********/	
}


void Push(SqStack &S,SElemType e)
{     
	// 插入元素e为新的栈顶元素
    /********** Begin **********/ 
	*S.top++=e;
    /********** End **********/	
}

int Pop(SqStack &S,SElemType &e)
{   
	// 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
    /********** Begin **********/ 
	e=*--S.top;
	S.top--;
	return true;
    /********** End **********/ 	
}

void StackTraverse(SqStack S,void(*visit)(SElemType))
{ 
	// 从栈底到栈顶依次对栈中每个元素调用函数visit()
    /********** Begin **********/ 
	while(S.base!=S.top)
	{
		cout<<*S.base<<" ";
		S.base++;
	}

    /********** End **********/	
}

第2关：栈的应用-进制转换

任务描述

本关任务：利用顺序栈将一个非负的十进制整数N转换为对应的十六进制数。非负的十进制整数N从键盘输入，转换结果从屏幕输出。

相关知识

进制转换

在较复杂的数据处理过程中，通常需要保存多个临时产生的数据。 如果先产生的数据后进行处理，那么需要用栈来保存这些数据。

十进制整数转换为 N 进制整数采用“除 N 取余，逆序排列”法。

具体做法是：

  • 将 N 作为除数，用十进制整数除以 N，可以得到一个商和余数；

  • 保留余数，用商继续除以 N，又得到一个新的商和余数；

  • 仍然保留余数，用商继续除以 N，还会得到一个新的商和余数； ……

  • 如此反复进行，每次都保留余数，用商接着除以 N，直到商为 0 时为止。

将十进制数159转换成八进制数的过程如下：

上述计算过程是低位到高位顺序产生八进制数的各个数位，而打印输出，一般来说应从高位到低位进行，恰好和计算过程相反，完全可以利用栈先进后出的特性来实现。

多文件结构

通常，在一个 C++ 程序中，只包含两类文件—— .cpp 文件和 .h文件。其中，.cpp 文件被称作 C++ 源文件，里面放的都是 C++ 的源代码；而 .h文件则被称作 C++ 头文件，里面放的也是 C++ 的源代码。

C++ 语言支持"分别编译"。也就是说，一个程序所有的内容，可以分成不同的部分分别放在不同的.cpp 文件里。.cpp 文件里的东西都是相对独立的，在编译（compile）时不需要与其他文件互通，只需要在编译成目标文件后再与其他的目标文件做一次链接（link）就行了。

所谓的头文件，一般放一些重复使用的代码，例如函数定义，宏的定义等等，但头文件不用被编译。当某一个.cpp 源文件需要它们时，它们就可以通过一个宏命令 "#include" 包含进这个.cpp 文件中，从而把它们的内容合并到.cpp 文件中去。当 .cpp 文件被编译时，这些被包含进去的 .h文件的作用便发挥了。

现在把顺序栈所有基本操作函数的定义放在 sqstack.cpp 里：

/* sqstack.cpp */
void InitStack(SqStack &S)
{ 
    if(!(S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType))))
     exit(OVERFLOW); // 存储分配失败
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE; 
}
void DestroyStack(SqStack &S)
{ 
    free(S.base);
    S.base=NULL;
    S.top=NULL;
    S.stacksize=0; 
}
void ClearStack(SqStack &S)
{ 
    S.top=S.base;
}
int StackEmpty(SqStack S)
{
    if(S.top==S.base)
     return TRUE;
    else
     return FALSE;     
 }
int StackLength(SqStack S)
{ 
    return S.top-S.base;
}
int GetTop(SqStack S,SElemType &e)
{ 
    if(S.top>S.base)
   {
     e=*(S.top-1);
     return OK;
   }
   else
     return ERROR;
 }
void Push(SqStack &S,SElemType e)
{ 
    if(S.top-S.base>=S.stacksize) // 栈满，追加存储空间
    {
     S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
     if(!S.base)
       exit(OVERFLOW); // 存储分配失败
     S.top=S.base+S.stacksize;
     S.stacksize+=STACKINCREMENT;
    }
   *(S.top)++=e; 
}
int Pop(SqStack &S,SElemType &e)
{ 
    if(S.top==S.base)
     return ERROR;
    e=*--S.top;
    return OK;
}
void StackTraverse(SqStack S,void(*visit)(SElemType))
{
    while(S.top>S.base)
        visit(*S.base++);
    printf("\n");
}
/* end of sqstack.cpp */

C语言的头文件（*.h文件）也可以自己写的，以扩展名.h保存就行了。头文件的作用就是被其他的 .cpp 包含进去的。它们本身并不参与编译，但实际上，它们的内容却在多个 .cpp 文件中得到了编译。通过"定义只能有一次"的规则，我们很容易可以得出，头文件中应该只放变量和函数的声明，而不能放它们的定义。当使用#include语句将头文件引用时，相当于将头文件中所有内容，复制到#include处。为了避免因为重复引用而导致的编译错误，头文件常具有以下格式：

#ifndef   LABEL
#define   LABEL
//代码部分
#endif

其中，LABEL为一个唯一的标号，命名规则跟变量的命名规则一样，常根据它所在的头文件名来命名。

如果头文件的文件名叫做sqstack.h，那么可以这样使用：

#ifndef   __SQSTACK_H__
#define   __ SQSTACK _H__
//代码部分
#endif

意思就是，如果没有定义__SQSTACK_H__，则定义__SQSTACK_H__，并编译下面的代码部分，直到遇到#endif。这样，当重复引用时，由于__SQSTACK_H__已经被定义，则下面的代码部分就不会被编译了，这样就避免了重复定义。 我们把顺序栈所有基本操作函数的声明放在头文件 sqstack.h 中：

/* sqstack.h */
// 函数结果状态代码
#ifndef   __SQSTACK_H__
#define   __SQSTACK_H__
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define  STACK_INIT_SIZE   100  //存储空间初始分配量 
#define  STACKINCREMENT    10   //存储空间分配增量  
typedef   struct
{          
    SElemType     *base;    //栈的基址即栈底指针          
    SElemType     *top;     //栈顶指针          
   int      stacksize;       //当前分配的空间 
}SqStack; 
void InitStack(SqStack &S);
void DestroyStack(SqStack &S);
void ClearStack(SqStack &S);
int StackEmpty(SqStack S);
int StackLength(SqStack S);
int GetTop(SqStack S,SElemType &e);
void Push(SqStack &S,SElemType e);
int Pop(SqStack &S,SElemType &e);
void StackTraverse(SqStack S,void(*visit)(SElemType));
#endif
/* end of sqstack.h */

现在如果我们要调用顺序栈的基本操作函数，那么就只需要把头文件包含进来：

/* main.cpp */
#include "sqstack.h"
int main()
{
}
/* end of main.cpp */

这样，便是一个完整的程序了。需要注意的是， .h文件不用写在编译器的命令之后，但它必须要在编译器找得到的地方（比如跟 main.cpp 在一个目录下）main.cpp 和 sqstack.cpp 都可以分别通过编译，生成 main.o 和 sqstack.o，然后再把这两个目标文件进行链接，程序就可以运行了。

编程要求

根据提示，在右侧编辑器补充代码，完成将一个非负的十进制整数N转换为对应的十六进制数函数的定义，具体要求如下：

  • void conversion(unsigned n) // 对于输入的任意一个非负十进制整数，打印输出与其等值的十六进制数

要注意的是八进制的数字是：0、1、2、3、4、5、6、7。

十六进制中，用A来表示10，B表示11，C表示12，D表示13，E表示14，F表示15，因此有 0~F 共16个数字，基数为16，加法运算时逢16进1，减法运算时借1当16。例如，数字 0、1、6、9、A、D、F、419、EA32、80A3、BC00 都是有效的十六进制。注意，十六进制中的字母不区分大小写，ABCDEF 也可以写作 abcdef。

测试说明

平台会对你编写的代码进行测试：

测试输入：10 预期输出：A

测试输入：100 预期输出：64

开始你的任务吧，祝你成功！

代码示例

#include <stdio.h>
#include<stdlib.h>
#include <iostream>
using namespace std;

typedef int SElemType; // 定义栈元素类型为整型

#include "sqstack.h"  // 顺序栈的类型定义

void conversion(unsigned n)
{
    // 对于输入的任意一个非负10进制整数，打印输出与其等值的16进制数
    /********** Begin **********/
    SqStack s;
    InitStack(s);
    SElemType temp;
    SElemType hah;
    SElemType e;
    if(n<0)
    {
        temp=-n;
        hah=1;
    }
    else temp=n;
    if(temp<16)
    {
        switch(temp)
        {
            case 10:cout<<"A";break;
            case 11:cout<<"B";break;
            case 12:cout<<"C";break;
            case 13:cout<<"D";break;
            case 14:cout<<"E";break;
            case 15:cout<<"F";break;
        }

    }
    else
    {
        while(temp) {
            hah=temp%16;
            Push(s, hah);
            temp /= 16;
        }
        while(s.base!=s.top)
        {
            Pop(s,e);
            if(e>=10)
            {
                switch(e)
                {
                    case 10:cout<<"A";break;
                    case 11:cout<<"B";break;
                    case 12:cout<<"C";break;
                    case 13:cout<<"D";break;
                    case 14:cout<<"E";break;
                    case 15:cout<<"F";break;
            }
            }
            else
            {
                cout<<e;
            }
        }
    }
    /********** End **********/
}


int main()
{  
    unsigned n; // 非负整数
    scanf("%u",&n); // 输入非负十进制整数n
    conversion(n);
 }

第3关：栈的应用-回文的判断

任务描述

本关任务：若一个字符串的正序与倒序相同，则称其为回文字符串。现在输入一个字符串，使用栈判断它是否是回文字符串。

相关知识

所谓回文字符串，就是一个字符串，从左到右读和从右到左读是完全一样的，比如：“level” 、 “aaabbaaa”

如何用栈来判断字符串是否为回文字符串，有两种方案：

  1. 可先将字符串全部字符连续进栈，产生的连续出栈序列和输入序列正好相反，如果所有元素连续出栈产生的序列和原字符串从头到尾的字符依次相同，表示原字符串是一个回文串，否则，不是回文串。

  1. 还可以优化第1种方案，先将一半的字符串存进去，出栈后再与剩下的一半进行比较，完全相同则为回文字符串，否则不是回文串。

编程要求

根据提示，在右侧编辑器补充代码，完成回文字符串的判断。

测试说明

平台会对你编写的代码进行测试：

测试输入： thisistrueurtsisiht

预期输出：

thisistrueurtsisiht

YES

测试输入：

thisisnottrue

预期输出：

thisisnottrue

NO

输入格式: 在一行中给出一个不超过80个字符长度的、以回车结束的非空字符串。
输出格式: 在第1行中输出字符串。如果它是回文字符串，在第2行中输出YES，否则输出NO。

开始你的任务吧，祝你成功！

代码示例

#include<stdio.h>
#include<string.h>
#include<iostream>
using namespace std;
#include"sqstack.h"    //头文件sqstack.h为顺序栈的定义和基本操作的实现

typedef char SElemType;// 定义栈元素类型为字符型

# define MAXSIZE  80

int main()
{
	/********** Begin **********/ 
	char a[80],s[80];
    int i,len,mid,next,top;   
    cin.getline(a,80);
    puts(a);
    len=strlen(a);
    mid=len/2-1;
    top=0; 
    for(i=0;i<=mid;i++) 
    {
        s[++top]=a[i];     
    }
    if(len%2==0)
    {
        next=mid+1;
    }
    else
    {
        next=mid+2;
    }
    for(i=next;i<=len-1;i++,top--)
    {
        if(a[i] != s[top])
        {
            break;
        }
    }
    if(top==0)
        printf("YES\n");
    else
        printf("NO\n");
    return 0;
}

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

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

相关文章

Sentry SDK使用（Vue/Browser JS/Laravel）

Sentry SDK使用（Vue/Browser JS/Laravel）

本文介绍通过Vue/Browser JS/Laravel三个平台对接Sentry SDK。1.在vue中使用这是入门指引&#xff0c;为了了解更多&#xff0c;请查看完整文档。为了收集错误信息和采集性能数据&#xff0c;需要安装以下两个包&#xff1a;sentry/vue(Sentrys Vue SDK)sentry/tracing(instrum…
阅读更多...
【网络安全】Wireshark过滤数据包分析TCP三次握手

【网络安全】Wireshark过滤数据包分析TCP三次握手

利用Wireshark分析TCP三次握手和四次挥手一、安装Wireshark二、界面介绍1. 网卡类型2. 首页功能2.1 按钮界面2.2 数据包列表2.3 数据包详细信息列表3. Wireshark过滤器3.1 设置数据抓取选项3.2 显示过滤器3.3 过滤关系3.4 复合过滤表达式3.5 常见用显示过滤需求及其对应表达式3…
阅读更多...
IDaaS 如何帮助中小微企业（SMB）赢得市场先机｜身份云研究院

IDaaS 如何帮助中小微企业（SMB）赢得市场先机｜身份云研究院

数字化的本质是生产关系、生产要素的重构&#xff0c;目的是通过数字化技术释放更多生产力。数据是数字化变革中最重要的生产要素&#xff0c;而开发者则是数字世界中最重要的劳动者。对于企业来说&#xff0c;如何将数据转化成企业重要的生产资料以及如何提升开发者的效率为企…
阅读更多...
机器学习算法竞赛实战--2，问题建模

机器学习算法竞赛实战--2，问题建模

目录 一&#xff0c;赛题理解 1&#xff0c;赛题理解 2&#xff0c;数据理解&#xff1a; 3&#xff0c;评价指标&#xff08;分类和回归&#xff09; 思考练习 当参赛者拿到竞赛题目的时候&#xff0c;首先应该考虑的事情就是问题建模&#xff0c;同时完成基线模型的管道…
阅读更多...
如何备考2023年高级网络规划设计师？

如何备考2023年高级网络规划设计师？

网络规划设计师是软考高级考试科目之一&#xff0c;也是比较难的科目&#xff0c;据官方数据统计网规每年的通过率很低&#xff0c;而且每年只有下半年11月份考一次&#xff0c;如果是直接裸考&#xff0c;估计很悬哦~ 但是你参加考试获得证书的过程就是一个学习网络规划系统知…
阅读更多...
一文揭晓，我是如何在Linux中查找自如

一文揭晓，我是如何在Linux中查找自如

未来已来&#xff0c;只是不均衡地分布在当下 大家好&#xff0c;我是菜农&#xff0c;欢迎来到我的频道。 本文共 2187字&#xff0c;预计阅读 10 分钟 用过 Linux 的小伙伴都知道&#xff0c;在Linux系统中包含着大量的文件&#xff0c;绝大部分情况下&#xff0c;我们都是…
阅读更多...
react hooks 中使用 Echarts图表中遇到的问题及相关配置

react hooks 中使用 Echarts图表中遇到的问题及相关配置

前言 项目开发中&#xff0c;需要做一个报表功能&#xff0c;看了下UI图&#xff0c;初步定下使用 echarts&#xff0c;不过之前使用 echarts 都是在 Vue2 和 Vue3 框架下开发&#xff0c;第一次使用 react-hooks 开发 echarts&#xff0c;将流程及一些 相关配置 写个随笔记录…
阅读更多...
没有开发经验的程序员，怎么快速学习进入工作？

没有开发经验的程序员，怎么快速学习进入工作？

今天在群里&#xff0c;Ace老师遇到一位没有开发经验的同学&#xff0c;他的情况是这样的。 问题 Ace老师&#xff1a; 有一些伙伴&#xff0c;我现在真的没有想到太好的方法去教他&#xff0c;我跟大家讲一下他目前的情况&#xff0c;你们有经验的来和他说说这样的情况应该怎…
阅读更多...
操作系统权限提升(三)之Windows系统内核溢出漏洞提权

操作系统权限提升(三)之Windows系统内核溢出漏洞提权

系列文章 操作系统权限提升(一)之操作系统权限介绍 操作系统权限提升(二)之常见提权的环境介绍 注&#xff1a;阅读本编文章前&#xff0c;请先阅读系列文章&#xff0c;以免造成看不懂的情况&#xff01;&#xff01;&#xff01; Windows系统内核溢出漏洞提权介绍 溢出提…
阅读更多...
五、环境的搭建

五、环境的搭建

1、配置用户信息 以下操作是用终端模拟器Cmder&#xff0c;这个工具比较便捷&#xff0c;比如需要粘贴&#xff0c;点击一下鼠标右键就粘贴了。如果不想下载这个工具&#xff0c;也可以在终端操作(打开终端快捷键&#xff1a;Win R&#xff0c;输入cmd)。 (1)查看git 打开C…
阅读更多...
Recast-Detour看这里就够了！

Recast-Detour看这里就够了！

目录一、 Recast生成(一) 概述1&#xff0e; 简介(二) 生成过程1&#xff0e; 体素化2&#xff0e; 区域3&#xff0e; 轮廓4&#xff0e; 生成凸多边形5&#xff0e; 详细三角形(三) 配置1&#xff0e; 可配置参数2&#xff0e; 数据结构(四) 项目应用1&#xff0e; CS体系方案…
阅读更多...
2023最新前端面试题3（持续更新）

2023最新前端面试题3（持续更新）

46、HTML语义化 HTML 语义化就是让页面内容结构化&#xff0c;它有如下优点 1、易于用户阅读&#xff0c;样式丢失的时候能让页面呈现清晰的结构。 2、有利于 SEO&#xff0c;搜索引警根据标签来确定上下文和各个关键字的权重。 3、方便其他设备解析&#xff0c;如盲人阅读器根…
阅读更多...
【Pytorch项目实战】之迁移学习：特征提取、微调、特征提取+微调、雾霾清除

【Pytorch项目实战】之迁移学习：特征提取、微调、特征提取+微调、雾霾清除

文章目录迁移学习&#xff08;Transfer Learning&#xff09;方法一&#xff1a;特征提取&#xff08;Feature Extraction&#xff09;方法二&#xff1a;微调&#xff08;Fine Tuning&#xff09;&#xff08;一&#xff09;实战&#xff1a;基于特征提取的迁移学习&#xff0…
阅读更多...
2023第三方应用苹果电脑磁盘读写工具Tuxera NTFS

2023第三方应用苹果电脑磁盘读写工具Tuxera NTFS

今天&#xff0c;小编要来分享的是Mac下一款实用的NTFS读写软件——Tuxera NTFS&#xff0c;我们都知道OS X默认是不支持NTFS格式写入的&#xff0c;对于很多使用U盘或移动硬盘写操作的朋友来说非常的不便。而Tuxera NTFS很好的解决了这个问题。小子这次带来的是2023版本。 Tu…
阅读更多...
kali入侵电脑

kali入侵电脑

kali入侵电脑 注意&#xff1a;本文仅用于教学目的 1 kali制作exe控制电脑&#xff08;msfvenom&#xff09; kali是黑客常用的系统&#xff0c;里面集成了很多的攻击软件&#xff0c;这里我给大家演示一种使用kali制作.exe文件来控制自己电脑的方式。 msfvenom a Metasploit s…
阅读更多...
Vue2 和Vue 3的区别

Vue2 和Vue 3的区别

Vue 2 和 Vue 3的区别 1.双向数据绑定原理不同 Vue2 的双向数据绑定是利用ES5的一个APIObject.definePropert() 对数据进行劫持&#xff0c;结合发布订阅模式的方式来实现的。 Vue3 中使用ES6的Proxy API对数据代理。 Vue3 使用数据代理的优势有以下几点&#xff1a;1&#x…
阅读更多...
深圳MES系统如何助力注塑企业实现数字化发展

深圳MES系统如何助力注塑企业实现数字化发展

家用电器、电子产品、日用品、医疗保健、汽车零部件、新能源以及建筑、玩具等行业对注塑制品需求量日益增长。注塑企业提供的各式各样注塑产品已深入到经济生活的各个领域&#xff0c;为国家经济的各个部门包括轻工业和重工业提供关键的支持。 现状 现在注塑企业的注塑机工作…
阅读更多...
RTP协议基本分析（RTSP、WebRTC使用）

RTP协议基本分析（RTSP、WebRTC使用）

1、介绍 实时流传输协议&#xff08;RTSP&#xff1a;Real Time Streaming Protocol&#xff09;是一种网络传输协议&#xff0c;旨在发送低延迟流。 该协议由RealNetworks&#xff0c;Netscape和哥伦比亚大学的专家在1996年开发。它定义了应如何打包流中的数 据以进行传输。 …
阅读更多...
【GD32F427开发板试用】INA226完成电流电压采集

【GD32F427开发板试用】INA226完成电流电压采集

本篇文章来自极术社区与兆易创新组织的GD32F427开发板评测活动&#xff0c;更多开发板试用活动请关注极术社区网站。作者&#xff1a;จุ๊บ冰语 前言 本次有幸参与并通过了极术社区组织的【GD32F427开发板试用】活动&#xff0c;让我对国产兆易创新的GD32处理器有了更深刻的…
阅读更多...
Scala系列之：函数式编程

Scala系列之：函数式编程

Scala系列之&#xff1a;函数式编程一、面向对象编程和函数式编程二、函数基本语法三、函数和方法的区别四、函数定义五、函数参数六、函数至简原则七、匿名函数一、面向对象编程和函数式编程 面向对象编程&#xff1a; 解决问题&#xff0c;分解对象&#xff0c;行为&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023