数据结构之栈、队列——算法与数据结构入门笔记（四）

news2024/12/30 2:32:37

CSDNlogoPost

本文是算法与数据结构的学习笔记第四篇，将持续更新，欢迎小伙伴们阅读学习 。有不懂的或错误的地方，欢迎交流

栈

栈是一种线性数据结构，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶 (Top）, 另一端称为栈底 (Bottom)。栈中的数据元素遵守后进先出 LIFO（Last In First Out）的原则，即最后进入的元素最先被访问。

压栈（push）：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈（pop）：栈的删除操作叫做出栈，出数据也在栈顶。

下面的动图可以更直观的理解栈的出入栈

在这里插入图片描述

栈的特点

  1. 后进先出（LIFO）：最后进入栈的元素最先被访问，而最先进入栈的元素最后被访问。
  2. 只允许在一端进行插入和删除操作：栈通常只允许在栈顶进行插入和删除操作，而不允许在其他位置进行操作。
  3. 栈顶指针：栈顶指针指向栈顶元素，它随着元素的插入和删除而改变。

栈的应用

  1. 函数调用：编程语言中的函数调用过程使用栈来保存函数的返回地址、参数和局部变量等信息。每当一个函数被调用，其相关信息被压入栈中；当函数执行完毕，这些信息被弹出栈，控制权回到调用函数。
  2. 表达式求值：栈在表达式求值中起到重要作用。通过将中缀表达式转换为后缀表达式，并使用栈来存储操作数和运算符，可以实现对表达式的求值。
  3. 括号匹配：栈常用于检查表达式中括号是否匹配的问题。遍历表达式时，遇到左括号就将其压入栈中，遇到右括号时与栈顶元素进行匹配，如果匹配则弹出栈顶元素，继续遍历；如果不匹配，则括号不匹配。
  4. 撤销操作：在文本编辑器或图形处理软件中，栈可用于实现撤销操作。每次执行操作时，相关信息被压入栈中，当用户需要撤销操作时，将栈顶元素弹出，回退到上一个状态。
  5. 中断处理和现场保护：中断是计算机系统中常见的事件，例如硬件故障、外部设备请求等。当系统发生中断时，当前正在执行的程序需要被暂停，转而处理中断事件。栈在中断处理中扮演着重要角色，用于保存和恢复程序的执行现场。当发生中断时，系统会自动将当前程序的执行现场（包括程序计数器、寄存器等状态信息）保存到栈中。然后，中断服务程序（Interrupt Service Routine，ISR）被执行，处理中断事件。处理完成后，系统从栈中恢复之前保存的执行现场，继续原来被中断的程序的执行。通过栈的保存和恢复操作，确保中断处理的流程正确且不会破坏原有的程序执行。

栈的基本操作

  1. 初始化栈。
  2. 压栈，往栈中添加一个元素。
  3. 出栈，从栈顶删除一个元素。
  4. 获取栈顶元素。
  5. 判断栈是否为空、是否满栈。
  6. 栈的销毁。

注意：在操作栈时，要避免“上溢”和“下溢”
上溢：指栈已满，若继续存数据，则会上溢，出现报错（栈满再存出现上溢）
下溢：指栈已空，若继续取数据，则会下溢，出现报错（栈空再取出现下溢）

C 语言

栈有两种实现方式，一种是使用数组来实现，另一种是使用链表来实现。下面是总结的用数组和链表实现的优缺点。

用数组实现的优点
1 . 数组在内存中是连续存储的，因此访问元素时速度较快。CPU高速缓存命中率会更高。
2. 下标的随机访问。尾插尾删效率不错.
3. 数组实现相对简单，不需要额外的指针来维护元素之间的关系。
数组实现的缺点
1 . 数组的大小是固定的，因此在栈空间不足时需要进行扩容操作，这可能会导致性能下降。
2 . 在删除元素时，需要移动数组中的其他元素，这也可能会导致性能下降。

用链表实现的优点
1 .链表的大小可以动态调整，因此可以更好地利用空间。
2 . 任意位置插入删除O(1) ，链表的性能较高，因为不需要移动其他元素。
链表实现的缺点
1 . CPU高速缓存命中率会更低,不是连续存储的，因此访问元素时速度较慢。
2. 不支持下标的随机访问.

用链表还是用数组结构实现，这个问题的答案取决于具体的应用场景和需求，下面我们给出了数组栈和链表栈的 C 语言实现。

数组栈

#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100

// 定义栈结构
typedef struct {
    int data[MAX_SIZE]; // 用数组存储栈的元素
    int top; // 栈顶指针
} Stack;

// 初始化栈
void init(Stack *stack) {
    stack->top = -1; // 初始化栈顶指针为-1，表示栈为空
}

// 判断栈是否为空
int isEmpty(Stack *stack) {
    return stack->top == -1;
}

// 判断栈是否已满
int isFull(Stack *stack) {
    return stack->top == MAX_SIZE - 1;
}

// 入栈操作
void push(Stack *stack, int item) {
    if (isFull(stack)) {
        printf("Stack overflow\n");
        return;
    }
    stack->top++; // 栈顶指针加1
    stack->data[stack->top] = item; // 将元素入栈
}

// 出栈操作
int pop(Stack *stack) {
    int item;
    if (isEmpty(stack)) {
        printf("Stack underflow\n");
        return -1;
    }
    item = stack->data[stack->top]; // 获取栈顶元素
    stack->top--; // 栈顶指针减1
    return item;
}

// 获取栈顶元素
int peek(Stack *stack) {
    if (isEmpty(stack)) {
        printf("Stack is empty\n");
        return -1;
    }
    return stack->data[stack->top];
}

// 销毁栈
void destroy(Stack *stack) {
    stack->top = -1; // 将栈顶指针重置为-1，表示栈为空
}

int main() {
    Stack stack;
    init(&stack);

    push(&stack, 1);
    push(&stack, 2);
    push(&stack, 3);

    printf("Top element: %d\n", peek(&stack));

    printf("Popped element: %d\n", pop(&stack));
    printf("Popped element: %d\n", pop(&stack));

    printf("Top element: %d\n", peek(&stack));

    destroy(&stack);

    return 0;
}

链表栈

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

// 定义链表节点
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 定义栈结构
typedef struct {
    Node* top; // 栈顶指针
} Stack;

// 初始化栈
void init(Stack* stack) {
    stack->top = NULL; // 初始化栈顶指针为空
}

// 判断栈是否为空
int isEmpty(Stack* stack) {
    return stack->top == NULL;
}

/* 由于链表实现的栈理论上没有大小限制，因此不存在“栈满”的情况。在入栈操作时只需要创建新节点，并将其插入到链表头部即可。
如需限制栈的大小，可以通过设置一个变量来记录当前栈中存储的元素个数，然后在入栈时进行判断，若已满则不允许再次入栈。*/

// 入栈操作
void push(Stack* stack, int item) {
    Node* newNode = (Node*)malloc(sizeof(Node)); // 创建新节点
    if (newNode == NULL) {
        printf("Memory allocation failed\n");
        return;
    }
    newNode->data = item; // 设置新节点的数据为要入栈的元素
    newNode->next = stack->top; // 将新节点插入到栈顶
    stack->top = newNode; // 更新栈顶指针
}

// 出栈操作
int pop(Stack* stack) {
    if (isEmpty(stack)) {
        printf("Stack underflow\n");
        return -1;
    }
    Node* topNode = stack->top; // 获取栈顶节点
    int item = topNode->data; // 获取栈顶元素
    stack->top = topNode->next; // 更新栈顶指针
    free(topNode); // 释放栈顶节点的内存
    return item;
}

// 获取栈顶元素
int peek(Stack* stack) {
    if (isEmpty(stack)) {
        printf("Stack is empty\n");
        return -1;
    }
    return stack->top->data;
}

// 销毁栈
void destroy(Stack* stack) {
    while (!isEmpty(stack)) {
        pop(stack);
    }
}

int main() {
    Stack stack;
    init(&stack);

    push(&stack, 1);
    push(&stack, 2);
    push(&stack, 3);

    printf("Top element: %d\n", peek(&stack));

    printf("Popped element: %d\n", pop(&stack));
    printf("Popped element: %d\n", pop(&stack));

    printf("Top element: %d\n", peek(&stack));

    destroy(&stack);

    return 0;
}

队列

队列是栈的兄弟结构，是只允许在一端进行插入元素操作，在另一端进行删除元素操作的线性数据结构。进行插入操作的一端称为队尾，进行删除操作的一端称为队头。队列中的数据元素遵守先进先出 FIFO（First In First Out）的原则，即最先进入的元素最先被访问。

请添加图片描述

队列的特点

  1. 先进先出（FIFO）：第一个插入的元素是第一个被删除的元素，因此表现为先进先出的顺序。
  2. 元素只能从队尾插入（入队）和从队头删除（出队）。

队列的应用

  1. 消息传递:在消息传递模型中，消息被发送到队列中等待接收方进行处理。发送方可以通过入队操作向队列发送消息，而接收方则通过出队操作从队列中获取消息。
  2. 缓存区管理：在网络通信、磁盘I/O等场景中，队列被用于管理数据的缓冲区。接收到的数据被放入队列中，然后按照一定的规则从队列中取出，保证数据按照顺序传输。
  3. 任务调度：操作系统中的任务调度通常使用队列来管理待执行的任务，按照先来先服务（First-Come-First-Served，FCFS）的原则进行调度。
  4. 广度优先搜索：图的广度优先搜索算法（BFS）使用队列来保存待访问的节点。从起始节点开始，将其放入队列中，然后不断从队列中取出节点，并将其邻接节点放入队列，直到队列为空。

队列的基本操作

  1. 入队（enqueue）：将元素插入到队列的末尾。
  2. 出队（dequeue）：从队列的头部删除一个元素并返回。
  3. 获取队列头部元素的值。
  4. 获取队列中元素的个数。
  5. 判断队列是否为空、是否已满。
  6. 队列的销毁

C 语言

队列有两种实现方式，一种是使用数组来实现，另一种是使用链表来实现。下面是总结的用数组和链表实现的优缺点。

用数组实现的优点
1 . 数组在内存中是连续存储的，因此访问元素时速度较快。CPU高速缓存命中率会更高。
2 . 数组实现相对简单，不需要额外的指针来维护元素之间的关系。
数组实现的缺点
1 . 需要事先确定队列的最大长度，这可能会导致性能下降。
2 . 需要移动元素来保持队列的顺序。

用链表实现的优点
1 . 不需要事先确定队列的最大长度，可以动态扩展。
2 . 插入和删除操作只需要修改指针，不需要移动元素。
3 . 可以实现多个队列共享一个链表。
链表实现的缺点
1 . CPU高速缓存命中率会更低,不是连续存储的，因此访问元素时速度较慢。
2 .实现相对复杂。

用链表还是用数组结构实现，这个问题的答案取决于具体的应用场景和需求，下面我们给出了数组队列和链表队列的 C 语言实现。

数组队列

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

#define MAX_SIZE 100 // 队列的最大大小

// 定义队列结构体
struct queue {
    int* arr; // 数组指针
    int front; // 队首位置
    int rear; // 队尾位置
    int size; // 当前队列中存储的元素个数
};

// 初始化队列
struct queue* init() {
    struct queue* q = (struct queue*)malloc(sizeof(struct queue));
    q->arr = (int*)malloc(MAX_SIZE * sizeof(int));
    q->front = 0;
    q->rear = -1;
    q->size = 0;
    return q;
}

// 判断队列是否为空
int is_empty(struct queue* q) {
    return q->size == 0;
}

// 判断队列是否已满
int is_full(struct queue* q) {
    return q->size == MAX_SIZE;
}

// 入队
void enqueue(struct queue* q, int value) {
    if (is_full(q)) {
        printf("Queue Overflow\n");
        return;
    }
    q->rear = (q->rear + 1) % MAX_SIZE;
    q->arr[q->rear] = value;
    q->size++;
}

// 出队
int dequeue(struct queue* q) {
    if (is_empty(q)) {
        printf("Queue Underflow\n");
        return -1;
    }
    int value = q->arr[q->front];
    q->front = (q->front + 1) % MAX_SIZE;
    q->size--;
    return value;
}

// 获取队首元素
int front(struct queue* q) {
    if (is_empty(q)) {
        printf("Queue Underflow\n");
        return -1;
    }
    return q->arr[q->front];
}

// 获取队列长度
int size(struct queue* q) {
    return q->size;
}

// 销毁队列
void destroy(struct queue* q) {
    free(q->arr);
    free(q);
}

int main() {
    struct queue* q = init();
    enqueue(q, 10);
    enqueue(q, 20);
    enqueue(q, 30);
    printf("%d\n", dequeue(q)); // 输出10
    printf("%d\n", front(q)); // 输出20
    enqueue(q, 40);
    printf("%d\n", dequeue(q)); // 输出20
    printf("%d\n", dequeue(q)); // 输出30
    printf("%d\n", dequeue(q)); // 输出40
    printf("%d\n", dequeue(q)); // 输出Queue Underflow
    destroy(q); // 销毁队列
    return 0;
}

链表队列

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

// 定义队列节点结构体
struct queue_node {
    int data;
    struct queue_node* next;
};

// 定义队列结构体
struct queue {
    struct queue_node* front; // 队首指针
    struct queue_node* rear; // 队尾指针
    int size; // 当前队列中存储的元素个数
};

// 初始化队列
struct queue* init() {
    struct queue* q = (struct queue*)malloc(sizeof(struct queue));
    q->front = NULL;
    q->rear = NULL;
    q->size = 0;
    return q;
}

// 判断队列是否为空
int is_empty(struct queue* q) {
    return q->size == 0;
}

// 同链表栈，链表队列没有固定的大小限制，因此不需要判断队列是否已满

// 入队
void enqueue(struct queue* q, int value) {
    // 创建新节点
    struct queue_node* new_node = (struct queue_node*)malloc(sizeof(struct queue_node));
    new_node->data = value;
    new_node->next = NULL;

    if (is_empty(q)) {
        q->front = new_node;
        q->rear = new_node;
    } else {
        q->rear->next = new_node;
        q->rear = new_node;
    }

    q->size++;
}

// 出队
int dequeue(struct queue* q) {
    if (is_empty(q)) {
        printf("Queue Underflow\n");
        return -1;
    }

    struct queue_node* temp = q->front;
    int value = temp->data;

    if (q->front == q->rear) {
        q->front = NULL;
        q->rear = NULL;
    } else {
        q->front = q->front->next;
    }

    free(temp);
    q->size--;

    return value;
}

// 获取队首元素
int front(struct queue* q) {
    if (is_empty(q)) {
        printf("Queue Underflow\n");
        return -1;
    }
    return q->front->data;
}

// 获取队列长度
int size(struct queue* q) {
    return q->size;
}

// 销毁队列
void destroy(struct queue* q) {
    while (!is_empty(q)) {
        dequeue(q);
    }
    free(q);
}

int main() {
    struct queue* q = init();
    enqueue(q, 10);
    enqueue(q, 20);
    enqueue(q, 30);
    printf("%d\n", dequeue(q)); // 输出10
    printf("%d\n", front(q)); // 输出20
    enqueue(q, 40);
    printf("%d\n", dequeue(q)); // 输出20
    printf("%d\n", dequeue(q)); // 输出30
    printf("%d\n", dequeue(q)); // 输出40
    printf("%d\n", dequeue(q)); // 输出Queue Underflow
    destroy(q); // 销毁队列
    return 0;
}

结论

栈和队列作为常见的数据结构，在算法和程序设计中扮演着重要的角色。本文总结了栈和队列的特点、应用场景以及C语言实现。通过深入理解它们的原理和应用，可以更好地解决问题和优化算法。希望本文能够对读者对栈和队列的学习和应用提供帮助。

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

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

相关文章

虚幻5-编辑器扩展开发Editor-Slate的TabManager结构如下

虚幻5-编辑器扩展开发Editor-Slate的TabManager结构如下

目录 Editor-Slate WorkSpaceMenu(Slate相关类) Editor-Tab-界面刷新 Editor-Slate 基本上&#xff0c;地球人都知道&#xff08;我不是地球人&#xff09;虚幻引擎的Editor界面&#xff08;自定义&#xff09;通过Slate管理 Slate的入口是方法&#xff1a;&#xff1a;Co…
阅读更多...
检测到“_CRT_STDIO_ISO_WIDE_SPECIFIERS”的不匹配项

检测到“_CRT_STDIO_ISO_WIDE_SPECIFIERS”的不匹配项

libboost_thread-vc142-mt-x64-1_82.lib(thread.obj) : error LNK2038: 检测到“_CRT_STDIO_ISO_WIDE_SPECIFIERS”的不匹配项: 值“0”不匹配值“1”(AcadStr.obj 中) 1> 正在创建库 x64\Release\ArxDbg.lib 和对象 x64\Release\ArxDbg.exp : fatal error LNK1319: 检测到 …
阅读更多...
这AI二维码也太酷炫了！谷歌生成式AI学习路径；媒体的AI炒作套路报告；使用GPT-4自动化制作短视频 | ShowMeAI日报

这AI二维码也太酷炫了！谷歌生成式AI学习路径；媒体的AI炒作套路报告；使用GPT-4自动化制作短视频 | ShowMeAI日报

&#x1f440;日报&周刊合集 | &#x1f3a1;生产力工具与行业应用大全 | &#x1f9e1; 点赞关注评论拜托啦&#xff01; &#x1f916; 新鲜出炉&#xff01;2023人工智能10大分类排行榜 这是根据2023年6月德本咨询、eNet研究院和互联网周刊联调的人工智能排行榜&#xf…
阅读更多...
smardaten简直是无代码软件开发的天花板

smardaten简直是无代码软件开发的天花板

目录 前言 一、smardaten简单介绍 二、基于smardaten创建应用 1、创建一个炫酷的大屏 2、创建一个web端和移动端共存的应用 三、smardaten功能特性和优势 1、操作简单&#xff0c;快速上手 2、圆桌开发&#xff0c;效率倍升 3、图形编排&#xff0c;拖拽生效 4、低无代…
阅读更多...
ARM---驱动开发

ARM---驱动开发

目录 1.驱动大纲&#xff1a; 2.单片机开发属于嵌入式开发吗&#xff1f; 3.RAM裸机代码和驱动有什么区别&#xff1f; 4.Linux系统的组成 5.宏内核、微内核 6.驱动移植 1.驱动大纲&#xff1a; &#xff08;1&#xff09;内核模块 &#xff08;2&#xff09;字符设备驱…
阅读更多...
docker创建ubuntu 22.04

docker创建ubuntu 22.04

1、拉取镜像 sudo docker pull ubuntu:22.04 2、启动ubuntu22.04&#xff0c;这里映射物理机23端口对应docker22端口用于远程连接 sudo docker run -it -p 23:22 1f6ddc1b2547 /bin/bash 3、进入容器后配置远程&#xff1a; apt update apt upgrade apt install vim ap…
阅读更多...
springboot+vue+java在线教育课程教学辅助系统

springboot+vue+java在线教育课程教学辅助系统

本文介绍了在线教育系统的开发全过程。通过分析在线教育系统管理的不足&#xff0c;创建了一个计算机管理在线教育系统的方案。文章介绍了在线教育系统的系统分析部分&#xff0c;包括可行性分析等&#xff0c;系统设计部分主要介绍了系统功能设计和数据库设计。课程辅助教学&a…
阅读更多...
智慧PG集成开发平台pgting-cli发布了

智慧PG集成开发平台pgting-cli发布了

介绍 两周前我们发布了智能页面搭建平台 —— 智慧PG(pgting)&#xff0c;深受用户青睐&#xff0c;很多用户尝试了在线开发组件。为了方便用户定制开发组件和组件共享&#xff0c;智慧PG设计之初就考虑了组件定制开发问题&#xff0c;为此&#xff0c;我们设计和研发了智慧PG…
阅读更多...
Spring Catch

Spring Catch

一、Spring Cache整合服务 1.pom.xml <!--spring catch--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-cache</artifactId></dependency>2.application.properties #开启缓存空值&am…
阅读更多...
canvas图片旋转，图片base64编码，保存图片

canvas图片旋转，图片base64编码，保存图片

在一些业务场景中&#xff0c;常常需要前端对图片进行操作&#xff0c;这样可以将部分的性能压力转移到前端设备&#xff0c;有利于减小服务器压力&#xff0c;下面讲解前端怎么操作图片。 首先&#xff0c;对图片的操作都是依赖于canvas画布&#xff0c;这里对canvas标签不再赘…
阅读更多...
华为OD机试题【字符统计】【2023 B卷 100分】

华为OD机试题【字符统计】【2023 B卷 100分】

文章目录 &#x1f3af; 前言&#x1f3af; 题目描述&#x1f3af; 解题思路&#x1f4d9; Python代码实现&#x1f4d7; Java代码实现&#x1f4d8; C语言代码实现 &#x1f3af; 前言 &#x1f3c6; 《华为机试真题》专栏含2023年牛客网面经、华为面经试题、华为OD机试真题最…
阅读更多...
LVGL学习(3)：页面切换原理和页面管理实现

LVGL学习(3)：页面切换原理和页面管理实现

在LVGL中&#xff0c;大多情况下是有多个页面的&#xff0c;一般来说页面的切换有两种情况&#xff1a; 删除当前的页面&#xff0c;创建新页面加载保留当前的页面&#xff0c;创建新页面加载 我们来分析一下这两种情况&#xff0c;比如页面1有一个列表框&#xff0c;有三个选…
阅读更多...
VESC操作入门（三）——PPM输入控制和ADC输入控制

VESC操作入门（三）——PPM输入控制和ADC输入控制

目录 一、PPM输入控制1.1、硬件准备1.2、PPM信号1.3、校准电机1.4、输入设置 二、ADC输入控制2.1、硬件准备2.2、更改固件2.3、电压信号2.4、校准电机2.5、输入设置 三、电动车转把控制3.1、转把说明3.2、转把测试 四、ADC的其它模式4.1、Current No Reverse Brake ADC24.2、Cu…
阅读更多...
Windows 安装Redis教程（图文详解）_下载使用redis_Redis可视化_配置Redis环境变量

Windows 安装Redis教程（图文详解）_下载使用redis_Redis可视化_配置Redis环境变量

下载、安装和配置 给出自己的百度网盘链接&#xff1a; 链接&#xff1a;https://pan.baidu.com/s/14uO7jSm0DuoBWBaFO-obTw 提取码&#xff1a;1234 1. Redis下载 由于 Redis 官网没有提供 windows 版本的&#xff0c;只能去 github 上下载。 1、下载地址&#xff1a;github链…
阅读更多...
【C/C++】基础知识之bool布尔类型

【C/C++】基础知识之bool布尔类型

创作不易&#xff0c;本篇文章如果帮助到了你&#xff0c;还请点赞 关注支持一下♡>&#x16966;<)!! 主页专栏有更多知识&#xff0c;如有疑问欢迎大家指正讨论&#xff0c;共同进步&#xff01; &#x1f525;c系列专栏&#xff1a;C/C零基础到精通 &#x1f525; 给大…
阅读更多...
Java 服务端生成动态 Word 文档下载

Java 服务端生成动态 Word 文档下载

需求&#xff1a;某些合同&#xff0c;被制作成模板&#xff0c;以 Word 格式保存&#xff0c;输入相关的内容参数最终生成 Word 文档下载。这是企业级应用中很常见的需求。 解决方案&#xff1a;无非是模板技术&#xff0c;界定不变和变的内容&#xff0c;预留插值的标记&…
阅读更多...
创新书荐｜《影响力经济》如何在社交媒体上寻求可信的影响力

创新书荐｜《影响力经济》如何在社交媒体上寻求可信的影响力

在这个越来越不可预测的经济体中&#xff0c;贫富悬殊、大规模裁员等让许多人都觉得踏上稳定的职业道路遥不可及&#xff0c;自由职业听起来是最好的选择。宾夕法尼亚大学研究人员Emily Hund在她的新书《影响力经济》很好地讲述了年轻创意人士如何将互联网从分散的网页集合转变…
阅读更多...
【目标检测——YOLO系列】YOLOv1 —《You Only Look Once: Unified, Real-Time Object Detection》

【目标检测——YOLO系列】YOLOv1 —《You Only Look Once: Unified, Real-Time Object Detection》

YOLOv1 —《You Only Look Once: Unified, Real-Time Object Detection》 论文地址&#xff1a;1506.02640] You Only Look Once: Unified, Real-Time Object Detection (arxiv.org) 代码地址&#xff1a;pjreddie/darknet: Convolutional Neural Networks (github.com) 1、Y…
阅读更多...
log4j 2自动配置的优先级顺序

log4j 2自动配置的优先级顺序

log4j 2按照下面优先级由高到低的顺序查找使用日志的配置&#xff1a; 1、系统变量log4j2.configurationFile中指明的配置文件&#xff1b; 2、类路径上的log4j2-test.properties配置文件&#xff1b; 3、类路径上的log4j2-test.yaml 或者 log4j2-test.yml配置文件&#xff1b;…
阅读更多...
【C++】C++中的I/O类总结——上篇

【C++】C++中的I/O类总结——上篇

title: 【C】C-中的I/O类总结 tags: C description: ’ ’ categories: C date: 2023-06-05 00:36:59 引入 #include <iostream>int main(){std::cout<<"Hello World!"<<std::endl;}我们在学习C时&#xff0c;往往都是从上面这段程序开始的 也就…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023