【数据结构】队列知识点总结--定义；基本操作；队列的顺序实现；链式存储；双端队列；循环队列

news2024/10/6 0:27:12

 欢迎各位看官^_^

目录

1.队列的定义

2.队列的基本操作

2.1初始化队列

2.2判断队列是否为空

2.3判断队列是否已满

2.4入队

2.5出队

2.6完整代码 

3.队列的顺序实现

4.队列的链式存储

5.双端队列

6.循环队列

1.队列的定义

        队列（Queue）是一种先进先出（First In First Out，FIFO）的线性数据结构，它只允许在队尾添加元素，在队头删除元素，不支持随机访问。队列常用的操作有入队（enqueue）、出队（dequeue）、队列长度（size）、队列是否为空（empty）等。队列可以用来实现很多算法，如广度优先搜索算法（BFS）和消息传递等。

2.队列的基本操作

2.1初始化队列

        可以使用数组或链表来实现队列。对于数组，我们可以定义一个数组和两个指针（front和rear）来表示队列。对于链表，我们可以创建一个链表，并定义头节点指针和尾节点指针。队列是一种线性数据结构，可以用数组或链表来实现。

以下是用数组实现队列的C语言代码示例：

#include <stdio.h>

#define MAX_SIZE 100

int queue[MAX_SIZE];
int front = 0, rear = -1;

void enqueue(int data) {
    if (rear == MAX_SIZE - 1) {
        printf("Queue overflow\n");
    } else {
        rear++;
        queue[rear] = data;
    }
}

int dequeue() {
    if (front > rear) {
        printf("Queue underflow\n");
        return -1;
    } else {
        int data = queue[front];
        front++;
        return data;
    }
}

int main() {
    enqueue(10);
    enqueue(20);
    enqueue(30);
    printf("%d ", dequeue());
    printf("%d ", dequeue());
    printf("%d ", dequeue());
    printf("%d ", dequeue());
    return 0;
}

        上述代码中，`queue`为数组，`front`和`rear`分别表示队列的前后指针，初始化为`0`和`-1`。`enqueue`函数用于向队列中添加元素，先判断队列是否已满，若未满则将数据存入队列尾部。`dequeue`函数用于弹出队列头部元素，先判断队列是否为空，若非空则返回队列头部元素并将`front`指针后移一位。在`main`函数中，先将元素10、20、30添加到队列中，然后依次弹出队列头部元素并输出。

2.2判断队列是否为空

如果队列为空，则front和rear指向同一个位置。

// 判断队列是否为空
int is_empty() {
    return front == rear;
}

2.3判断队列是否已满

如果队列已满，则rear指向的下一个位置就是front（因为它是循环队列）。

// 判断队列是否已满
int is_full() {
    return (rear + 1) % MAX_SIZE == front;
}

2.4入队

当队列不满时，我们将元素插入队列的rear位置，并将rear指针后移。

// 入队
void enqueue(int data) {
    if (is_full()) {
        printf("Queue is full.\n");
        return;
    }
    queue[rear] = data;
    rear = (rear + 1) % MAX_SIZE;
}

2.5出队

当队列不为空时，我们将front指向的元素从队列中删除，并将front指针后移。

// 出队
int dequeue() {
    if (is_empty()) {
        printf("Queue is empty.\n");
        return -1;
    }
    int data = queue[front];
    front = (front + 1) % MAX_SIZE;
    return data;
}

2.6完整代码 

#include <stdio.h>
#define MAX_SIZE 10      // 定义队列的最大容量为10

int queue[MAX_SIZE];     // 定义数组队列
int front = 0, rear = 0; // front指向队首，rear指向队尾的下一个位置

// 判断队列是否为空
int is_empty() {
    return front == rear;
}

// 判断队列是否已满
int is_full() {
    return (rear + 1) % MAX_SIZE == front;
}

// 入队
void enqueue(int data) {
    if (is_full()) {
        printf("Queue is full.\n");
        return;
    }
    queue[rear] = data;
    rear = (rear + 1) % MAX_SIZE;
}

// 出队
int dequeue() {
    if (is_empty()) {
        printf("Queue is empty.\n");
        return -1;
    }
    int data = queue[front];
    front = (front + 1) % MAX_SIZE;
    return data;
}

int main() {
    enqueue(1);
    enqueue(2);
    enqueue(3);
    printf("%d\n", dequeue());
    printf("%d\n", dequeue());
    enqueue(4);
    printf("%d\n", dequeue());
    printf("%d\n", dequeue());
    return 0;
}

        注意：这是一个循环队列，在计算rear的位置时需要使用取模运算。这是因为数组的最后一个位置后面没有下一个位置，我们需要将rear回到数组的开头位置。 

3.队列的顺序实现

C语言队列的顺序实现可以使用数组来实现。实现思路如下：

  1. 定义一个数组和队列头尾指针。
  2. 队列头指针指向队列的第一个元素，队列尾指针指向队列的最后一个元素。
  3. 入队操作时，先判断队列是否已满，如果已满则提示队列已满，否则将元素加入到队列尾部，并更新队列尾指针。
  4. 出队操作时，先判断队列是否为空，如果为空则提示队列为空，否则将队列头部的元素出队，并更新队列头指针。
  5. 获取队列头元素时，先判断队列是否为空，如果为空则提示队列为空，否则返回队列头的元素。

以下是C语言队列的顺序实现示例代码：

#include <stdio.h>
#define MAX_SIZE 100

// 定义队列结构体
typedef struct {
    int data[MAX_SIZE];  // 存储队列的数组
    int front;  // 队列头指针
    int rear;   // 队列尾指针
} Queue;

// 初始化队列
void initQueue(Queue *q) {
    q->front = q->rear = 0;
}

// 入队
void enqueue(Queue *q, int x) {
    if ((q->rear + 1) % MAX_SIZE == q->front) {
        printf("Queue is full.\n");
    } else {
        q->data[q->rear] = x;
        q->rear = (q->rear + 1) % MAX_SIZE;
    }
}

// 出队
void dequeue(Queue *q) {
    if (q->front == q->rear) {
        printf("Queue is empty.\n");
    } else {
        q->front = (q->front + 1) % MAX_SIZE;
    }
}

// 获取队列头元素
int front(Queue *q) {
    if (q->front == q->rear) {
        printf("Queue is empty.\n");
        return -1;
    } else {
        return q->data[q->front];
    }
}

// 判断队列是否为空
int isEmpty(Queue *q) {
    return q->front == q->rear;
}

int main() {
    Queue q;
    initQueue(&q);

    // 入队
    enqueue(&q, 1);
    enqueue(&q, 2);
    enqueue(&q, 3);

    // 获取队列头元素
    printf("Front of queue: %d\n", front(&q));

    // 出队
    dequeue(&q);

    // 获取队列头元素
    printf("Front of queue: %d\n", front(&q));

    return 0;
}

4.队列的链式存储

        队列和链表的关系：队列和链表是两种不同的数据结构，但是在实现队列时可以使用链表来表示。队列是一种先进先出（First In First Out，FIFO）的数据结构，可以理解为是一条通道，从一端（队尾）加入数据，从另一端（队头）取出数据。而链表是一种动态数据结构，由节点之间的指针连接而成。每个节点包含一个数据元素和一个指向下一个节点的指针。在使用链表实现队列时，可以将链表的头作为队列的队头，将链表的尾作为队列的队尾，使用链表的头插法或尾插法对队列进行入队操作，使用链表的尾删除或头删除对队列进行出队操作。因此，可以说队列和链表有一定的关系，但二者仍然是不同的数据结构。 

        队列的链式存储是使用链表来实现队列的存储结构。队列的链式存储结构可以分为单向链表和双向链表两种。

        单向链表的存储结构是每个节点包含一个数据元素和一个指向下一个节点的指针。队列的头指针指向链表的头节点，队列的尾指针指向链表的尾节点。入队操作将元素添加到尾节点之后，出队操作则删除头节点。

        双向链表的存储结构是每个节点包含一个数据元素、一个指向前一个节点的指针和一个指向下一个节点的指针。队列的头指针指向链表头部，队列的尾指针指向链表尾部。入队操作将元素添加到尾节点之后，出队操作则删除头节点。

        链式存储相比于顺序存储的优势在于可以更灵活地插入和删除元素，但是在访问元素时需要通过指针遍历链表，效率较低。

        链式存储结构的队列通常包含一个头结点和一个尾结点，其中头结点指向队列的头部，尾结点指向队列的尾部。每个结点都包含一个数据域和一个指针域，指针域指向下一个结点。

以下是C语言实现队列的链式存储的示例代码：

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

// 队列结点定义
typedef struct queue_node{
    int data;                   // 数据域
    struct queue_node *next;    // 指针域
} queue_node;

// 队列定义
typedef struct {
    queue_node *front;          // 队列头指针
    queue_node *rear;           // 队列尾指针
} queue;

// 初始化队列
void init_queue(queue *q)
{
    // 分配头结点
    q->front = q->rear = (queue_node *)malloc(sizeof(queue_node));
    if (!q->front) {
        printf("Memory allocation failed.\n");
        exit(-1);
    }
    q->front->next = NULL;
}

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

// 入队
void enqueue(queue *q, int data)
{
    queue_node *new_node = (queue_node *)malloc(sizeof(queue_node));
    if (!new_node) {
        printf("Memory allocation failed.\n");
        exit(-1);
    }
    new_node->data = data;
    new_node->next = NULL;
    q->rear->next = new_node;
    q->rear = new_node;
}

// 出队
int dequeue(queue *q)
{
    if (is_empty(q)) {
        printf("Queue is empty.\n");
        exit(-1);
    }
    queue_node *p = q->front->next;
    int data = p->data;
    q->front->next = p->next;
    if (q->rear == p) {
        q->rear = q->front;
    }
    free(p);
    return data;
}

// 输出队列中元素
void print_queue(queue *q)
{
    queue_node *p = q->front->next;
    while (p) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

int main()
{
    queue q;
    init_queue(&q);
    for (int i = 1; i <= 5; i++) {
        enqueue(&q, i);
    }
    print_queue(&q);
    dequeue(&q);
    print_queue(&q);
    return 0;
}

5.双端队列

        双端队列（deque，全名double-ended queue）是一种具有队列和栈的性质的数据结构，即两端都可以进行插入和删除操作。

        双端队列有两个端点：一个是“前端”（front），可以进行“出队”操作；另一个是“后端”（rear），可以进行“入队”操作。因此，双端队列支持的操作包括入队、出队、队头入队、队尾入队、队头出队、队尾出队等。

        与单端队列相比，双端队列的优势在于可以自由地从两端添加或删除元素，更加灵活、方便地实现某些算法和数据结构。例如，在实现图遍历算法中，使用双端队列可以使得遍历的顺序更加合理，减少搜索的时间和空间复杂度。

        另外，双端队列支持一些其他的操作，如获取队列长度、获取队头/尾元素等。

以下是C语言实现双端队列的代码：

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

// 双端队列节点结构体
typedef struct DequeNode {
    int val;
    struct DequeNode* next;
    struct DequeNode* prev;
} DequeNode;

// 双端队列结构体
typedef struct Deque {
    DequeNode* front; // 队头指针
    DequeNode* rear; // 队尾指针
    int size; // 队列元素个数
} Deque;

// 初始化双端队列
void initDeque(Deque* deque) {
    deque->front = NULL;
    deque->rear = NULL;
    deque->size = 0;
}

// 判断双端队列是否为空
bool isEmptyDeque(Deque* deque) {
    return deque->size == 0;
}

// 获取双端队列的长度
int sizeDeque(Deque* deque) {
    return deque->size;
}

// 获取双端队列队头元素
int frontDeque(Deque* deque) {
    return deque->front->val;
}

// 获取双端队列队尾元素
int rearDeque(Deque* deque) {
    return deque->rear->val;
}

// 在双端队列前端插入元素
void addFrontDeque(Deque* deque, int val) {
    DequeNode* new_node = (DequeNode*)malloc(sizeof(DequeNode));
    new_node->val = val;
    new_node->next = deque->front;
    new_node->prev = NULL;
    if (deque->front != NULL) {
        deque->front->prev = new_node;
    }
    deque->front = new_node;
    if (deque->rear == NULL) {
        deque->rear = new_node;
    }
    deque->size++;
}

// 在双端队列后端插入元素
void addRearDeque(Deque* deque, int val) {
    DequeNode* new_node = (DequeNode*)malloc(sizeof(DequeNode));
    new_node->val = val;
    new_node->next = NULL;
    new_node->prev = deque->rear;
    if (deque->rear != NULL) {
        deque->rear->next = new_node;
    }
    deque->rear = new_node;
    if (deque->front == NULL) {
        deque->front = new_node;
    }
    deque->size++;
}

// 在双端队列前端删除元素
void removeFrontDeque(Deque* deque) {
    if (deque->front == NULL) {
        return;
    }
    DequeNode* temp = deque->front;
    deque->front = deque->front->next;
    if (deque->front != NULL) {
        deque->front->prev = NULL;
    } else {
        deque->rear = NULL;
    }
    free(temp);
    deque->size--;
}

// 在双端队列后端删除元素
void removeRearDeque(Deque* deque) {
    if (deque->rear == NULL) {
        return;
    }
    DequeNode* temp = deque->rear;
    deque->rear = deque->rear->prev;
    if (deque->rear != NULL) {
        deque->rear->next = NULL;
    } else {
        deque->front = NULL;
    }
    free(temp);
    deque->size--;
}

// 测试
int main() {
    Deque deque;
    initDeque(&deque);
    addFrontDeque(&deque, 1);
    addRearDeque(&deque, 2);
    addFrontDeque(&deque, 3);
    addRearDeque(&deque, 4);
    while (!isEmptyDeque(&deque)) {
        printf("%d ", frontDeque(&deque));
        removeFrontDeque(&deque);
    }
    printf("\n");
    return 0;
}

6.循环队列

        循环队列是一种环形数据结构，它允许在一端添加数据元素，同时在另一端删除数据元素。与线性队列不同的是，在循环队列中，队头和队尾是可以相互穿越的。这意味着队列的末尾可以连接到队列的开始，形成一个环。这样，可以使用有限的空间，存储无限数量的数据元素。

        循环队列通常使用数组来实现。它有一个前后指针，称为队头和队尾。入队操作时，将新元素加入队尾，并将队尾指针向后移动。出队操作时，将队头元素删除，并将队头指针向后移动。当队列满时，新元素无法插入，即使队列前面有空位置。当队列为空时，无法删除元素。

        循环队列的主要优点是可以避免队列的前面空出大量空间，同时保证队列的顺序性和完整性。缺点是在实现时需要注意控制队列满和空的情况，以及指针的计算。

        循环队列是一种特殊的队列，其队尾指针指向数组的末尾后会回到数组的开头，实现队列的循环利用。下面是C语言实现循环队列的示例代码：

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

#define QUEUE_MAX_SIZE 5  // 队列的最大容量

typedef struct {
    int* data;  // 队列数据存储的位置
    int front;  // 队首指针
    int rear;   // 队尾指针
} Queue;

// 初始化队列
void InitQueue(Queue* q) {
    q->data = (int*)malloc(QUEUE_MAX_SIZE * sizeof(int));  // 分配队列空间
    q->front = q->rear = 0;  // 初始化队首和队尾指针
}

// 判断队列是否为空
int IsEmpty(Queue* q) {
    return q->front == q->rear;
}

// 判断队列是否已满
int IsFull(Queue* q) {
    return (q->rear + 1) % QUEUE_MAX_SIZE == q->front;
}

// 入队操作
int EnQueue(Queue* q, int value) {
    if (IsFull(q)) {
        return 0;  // 队列已满，无法入队
    }
    q->data[q->rear] = value;  // 将数据存入队列
    q->rear = (q->rear + 1) % QUEUE_MAX_SIZE;  // 队尾指针后移
    return 1;  // 入队成功
}

// 出队操作
int DeQueue(Queue* q, int* value) {
    if (IsEmpty(q)) {
        return 0;  // 队列为空，无法出队
    }
    *value = q->data[q->front];  // 取出队首数据
    q->front = (q->front + 1) % QUEUE_MAX_SIZE;  // 队首指针后移
    return 1;  // 出队成功
}

// 获取队首元素
int GetFront(Queue* q, int* value) {
    if (IsEmpty(q)) {
        return 0;  // 队列为空，无法获取队首元素
    }
    *value = q->data[q->front];  // 获取队首元素
    return 1;  // 获取成功
}

// 获取队列长度
int GetLength(Queue* q) {
    return (q->rear - q->front + QUEUE_MAX_SIZE) % QUEUE_MAX_SIZE;
}

// 输出队列中的所有元素
void PrintQueue(Queue* q) {
    int i, len = GetLength(q);
    for (i = 0; i < len; i++) {
        int value;
        DeQueue(q, &value);
        printf("%d ", value);
        EnQueue(q, value);
    }
    printf("\n");
}

// 测试代码
int main() {
    Queue q;
    InitQueue(&q);
    EnQueue(&q, 1);
    EnQueue(&q, 2);
    EnQueue(&q, 3);
    EnQueue(&q, 4);
    EnQueue(&q, 5);
    printf("Queue length: %d\n", GetLength(&q));  // 5
    printf("Queue content: ");
    PrintQueue(&q);  // 1 2 3 4 5
    int value;
    DeQueue(&q, &value);
    printf("DeQueue value: %d\n", value);  // 1
    printf("Queue content: ");
    PrintQueue(&q);  // 2 3 4 5
    EnQueue(&q

        在上面的代码中，我们实现了循环队列的初始化、判断是否为空或已满、入队、出队、获取队首元素、获取队列长度和输出队列中的所有元素等操作。我们可以通过这些操作对循环队列进行基本的操作。 

 🤞❤️🤞❤️🤞❤️栈的知识点总结就到这里啦，如果对博文还满意的话，劳烦各位看官动动“发财的小手”留下您对博文的赞和对博主的关注吧🤞❤️🤞❤️🤞❤️

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

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

相关文章

最新版WPS 2023 加载Zotero方法

最新版WPS 2023 加载Zotero方法

安装wps2019vba.exe&#xff0c;获取链接&#xff1a;链接&#xff1a;https://pan.baidu.com/s/1eeoc6Tmwyzxh3n1MFQTVeA 提取码&#xff1a;6431 –来自百度网盘超级会员V8的分享 打开WPS的工具的加载项 添加文件路径&#xff0c;我的在&#xff1a; C:\Users\Administrat…
阅读更多...
函数，变量作用域

函数，变量作用域

目录 为什么需要函数 ​编辑 什么叫函数​编辑 如何定义函数 ​编辑 return和break 函数分类 函数声明 函数是C语言基本单位 变量作用域 全局变量局部变量 命名一样 为什么需要函数 什么叫函数 如何定义函数 return和break 函数分类 函数声明 函数是C语言基本单位…
阅读更多...
腾讯云4核8G云服务器S5租用价格_CPU型号_网络性能

腾讯云4核8G云服务器S5租用价格_CPU型号_网络性能

腾讯云4核8G服务器CVM标准型S5实例性能测评&#xff0c;包括CPU型号、内存、系统盘、CVM实例规格性能测评&#xff0c;腾讯云4核8G租用优惠价格表&#xff0c;腾讯云服务器网分享腾讯云4核8G服务器CVM S5性能测评和租用费用&#xff1a; 目录 腾讯云4核8G服务器CVM S5性能测评…
阅读更多...
嵌入式操作Sqlite的8条建议

嵌入式操作Sqlite的8条建议

当使用 SQLite C 语言接口进行数据库操作时&#xff0c;以下是一些建议和最佳实践&#xff1a; 错误处理&#xff1a;SQLite C 语言接口的函数通常返回一个整数作为返回码&#xff08;return code&#xff09;。在调用这些函数后&#xff0c;应该检查返回码以确定操作是否成功。…
阅读更多...
pytorch中的词性标注_seq2seq_比较naive的示例

pytorch中的词性标注_seq2seq_比较naive的示例

一、各种用法_查漏补缺&#xff1a; 1.关于numpy中的argmax的用法&#xff1a; numpy之argmax()函数 - 知乎 (zhihu.com) 具体看这篇文章够了 二、代码注释&#xff1a; 参考&#xff1a; Sequence Models and Long Short-Term Memory Networks — PyTorch Tutorials 2.0.…
阅读更多...
Ae 效果：CC Rainfall

Ae 效果：CC Rainfall

模拟/CC Rainfall Simulation/CC Rainfall CC Rainfall&#xff08;CC 下雨&#xff09;可用来模拟带景深、光效和运动模糊的下雨效果。 ◆ ◆ ◆ 效果属性说明 Drops 雨滴 用于控制雨滴的数量。 默认值为 5000。值越大&#xff0c;雨线越密集。 Size 大小 用于控制雨滴的大小…
阅读更多...
【LeetCode-简单题】977. 有序数组的平方

【LeetCode-简单题】977. 有序数组的平方

文章目录 题目方法一&#xff1a;双指针方法二&#xff1a; 题目 方法一&#xff1a;双指针 class Solution { // 方法一 &#xff1a;双指针public int[] sortedSquares(int[] nums) {int left 0;int right nums.length -1 ;int[] res new int[nums.length];//结果集新数组…
阅读更多...
jwt自定义表签发、jwt 多方式登录(auth的user表)

jwt自定义表签发、jwt 多方式登录(auth的user表)

补充 # 1 接口文档编写规范&#xff1a;-1 描述-2 请求地址-3 请求方式-4 请求参数-headers-请求体-请求参数-5 请求编码格式-6 返回格式-示例-返回数据字段含义-其他&#xff1a;-错误状态码-...-接口文档编写位置-写在文件中&#xff1a;word&#xff0c;md&#xff0c;跟前…
阅读更多...
MySQL从入门到精通【实践篇】之使用Sharding-JDBC 分库分表详解

MySQL从入门到精通【实践篇】之使用Sharding-JDBC 分库分表详解

文章目录 0. 前言本文技术组件版本基本介绍 2. 使用和配置&#xff1a;步骤1 引入依赖步骤2 配置数据源和分片策略步骤3 核心代码MybatisPlusConfig 核心配置OrderServiceOrderServiceImplOrderInfoOrderMapperOrderControllerBaseMapper 3. 数据库分片配置在我的demo工程中大家…
阅读更多...
【2023】基于docker 实现部署jar包项目（包括单个和多个一起部署）

【2023】基于docker 实现部署jar包项目（包括单个和多个一起部署）

建议学习本博客之前&#xff0c;需要对docke的基本命令有过学习&#xff1b; 目录 前言1、项目打包2、编写Dockerfile文件2.1、单个jar部署&#x1f355;Dockerfile文件常用命令 2.2.1、编写一个Dockerfile 文件格式制作镜像 2.1.2、执行docker命令2.2、多个jar一起部署到docke…
阅读更多...
电脑提示“Windows Boot Manager boot failed”怎么办？

电脑提示“Windows Boot Manager boot failed”怎么办？

如果主引导记录(MBR)损坏&#xff0c;则会出现此错误消息“Windows Boot Manager boot failed”。因此&#xff0c;Windows 10引导管理器未能找到操作系统加载程序可能是由于MBR损坏。损坏MBR的原因可能是恶意软件感染或关闭电脑时使用方法不当。那么&#xff0c;Windows提示“…
阅读更多...
【iOS】push与present Controller的区别

【iOS】push与present Controller的区别

文章目录 前言一、push方法二、pop方法三、present方法四、dismiss方法五、dismiss多级的方法举例动画 前言 iOS推出与退出界面有两种方式——push与present&#xff0c;接下来笔者分别介绍这两种方式 一、push方法 SecondViewController *second [[SecondViewController all…
阅读更多...
运行ORB-SLAM3，整体感觉还不错

运行ORB-SLAM3，整体感觉还不错

安装文档&#xff0c;可以参考 https://blog.csdn.net/u014374826/article/details/132013820 运行测试 双目IMU 可以参考官方文档 Running ROS example: Download a rosbag (e.g. V1_02_medium.bag) from the EuRoC dataset (http://projects.asl.ethz.ch/datasets/doku.ph…
阅读更多...
Docker笔记-概念安装简单使用

Docker笔记-概念安装简单使用

概念 docker通用词汇。 镜像&#xff1a;Build&#xff0c;创建一个镜像。 仓库&#xff1a;Ship&#xff0c;从仓库和主机上运输镜像。 容器&#xff1a;Run&#xff0c;运行的镜像就是一个容器。 安装 Windows上安装 Docker对win10有原生的支持&#xff0c;win10下的是…
阅读更多...
zemax优化功能

zemax优化功能

1、三种优化方法 zemax的三种优化方法中&#xff0c;局部优化会找到局部的极小值点&#xff0c;全局优化会找到整体的最小值点。 锤形优化适用于先用全局优化找到大概值后&#xff0c;进一步完善光学系统 对于评价函数单调或者局部最小值就是全局最小值的情况&#xff0c;使…
阅读更多...
1976~2020年青藏高原典型冰川及冰湖遥感监测数据集

1976~2020年青藏高原典型冰川及冰湖遥感监测数据集

冰川面积是反应气候变化最直接的指标之一。在全球变暖的大背景下&#xff0c;对于评估冰川融化造成的生态、全球气候变化和水资源价值评价等问题十分重要。本文针对受西风和印度洋夏季风影响下的青藏高原冰川及其末端冰湖的变化特征&#xff0c;制作了近44年来时相相对连续的冰…
阅读更多...
使用LlamaIndex构建自己的PandasAI

使用LlamaIndex构建自己的PandasAI

推荐&#xff1a;使用 NSDT场景编辑器 快速搭建3D应用场景 Pandas AI 是一个 Python 库&#xff0c;它利用生成 AI 的强大功能来增强流行的数据分析库 Pandas。只需一个简单的提示&#xff0c;Pandas AI 就可以让你执行复杂的数据清理、分析和可视化&#xff0c;而这以前需要很…
阅读更多...
为特征向量数据（1D数组）叠加噪声实现数据增强

为特征向量数据（1D数组）叠加噪声实现数据增强

为特征向量数据&#xff08;1D数组&#xff09;叠加噪声实现数据增强 日期作者版本备注2023.09.11Dog TaoV1.0完成文档的初始版本。 文章目录 为特征向量数据&#xff08;1D数组&#xff09;叠加噪声实现数据增强背景介绍叠加噪声的主要方法高斯噪声&#xff08;Gaussian Nois…
阅读更多...
移动机器人（浙大）（待补充）

移动机器人（浙大）（待补充）

目录 1.简介 1.1分类 1.2执行模式 2.运动学建模 2.1简述 2.2建模 2.2.1分量叠加 3.导航规划 ​编辑 4.路径规划 1.简介 1.1分类 按移动方式&#xff1a;轮式、履带式、足式、躯干式 1.2执行模式 未知的环境中构建局部地图/已知环境则有地图&#xff0c;根据环境和定位信息进…
阅读更多...
AtCoder Beginner Contest 319(D-G)

AtCoder Beginner Contest 319(D-G)

D.Tasks - AtCoder Beginner Contest 319 &#xff08;1&#xff09;题意 给你一个M行得框框和N个单词&#xff0c;每个单词有一个宽度&#xff0c;每个单词之间应该用一个空格隔开&#xff0c;首位单词不需要&#xff0c;问至少需要多宽才能使得单词不会超过M行。 &#xff08…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023