栈和队列的基础知识，C语言实现及经典OJ题

news2025/5/26 6:04:01

基础知识 

一.栈

1.栈的概念

定义：堆栈又名栈（stack），它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。

压栈：向一个栈插入新元素，又称作进栈、入栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；

出栈：从一个栈删除元素又称作退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

特点：先入后出，后入先出。

2.栈的实现

//利用动态数组实现栈
typedef char STDataType;
typedef struct Stack
{
	STDataType* arr;//用数组来实现栈
	int top;
	int capacity;
}ST;
// 初始化和销毁
void STInit(ST* pst)
{
	assert(pst);

	pst->arr = NULL;
	pst->capacity = 0;
	pst->top = 0;//top指向栈顶元素的下一位，数组下标从0开始
	//top实际指向的是下标，且top == 数据个数
}
void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->arr);
	pst->arr = NULL;
	pst->capacity = 0;
	pst->top = 0;
}

// 入栈  出栈
void STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->capacity == pst->top)//扩容
	{
		int newcapacity = pst->capacity == 0 ? 4 : 2 * pst->capacity;
		STDataType* tmp = (STDataType*)realloc(pst->arr, newcapacity*sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc");
			return;
		}
		pst->arr = tmp;
		pst->capacity = newcapacity;
	}
	pst->arr[pst->top++] = x;
}
void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);//栈的数据个数大于0
	pst->top--;
}

// 取栈顶数据
STDataType STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);//栈的数据个数大于0
	return pst->arr[(pst->top - 1)];
}

// 判空
bool STEmpty(ST* pst)
{
	assert(pst);
	return (pst->top == 0);
}
// 获取数据个数
int STSize(ST* pst)
{
	assert(pst);
	return pst->top ;
}

二.队列 

1.队列的概念

定义：队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。

队尾：进行插入操作端称为队尾

队头：进行删除操作的端称为队头。

特点：先进先出（FIFO—first in first out）

分类：顺序队列和循环队列

顺序队列： 

2.顺序队列的实现

//队列的基本接口

//用单链表实现队列
typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType val;
}QNode;

typedef struct Queue
{
	QNode* phead;//队列头节点指针
	QNode* ptail;//队列尾节点指针
	int size;//数据个数
}Queue;
//初始化  销毁
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* pcur = pq->phead;
	while (pcur)
	{
		QNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

// 队尾插入
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->next = NULL;
	newnode->val = x;
	//队列为空
	if (pq->ptail == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}
// 队头删除
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size > 0);

	//一个节点
	if (pq->phead == pq->ptail)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else//多个节点
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}

	pq->size--;
}

// 取队头和队尾的数据
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead);
	return pq->phead->val;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);
	return pq->ptail->val;
}

//队列数据个数
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}
//判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return (pq->size == 0);
}

3.循环队列的概念：

 定义：在实际使用队列时，为了使队列空间能重复使用，往往对队列的使用方法稍加改进：无论插入或删除，一旦tail(尾）指针增1或head（头）指针增1 时超出了所分配的队列空间，就让它指向这片连续空间的起始位置。这实际上是把队列空间想象成一个环形空间，环形空间中的存储单元循环使用，用这种方法管理的队列也就称为循环队列。除了一些简单应用之外，真正实用的队列是循环队列。

空和满的判别条件：在循环队列中，当队列为空时，有head = tail，而当所有队列空间全占满时，也有head = tail。为了区别这两种情况，规定循环队列最多只能有MaxSize-1个队列元素，当循环队列中只剩下一个空存储单元时，队列就已经满了。因此，队列判空的条件是head = tail，而队列判满的条件是head=（tail+1）%MaxSize

题目一.有效的括号（括号匹配问题）

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。
  3. 每个右括号都有一个对应的相同类型的左括号。

  4. 示例 1：

    输入：s = "()"
输出：true

    示例 2：

    输入：s = "()[]{}"
输出：true

    示例 3：

    输入：s = "(]"
输出：false

解题方法：

分析：

从字符串s的右边开始看，若左右括号不匹配或者左括号在前，则字符串无效，若匹配，则二者可以消掉，继续重复上述步骤。

左右括号数量一致

核心思想：

后进先出

工具：

栈

思路：（从s的左边开始依次，一个一个读取）

1. 左括号入栈

2.右括号与栈顶的左括号尝试匹配

代码（力扣中的部分代码）（由于栈和队列的接口代码在上文中已经写明，题目代码中就不再赘述）

//题目主代码逻辑
bool isValid(char* s) 
{
    //左括号入栈，右括号出栈
    ST st;
    STInit(&st);
    while(*s)
    {
        //左括号入栈
        if(*s == '('||*s == '['||*s == '{')
        {
            STPush(&st,*s);
        }
        else//右括号与栈顶左括号尝试匹配
        {
            //如果栈为空，且s中的是右括号，则直接返回false
            if(STEmpty(&st))
            {
                STDestroy(&st);
                return false;
            }
            char top = STTop(&st);
            //不匹配
            if(top=='('&&(*s)!=')'||
               top=='['&&(*s)!=']'||
               top=='{'&&(*s)!='}')
            {
                STDestroy(&st);//销毁
                return false;
            }
            //匹配，栈顶的左括号出栈
            STPop(&st);
        }
        s++;
    }
    //如果栈为空，说明左括号和右括号数量匹配
    //反之，数量不匹配
    bool ret = STEmpty(&st);

    STDestroy(&st);
    return ret;

}

题目二.用队列实现栈 

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

  • void push(int x) 将元素 x 压入栈顶。
  • int pop() 移除并返回栈顶元素。
  • int top() 返回栈顶元素。
  • boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

 分析：

压栈：将数据依次插入第一个队列

出栈：将尾数据之前的所有数据导入到第二个队列中（队列之间导入数据可以保证数据的顺序不变），留下的尾数据就是要出栈的栈顶元素

判空：如果两个队列都为空则栈为空

要点：

1.一个队列始终往不为空，用于进行压栈操作

2.另一个队列在每一次操作之后，一直保持为空，用于导入数据，实现出栈

 解题代码

//题目代码主逻辑

typedef struct 
{
    Queue que1;
    Queue que2;   
} MyStack;


MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&pst->que1);
    QueueInit(&pst->que2);
    return pst;
}

void myStackPush(MyStack* obj, int x) 
{
    //往非空队列插入数据
   if(!QueueEmpty(&obj->que1))
    {
        QueuePush(&obj->que1,x);
    }
    else
    {
        QueuePush(&obj->que2,x);
    }

}

int myStackPop(MyStack* obj) 
{
    //判断哪个队列为空
    //假设法
    Queue* empty = &obj->que1;
    Queue* noempty = &obj->que2;
    if(!QueueEmpty(&obj->que1))
    {
        empty = &obj->que2;
        noempty = &obj->que1;
    }
    //非空队列的前size-1个数据导到空队列中
    while(QueueSize(noempty) > 1)
    {
        QueuePush(empty,QueueFront(noempty));
        QueuePop(noempty);
    }

    int top = QueueFront(noempty);
    QueuePop(noempty);
    return top;
}

int myStackTop(MyStack* obj) 
{
    if(!QueueEmpty(&obj->que1))
    {
        return QueueBack(&obj->que1);
    }
    else
    {
        return QueueBack(&obj->que2);
    }
}

bool myStackEmpty(MyStack* obj) 
{
    return (QueueEmpty(&obj->que1))&&(QueueEmpty(&obj->que2));    
}

void myStackFree(MyStack* obj) 
{
    //先释放每个队列，在释放栈
    QueueDestroy(&obj->que1);
    QueueDestroy(&obj->que2);
    free(obj);
    obj = NULL;
    
}

题目三.用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾
  • int pop() 从队列的开头移除并返回元素
  • int peek() 返回队列开头的元素
  • boolean empty() 如果队列为空，返回 true ；否则，返回 false

 分析：

和前面用队列实现栈大致相同，一个栈始终不为空，用于插入数据，另一个栈在每一次操作之后，一直保持为空，用于数据的转移，实现出队列的操作

不同的是，每一次Pop操作要进行两次数据的转移

typedef struct 
{
    ST st1;
    ST st2;
} MyQueue;


MyQueue* myQueueCreate() 
{
    MyQueue* pq = (MyQueue*)malloc(sizeof(MyQueue));
    STInit(&pq->st1);
    STInit(&pq->st2);
    return pq;
}

void myQueuePush(MyQueue* obj, int x) 
{
    //往非空栈中存数据
   if(!STEmpty(&obj->st1))
    {
        STPush(&obj->st1,x);
    }
    else
    {
        STPush(&obj->st2,x);
    }


}

int myQueuePop(MyQueue* obj) 
{
    //把非空栈中后size-1个数据挪到空栈中
    ST* empty = &obj->st1;
    ST* noempty = &obj->st2;
    if(STEmpty(&obj->st2))
    {
        ST* empty = &obj->st2;
        ST* noempty = &obj->st1;
    }
    while(noempty->top>1)
    {
        STPush(empty,STTop(noempty));
        STPop(noempty);
    }
    int top = STTop(noempty);    
    STPop(noempty);
    //再把数据导回去
    while(empty->top)
    {
        STPush(noempty,STTop(empty));
        STPop(empty);
    }
    return top;
}

int myQueuePeek(MyQueue* obj) 
{
    if(!STEmpty(&obj->st1))
    {
        return obj->st1.arr[0];
    }
    else
    {
        return obj->st2.arr[0];
    }   
}

bool myQueueEmpty(MyQueue* obj) 
{
    return (STEmpty(&obj->st1)&&STEmpty(&obj->st2));
}

void myQueueFree(MyQueue* obj) 
{
    STDestroy(&obj->st1);
    STDestroy(&obj->st2);
    free(obj);
    obj = NULL;    
}

题目四.设计循环队列

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

  • MyCircularQueue(k): 构造器，设置队列长度为 k 。
  • Front: 从队首获取元素。如果队列为空，返回 -1 。
  • Rear: 获取队尾元素。如果队列为空，返回 -1 。
  • enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
  • deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
  • isEmpty(): 检查循环队列是否为空。
  • isFull(): 检查循环队列是否已满。
typedef struct 
{
    int* arr;//动态数据实现循环队列
    int head;//指向队头
    int tail;//指向队尾数据的下一个
    int k;//k表示最多可存数据的个数,即队列长度,等于 MaxSize - 1   
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* pq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));  
    //多开一个空间解决空和满冲突的问题
    pq->arr = (int*)malloc(sizeof(int)*(k+1));
    pq->head = pq->tail = 0;
    pq->k = k;
    return pq;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    return obj->head == obj->tail;//head == tail    
}

bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    return (obj->tail+1)%(obj->k+1) == obj->head;//head=（tail+1）%MaxSize    
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if(myCircularQueueIsFull(obj))
    {
        return false;
    } 
    else
    {
        obj->arr[obj->tail++] = value; 
    }   
    //若tail超出了所分配的队列空间，即走到了数组下标为k+1的位置，则要回到起点
    //可以让tail%(k+1),若tail<k+1,则不变,若等于,则tail刚好为0
    obj->tail %= obj->k+1;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->head++;
        obj->head %= obj->k+1;
        return true;
    }
}

int myCircularQueueFront(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->arr[obj->head]; 
    }
   
}

int myCircularQueueRear(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    } 
    else
    {
        //情况一.tail位于起点，此时队尾在下标为k的地方
        //情况二.tail不在起点，队尾==tail-1
        //写法一.
        return obj->tail == 0?obj->arr[obj->k]:obj->arr[obj->tail-1];
        //写法二.
        //return obj->arr[(obj->tail - 1 + obj->k + 1)%(obj->k + 1)];
        //假设k == 4
        //若 tail == 0,则 (0-1+5)%5 == 4,恰好 == k
        //若 tail != 0,则 (k+1)%(k+1) == 0,二者相互抵消
    }   
    
}

void myCircularQueueFree(MyCircularQueue* obj) 
{
    free(obj->arr);
    obj->arr = NULL;
    obj->head = obj->tail = 0 ;  
    free(obj);
    obj = NULL;  
}

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

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

相关文章

爆款小红书免费流量体系课程(两周变现)，小红书电商教程

爆款小红书免费流量体系课程(两周变现)，小红书电商教程

课程下载&#xff1a;小红书电商教程-课程网盘链接提取码下载.txt资源-CSDN文库 更多资源下载&#xff1a;关注我。 课程内容&#xff1a; 10-爆款标题(三段式取标题).mp3 11-爆款封面怎么作图.mp3 12-爆款内容的模板(三段式模板).mp3 13-小红书流量推荐背后的秘密(四大流…
阅读更多...
【深度学习】探秘PSD:合成到真实去雾框架的实例解析

【深度学习】探秘PSD:合成到真实去雾框架的实例解析

揭秘PSD&#xff1a;合成到真实去雾框架的革新 一、PSD框架的提出背景二、PSD框架的原理与网络结构三、PSD框架的实现与代码示例四、结论与展望 在图像处理领域&#xff0c;去雾技术一直是一个备受关注的研究热点。然而&#xff0c;传统的去雾方法在面对真实世界的模糊图像时&a…
阅读更多...
UDP和TCP协议比较，TOE技术

UDP和TCP协议比较，TOE技术

如今在某些方面TCP超越UDP的主要原因如下 在硬件层面的TOE(TCP Offload Engine)功能&#xff0c;将越来越多的TCP功能卸载到网卡上。它极大地提升了TCP的性能&#xff0c;使其在高吞吐量场景下的表现更为出色。近年TCP的拥塞控制算法实现了显著进步。这些新算法显著提高了TCP在…
阅读更多...
设计模式3——简单工厂模式

设计模式3——简单工厂模式

简单工厂模式 简单工厂模式是工厂方法模式的衍生&#xff0c;实现起来较容易&#xff0c;也是一种创建型模式。 目录 一、简短概述 二、优缺点 三、使用过程 四、举例 一、简短概述 当有一堆相似的对象需要被创建时&#xff0c;可以使用一个简单工厂去管理如何创建它们&…
阅读更多...
到底考不考CISP？纠结的看过来

到底考不考CISP？纠结的看过来

专业认证如CISP&#xff08;注册信息安全专业人员&#xff09;成为了衡量专业水平的重要标准。 CISP的含金量懂的都懂&#xff0c;然而&#xff0c;是否要投入时间、精力和金钱去追求这样一个认证&#xff0c;对于许多人来说&#xff0c;依然是一个值得深思的问题。 那么到底…
阅读更多...
Spirng-IOC零碎知识点

Spirng-IOC零碎知识点

Spirng IOC 依赖注入 根据名称注入 <?xml version"1.0" encoding"UTF-8"?> <beansxmlns"http://www.springframework.org/schema/beans"xmlns:xsi"http://www.w3.org/2001/XMLSchema-instance"xmlns:util"http://w…
阅读更多...
鸿蒙ArkUI开发：常用布局【弹性布局方向图】

鸿蒙ArkUI开发：常用布局【弹性布局方向图】

弹性布局方向图 Flex({ direction: FlexDirection.Row }) FlexDirection.Row&#xff08;默认值&#xff09;&#xff1a;主轴为水平方向&#xff0c;子组件从起始端沿着水平方向开始排布FlexDirection.RowReverse&#xff1a;主轴为水平方向&#xff0c;子组件从终点端沿着F…
阅读更多...
Hystrix服务熔断

Hystrix服务熔断

服务熔断 熔断机制是应对雪崩效应的一种微服务链路保护机制。当某个微服务不可用或者响应时间太长时&#xff0c; 会进行服务降级&#xff0c;进而熔断该节点微服务的调用&#xff0c;快速返回“错误”的响应信息。当检测到该节点微 服务调用响应正常后恢复调用链路。 在Spri…
阅读更多...
NCL绘制WRF domain区域并添加气象站点

NCL绘制WRF domain区域并添加气象站点

读取文件 根据官网例子Using gsn_csm_contour_map to plot WRF-ARW data绘制&#xff1a; ; It shows how to use gsn_csm_xxxx scripts to do the plotting. ; ; You can use the map projection settings on the WRF file, or you ; can use your own map projection. See …
阅读更多...
在excel的内置瀑布图模板中，能在数据标签里同时显示数值和百分比吗？

在excel的内置瀑布图模板中，能在数据标签里同时显示数值和百分比吗？

瀑布图是由麦肯锡顾问公司所创的图表类型&#xff0c;因为形似瀑布流水而称之为瀑布图( Waterfall Plot)。这种图表常用于表达数个特定数值之间的数量增减变化关系。 在Excel中&#xff0c;瀑布图是可以通过簇状柱形图来完成创建。从excel2016版起&#xff0c;excel添加了内置…
阅读更多...
【UE5 C++】基础学习笔记——01 UObject的创建与使用

【UE5 C++】基础学习笔记——01 UObject的创建与使用

目录 步骤 一、创建UObject 二、创建基于UObject的蓝图类 三、在UObject中使用变量和函数 步骤 一、创建UObject 在内容浏览器中新建一个C类 父类选择“Object” 类的类型设置为公有&#xff0c;这里就命名为“MyObject”&#xff0c;点击“创建类”来创建头文件和源文…
阅读更多...
【网络基础】TCP协议2

【网络基础】TCP协议2

TCP建立连接 什么是TCP连接 用于保证可靠性和流量控制维护的某些状态信息&#xff0c;这些信息的组合&#xff0c;包括 Socket、序列号和窗口大小称为连接。 Socket&#xff1a;由 IP 地址和端口号组成 序列号&#xff1a;用来解决乱序问题等 窗口大小&#xff1a;用来做流量…
阅读更多...
Web 安全漏洞之文件上传

Web 安全漏洞之文件上传

目录 文件上传漏洞及危害 文件名 HTML 和 SVG 软链 服务器磁盘 防御方法 网络安全学习路线 &#xff08;2024最新整理&#xff09; 学习资料的推荐 1.视频教程 2.SRC技术文档&PDF书籍 3.大厂面试题 特别声明&#xff1a; 文件上传漏洞及危害 文件上传漏洞…
阅读更多...
基于SpringBoot + Vue的兼职网站管理系统设计与实现+毕业论文+答辩PPT

基于SpringBoot + Vue的兼职网站管理系统设计与实现+毕业论文+答辩PPT

系统介绍 本系统包含管理员、用户、企业三个角色。 管理员角色&#xff1a;前台首页、个人中心、用户管理、企业管理、兼职信息管理、职位申请管理、留言板管理、系统管理。 用户角色&#xff1a;前台首页、个人中心、职位申请管理。 企业角色&#xff1a;前台首页、个人中心、…
阅读更多...
【异常处理】（中北大学-程序设计基础（2））

【异常处理】（中北大学-程序设计基础（2））

目录 题目 源码 结果示例 题目 求一元二次方程式ax^2bxc0的实根&#xff0c;如果方程没有实根&#xff0c;则输入有关警告信息。要求&#xff1a;建立一元二次方程类&#xff0c;利用异常技术处理。 源码 #include <iostream> #include <cmath>using namespa…
阅读更多...
JVM的垃圾回收算法有哪些？从可达性分析算法开始，深入解读三大核心垃圾回收算法

JVM的垃圾回收算法有哪些？从可达性分析算法开始，深入解读三大核心垃圾回收算法

导航&#xff1a; 【Java笔记踩坑汇总】Java基础JavaWebSSMSpringBootSpringCloud瑞吉外卖/黑马旅游/谷粒商城/学成在线设计模式面试题汇总性能调优/架构设计源码-CSDN博客 目录 一、概念准备 1.1 GC Roots 1.2 可达性分析算法 1.3 非可达对象被回收过程中的两次标记 1.4…
阅读更多...
【数据结构与算法 刷题系列】环形链表的约瑟夫问题

【数据结构与算法 刷题系列】环形链表的约瑟夫问题

&#x1f493; 博客主页&#xff1a;倔强的石头的CSDN主页 &#x1f4dd;Gitee主页&#xff1a;倔强的石头的gitee主页 ⏩ 文章专栏&#xff1a;数据结构与算法刷题系列&#xff08;C语言&#xff09; 目录 一、问题描述 二、解题思路详解 解题思路 解题步骤 三、C语言代码…
阅读更多...
文件流-ASCII文件（中北大学-程序设计基础（2））

文件流-ASCII文件（中北大学-程序设计基础（2））

目录 题目 源码 结果示例 题目 编写程序实现以下功能&#xff1a;【要求处理ASCII文件】 &#xff08;1&#xff09;按职工号由小到大的顺序将5个员工的数据&#xff08;包括号码、姓名、年龄和工资&#xff09;输出到磁盘文件中保存&#xff1b; &#xff08;2&#xff…
阅读更多...
服务器3389端口，服务器3389端口风险提示的应对措施

服务器3389端口，服务器3389端口风险提示的应对措施

3389端口是Windows操作系统中远程桌面协议&#xff08;RDP&#xff09;的默认端口。一旦该端口被恶意攻击者利用&#xff0c;可能会导致未经授权的远程访问和数据泄露等严重安全问题。 针对此风险&#xff0c;强烈建议您采取以下措施&#xff1a; 1. 修改默认端口&#xff1a;…
阅读更多...
八、e2studio VS STM32CubeIDE之内存使用情况窗口

八、e2studio VS STM32CubeIDE之内存使用情况窗口

目录 一、概述/目的 二、STM32CubeIDE Build Analyzer 三、e2studio Memory Usage 八、e2studio VS STM32CubeIDE之内存使用情况窗口 一、概述/目的 1、嵌入开发最大特点之一就是资源受限&#xff0c;关注芯片资源使用详情是优秀工程师的技能之一 2、Keil和IAR都不支持内存…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023