详解Rust标准库：VecDeque 队列

news2024/11/8 2:07:59

theme: github
highlight: an-old-hope

查看本地官方文档

安装rust后运行

rustup doc

查看The Standard Library即可获取标准库内容

std::connections::VecDeque定义

队列是遵循先入先出规则的线性数据结构，在内存中不一定连续

VecDeque定义：可增长的环形缓冲区实现的双端队列

pub struct VecDeque<T, A: Allocator = Global> {
    // 队列头部在内部缓冲区中的索引位置
    head: usize,
    // 当前队列中的元素数量
    len: usize,
    // 管理内存分配和释放，确保有足够的空间来存储队列中的元素
    buf: RawVec<T, A>,
}

方法

with_capacity：用于创建一个具有指定初始容量的VecDeque

use std::collections::VecDeque;

fn main() {
    let deque = VecDeque::from([1, 2, 3]);
    if let Some(element) = deque.get(1) {
        println!("Element at index 1: {}", element);
        // Element at index 1: 2
    }
}

get：获取指定索引位置的元素的不可变引用

use std::collections::VecDeque;

fn main() {
    let deque = VecDeque::from([1, 2, 3]);
    if let Some(element) = deque.get(1) {
        println!("Element at index 1: {}", element);
        // Element at index 1: 2
    }
}

get_mut：获取指定索引位置的元素的可变引用

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3]);
    if let Some(element) = deque.get_mut(1) {
        *element = 4;
    }
    println!("Modified deque: {:?}", deque);
    // Modified deque: [1, 4, 3]
}

swap：交换VecDeque中两个指定索引位置的元素

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3]);
    deque.swap(0, 2);
    println!("Swapped deque: {:?}", deque);
    // Swapped deque: [3, 2, 1]
}

capacity：返回VecDeque当前的容量

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::with_capacity(5);
    println!("Initial capacity: {}", deque.capacity());
    // Initial capacity: 5

    deque.push_back(1);
    println!("Capacity after adding an element: {}", deque.capacity());
    // Capacity after adding an element: 5
}

reserve_exact：精确地预留足够的空间以容纳指定数量的额外元素

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::new();
    deque.reserve_exact(3);
    println!("Capacity after reserve_exact: {}", deque.capacity());
    // Capacity after reserve_exact: 3
    deque.push_back(1);
    deque.push_back(2);
    deque.push_back(3);
}

reserve：预留足够的空间以容纳指定数量的额外元素（空间不够自动增长）

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::new();
    deque.reserve(5);
    println!("Capacity after reserve: {}", deque.capacity());
    // Capacity after reserve: 5
    deque.push_back(1);
    deque.push_back(2);
    deque.push_back(3);
    deque.push_back(4);
    deque.push_back(5);
    deque.push_back(6);
    println!("Capacity after reserve: {}", deque.capacity());
    // Capacity after reserve: 10
}

try_reserve_exact：尝试精确地预留足够的空间以容纳指定数量的额外元素，如果预留成功则返回Ok(())，否则返回错误

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::new();
    if let Ok(()) = deque.try_reserve_exact(3) {
        println!("Reserved successfully. Capacity: {}", deque.capacity());
        // Reserved successfully. Capacity: 3
    } else {
        println!("Reserve failed.");
    }
    deque.push_back(1);
    deque.push_back(2);
    deque.push_back(3);
    deque.push_back(4);
    println!("Reserved successfully. Capacity: {}", deque.capacity());
    // Reserved successfully. Capacity: 6
}

try_reserve：尝试预留足够的空间以容纳指定数量的额外元素，如果预留成功则返回Ok(())，否则返回错误

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::new();
    if let Ok(()) = deque.try_reserve(3) {
        println!("Reserved successfully. Capacity: {}", deque.capacity());
        // Reserved successfully. Capacity: 4
    } else {
        println!("Reserve failed.");
    }
    deque.push_back(1);
    deque.push_back(2);
    deque.push_back(3);
    deque.push_back(4);
}

shrink_to_fit：将VecDeque的容量收缩到与当前元素数量相同

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::with_capacity(10);
    deque.push_back(1);
    deque.push_back(2);
    deque.push_back(3);
    deque.shrink_to_fit();
    println!("Capacity after shrink_to_fit: {}", deque.capacity());
    // Capacity after shrink_to_fit: 3
}

shrink_to：将VecDeque的容量收缩到指定大小

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::with_capacity(10);
    deque.push_back(1);
    deque.push_back(2);
    deque.push_back(3);
    deque.shrink_to(5);
    println!("Capacity after shrink_to: {}", deque.capacity());
    // Capacity after shrink_to: 5
}

truncate：将VecDeque截断到指定长度

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3, 4, 5]);
    deque.truncate(3);
    println!("Truncated deque: {:?}", deque);
    // Truncated deque: [1, 2, 3]
}

iter：返回一个不可变的迭代器，用于遍历VecDeque中的元素

use std::collections::VecDeque;

fn main() {
    let deque = VecDeque::from([1, 2, 3]);
    for element in deque.iter() {
        println!("Element: {}", element);
    }
    // Element: 1
    // Element: 2
    // Element: 3
}

iter_mut：返回一个可变的迭代器，允许在遍历过程中修改VecDeque中的元素

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3]);
    for element in deque.iter_mut() {
        *element *= 2;
    }
    println!("Modified deque: {:?}", deque);
    // Modified deque: [2, 4, 6]
}

as_slice：将VecDeque分成不可变的切片

use std::collections::VecDeque;

fn main() {
    let deque = VecDeque::from([1, 2, 3, 4, 5]);
    let (front_slice, back_slice) = deque.as_slices();
    println!("Front slice: {:?}", front_slice);
    // Front slice: [1, 2, 3, 4, 5]
    println!("Back slice: {:?}", back_slice);
    // Back slice: []
}

as_mut_slices：将VecDeque分成可变的切片

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3, 4, 5]);
    let (front_slice, back_slice) = deque.as_mut_slices();
    for element in front_slice {
        *element *= 2;
    }
    for element in back_slice {
        *element *= 3;
    }
    println!("Modified deque: {:?}", deque);
    // Modified deque: [2, 4, 6, 8, 10]
}

len：返回VecDeque中元素的数量

use std::collections::VecDeque;

fn main() {
    let deque = VecDeque::from([1, 2, 3]);
    println!("Length of deque: {}", deque.len());
    // Length of deque: 3
}

is_empty：判断VecDeque是否为空

use std::collections::VecDeque;

fn main() {
    let deque:VecDeque<i32> = VecDeque::new();
    println!("Is deque empty? {}", deque.is_empty());
    // Is deque empty? true
    let deque2 = VecDeque::from([1]);
    println!("Is deque2 empty? {}", deque2.is_empty());
    // Is deque2 empty? false
}

range：返回一个指定范围内的不可变迭代器

use std::collections::VecDeque;

fn main() {
    let deque = VecDeque::from([1, 2, 3, 4, 5]);
    for element in deque.range(1..3) {
        println!("Element: {}", element);
        // Element: 2
        // Element: 3
    }
}

range_mut：返回一个指定范围内的可变迭代器

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3, 4, 5]);
    for element in deque.range_mut(1..3) {
        *element *= 2;
    }
    println!("Modified deque: {:?}", deque);
    // Modified deque: [1, 4, 6, 4, 5]
}

drain：移除并返回一个迭代器，用于遍历被移除的元素

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3, 4, 5]);
    let drained = deque.drain(1..3).collect::<Vec<i32>>();
    println!("Drained elements: {:?}", drained);
    // Drained elements: [2, 3]
    println!("Remaining deque: {:?}", deque);
    // Remaining deque: [1, 4, 5]
}

clear：清空VecDeque，移除所有元素

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3]);
    println!("Before clearing: {:?}", deque);
    // Before clearing: [1, 2, 3]
    deque.clear();
    println!("After clearing: {:?}", deque);
    // After clearing: []
}

contains：判断VecDeque中是否包含特定元素

use std::collections::VecDeque;

fn main() {
    let deque = VecDeque::from([1, 2, 3]);
    println!("Does deque contain 2? {}", deque.contains(&2));
    // Does deque contain 2? true
    println!("Does deque contain 4? {}", deque.contains(&4));
    // Does deque contain 4? false
}

front：返回VecDeque头部元素的不可变引用，如果为空则返回None

use std::collections::VecDeque;

fn main() {
    let deque = VecDeque::from([1, 2, 3]);
    if let Some(element) = deque.front() {
        println!("Front element: {}", element);
        // Front element: 1
    }
}

front_mut：返回VecDeque头部元素的可变引用，如果为空则返回None

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3]);
    if let Some(element) = deque.front_mut() {
        *element = 4;
    }
    println!("Modified deque: {:?}", deque);
    // Modified deque: [4, 2, 3]
}

back：返回VecDeque尾部元素的不可变引用，如果为空则返回None

use std::collections::VecDeque;

fn main() {
    let deque = VecDeque::from([1, 2, 3]);
    if let Some(element) = deque.back() {
        println!("Back element: {}", element);
        // Back element: 3
    }
}

back_mut：返回VecDeque尾部元素的可变引用，如果为空则返回None

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3]);
    if let Some(element) = deque.back_mut() {
        *element = 4;
    }
    println!("Modified deque: {:?}", deque);
    // Modified deque: [1, 2, 4]
}

pop_front：移除并返回VecDeque头部元素，如果为空则返回None

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3]);
    if let Some(element) = deque.pop_front() {
        println!("Popped element: {}", element);
        // Popped element: 1
    }
    println!("Remaining deque: {:?}", deque);
    // Remaining deque: [2, 3]
}

pop_back：移除并返回VecDeque尾部元素，如果为空则返回None

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3]);
    if let Some(element) = deque.pop_back() {
        println!("Popped element: {}", element);
        // Popped element: 3
    }
    println!("Remaining deque: {:?}", deque);
    // Remaining deque: [1, 2]
}

push_front：在VecDeque头部插入一个元素

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::new();
    deque.push_front(1);
    deque.push_front(2);
    println!("Modified deque: {:?}", deque);
    // Modified deque: [2, 1]
}

push_back：在VecDeque尾部插入一个元素

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::new();
    deque.push_back(1);
    deque.push_back(2);
    println!("Modified deque: {:?}", deque);
    // Modified deque: [1, 2]
}

swap_remove_front：移除并返回VecDeque头部开始的元素索引，同时用其后的第一个元素替换它，避免移动其后的所有元素，如果为空则返回None

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3, 4]);
    if let Some(element) = deque.swap_remove_front(2) {
        println!("Swapped and removed element: {}", element);
        // Swapped and removed element: 3
    }
    println!("Remaining deque: {:?}", deque);
    // Remaining deque: [2, 1, 4]
}

swap_remove_back：移除并返回VecDeque尾部开始的元素索引，同时用前一个元素替换它，避免移动前面的所有元素，如果为空则返回None

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3, 4]);
    if let Some(element) = deque.swap_remove_back(2) {
        println!("Swapped and removed element from back: {}", element);
        // Swapped and removed element from back: 3
    }
    println!("Remaining deque: {:?}", deque);
    // Remaining deque: [1, 2, 4]
}

insert：在指定索引位置插入一个元素。如果索引超出范围，会导致程序 panic（元素为[1,2,3]时容量为3，插入索引1不改变容量，插入4时由于索引是连续的，会开辟原队列的两倍容量6，后续插入索引5可以成功，如果直接插入5索引不连续不会开辟新空间会panic）

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3]);
    println!("deque capacity: {}", deque.capacity());
    // deque capacity: 3
    deque.insert(1, 9);
    // deque.insert(4, 5); // 这一行存在以下操作成功，不存在 panic!
    deque.insert(5, 6); // panic!'
    println!("deque capacity: {}", deque.capacity());
    // deque capacity: 6
    println!("After insertion: {:?}", deque);
    // After insertion: [1, 9, 2, 4, 3, 6]
    println!("deque capacity: {}", deque.capacity());
    // deque capacity: 6
}

remove：移除指定索引位置的元素，并返回该元素。如果索引超出范围，会导致程序 panic

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3]);
    if let Some(element) = deque.remove(1) {
        println!("Removed element: {}", element);
        // Removed element: 2
    }
    println!("Remaining deque: {:?}", deque);
    // Remaining deque: [1, 3]
}

split_off：在指定索引位置将VecDeque分割成两个，返回从指定索引开始的后半部分

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3, 4, 5]);
    let deque2 = deque.split_off(2);

    println!("{:?}", deque2);
    // [3, 4, 5]
}

append：将另一个VecDeque的所有元素追加到当前VecDeque的末尾

use std::collections::VecDeque;

fn main() {
    let mut deque1 = VecDeque::from([1, 2, 3]);
    let mut deque2 = VecDeque::from([4, 5, 6]);
    deque1.append(&mut deque2);
    println!("Appended deque: {:?}", deque1);
    // Appended deque: [1, 2, 3, 4, 5, 6]
}

retain：保留满足给定谓词的元素，移除不满足的元素

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3, 4, 5]);
    deque.retain(|&x| x % 2 == 0);
    println!("After retain: {:?}", deque);
    // After retain: [2, 4]
}

retain_mut：与retain类似，但可以对元素进行可变操作

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3, 4, 5]);
    deque.retain_mut(|x| {
        *x *= 2;
        *x % 3 == 0
    });
    println!("After retain_mut: {:?}", deque);
    // After retain_mut: [6]
}

resize_with：调整VecDeque的大小到指定长度，使用给定的函数生成新元素填充额外的空间或者截断多余的元素

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2]);
    deque.resize_with(5, || 0);
    println!("Resized deque: {:?}", deque);
    // Resized deque: [1, 2, 0, 0, 0]
}

make_contiguous：尝试使VecDeque在内存中连续存储，可能会导致重新分配内存

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3]);
    deque.make_contiguous();
    println!("After make_contiguous: {:?}", deque);
    // After make_contiguous: [1, 2, 3]
}

rotate_left：将VecDeque向左旋转指定的步数

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3, 4, 5]);
    deque.rotate_left(2);
    println!("After rotate_left: {:?}", deque);
    // After rotate_left: [3, 4, 5, 1, 2]
}

rotate_right：将VecDeque向右旋转指定的步数

use std::collections::VecDeque;

fn main() {
    let mut deque = VecDeque::from([1, 2, 3, 4, 5]);
    deque.rotate_right(2);
    println!("After rotate_right: {:?}", deque);
    // After rotate_right: [4, 5, 1, 2, 3]
}

binary_search：在已排序的VecDeque中进行二分查找指定元素，返回一个Result类型，表示查找结果。如果找到元素，返回Ok(index)，默认最后一个结果；如果未找到返回Err()；在未排序的队列进行查找会返回unspecified，这个结果没有意义

当查找的元素不存在时返回查找元素应当插入位置有序队列位置的索引

当查找的元素存在时返回最后一个匹配的元素

use std::collections::VecDeque;

fn main() {
    let deque = VecDeque::from([1, 2, 3, 3, 4, 5]);
    let result = deque.binary_search(&3);
    println!("{:?}", result);
    // Ok(3)

    // 有序且不存在
    let deque = VecDeque::from([3, 3, 3, 3, 3, 4, 4, 7, 8]);
    let result = deque.binary_search(&5);
    println!("{:?}", result);
    // Err(7)

    // 有序且存在
    let deque = VecDeque::from([3, 3, 3, 3, 3, 4, 4, 7, 8]);
    let result = deque.binary_search(&3);
    println!("{:?}", result);
    // Ok(4)

    // 注意以下结果没有意义

    // 无序且不存在
    let deque = VecDeque::from([3, 9, 3, 3, 8, 4, 3, 7, 3]);
    let result = deque.binary_search(&5);
    println!("{:?}", result);
    // Err(4)

    // 无序且存在
    let deque = VecDeque::from([3, 9, 3, 3, 8, 4, 3, 7, 3]);
    let result = deque.binary_search(&3);
    println!("{:?}", result);
    // Ok(2)
}

binary_search_by：使用自定义的比较函数在已排序的VecDeque中进行二分查找

use std::collections::VecDeque;

fn main() {
    let deque = VecDeque::from([1, 2, 3, 3, 4, 6]);
    // 找到最后一个等于3的元素索引
    let result = deque.binary_search_by(|x| x.cmp(&3));
    println!("{:?}", result);
    // Ok(3)

    // 找到最后一个等于5de的元素索引,不存在返回应当插入位置的索引
    let result = deque.binary_search_by(|x| x.cmp(&5));
    println!("{:?}", result);
    // Err(5)
}

binary_search_by_key：如果队列是以元组键的顺序排序的，使用自定义的键提取函数在已排序的VecDeque中进行二分查找

use std::collections::VecDeque;

fn main() {
    let deque = VecDeque::from([
        (0, 0),
        (2, 1),
        (4, 1),
        (5, 1),
        (3, 1),
        (1, 2),
        (2, 3),
        (4, 5),
        (5, 8),
        (3, 13),
        (1, 21),
        (2, 34),
        (4, 55),
    ]);
    // 按元组第二个键值排序
    let result = deque.binary_search_by_key(&13, |&(a, b)| b);
    println!("{:?}", result);
    // Ok(9)
}

partition_point：在已排序的VecDeque中找到满足给定谓词的元素的分界点。即返回第一个不满足谓词的元素的索引

use std::collections::VecDeque;

fn main() {
    let deque: VecDeque<i32> = VecDeque::from([1, 2, 3, 3, 5, 6, 7]);
    // 按小于5的元素划分，返回第一个大于等于5的索引
    let result = deque.partition_point(|&x| x < 5);
    println!("{:?}", result);
    // 4
}

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

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

相关文章

软件开发项目管理：实现目标的实用指南

软件开发项目管理：实现目标的实用指南

由于软件项目多数是复杂且难以预测的&#xff0c;对软件开发生命周期的深入了解、合适的框架以及强大的工作管理平台是必不可少的。项目管理系统在软件开发中通常以监督为首要任务&#xff0c;但优秀的项目计划、管理框架和软件工具可以使整个团队受益。 软件开发项目管理的主要…
阅读更多...
计算网络信号

计算网络信号

题目描述&#xff1a; 网络信号经过传递会逐层衰减&#xff0c;且遇到阻隔物无法直接穿透&#xff0c;在此情况下需要计算某个位置的网络信号值。注意&#xff1a;网络信号可以绕过阻隔物 array[m][n]的二维数组代表网格地图&#xff0c; array[i][j]0代表i行j列是空旷位置&…
阅读更多...
ESP8266 自定义固件烧录-Tcpsocket固件

ESP8266 自定义固件烧录-Tcpsocket固件

一、固件介绍 固件为自定义开发的一个适配物联网项目的开源固件&#xff0c;支持网页配网、支持网页tcpsocket服务器配置、支持串口波特率设置。 方便、快捷、稳定&#xff01; 二、烧录说明 固件及工具打包下载地址&#xff1a; https://download.csdn.net/download/flyai…
阅读更多...
数据结构与算法——Java实现 52.力扣98题——验证二叉搜索树

数据结构与算法——Java实现 52.力扣98题——验证二叉搜索树

我将一直向前&#xff0c;带着你给我的淤青 —— 24.11.5 98. 验证二叉搜索树 给你一个二叉树的根节点 root &#xff0c;判断其是否是一个有效的二叉搜索树。 有效 二叉搜索树定义如下&#xff1a; 节点的左子树只包含 小于 当前节点的数。节点的右子树只包含 大于 当前节点的…
阅读更多...
[mysql]DDL,DML综合案例,

[mysql]DDL,DML综合案例,

综合案例 题目如下 目录 综合案例 ​编辑 ​编辑 # 1、创#1建数据库test01_library # 2、创建表 books&#xff0c;表结构如下&#xff1a; # 3、向books表中插入记录库存 # 4、将小说类型(novel)的书的价格都增加5。 # 5、将名称为EmmaT的书的价格改为40&#xff0c;并将…
阅读更多...
书生实战营第四期-基础岛第三关-浦语提示词工程实践

书生实战营第四期-基础岛第三关-浦语提示词工程实践

一、基础任务 任务要求&#xff1a;利用对提示词的精确设计&#xff0c;引导语言模型正确回答出“strawberry”中有几个字母“r”。 1.提示词设计 你是字符计数专家&#xff0c;能够准确回答关于文本中特定字符数量的问题。 - 技能&#xff1a; - &#x1f4ca; 分析文本&…
阅读更多...
国药准字生发产品有哪些？这几款不错

国药准字生发产品有哪些？这几款不错

头秃不知道怎么选的朋友们看这&#xff0c;基本上市面上火的育发精华我都用了个遍了&#xff0c;陆陆续续也花了有大几w了&#xff0c;都是真金白银总结出来的&#xff0c;所以必须要给掉发人分享一些真正好用的育发产品&#xff0c;大家可以根据自己实际情况来选择。 1. 露卡菲…
阅读更多...
构建基于 DCGM-Exporter, Node exporter,PROMETHEUS 和 GRAFANA 构建算力监控系统

构建基于 DCGM-Exporter, Node exporter,PROMETHEUS 和 GRAFANA 构建算力监控系统

目录 引言工具作用概述DCGM-ExporterNode exporterPROMETHEUSGRAFANA小结 部署单容器DCGM-ExporterNode exporterPROMETHEUSGRAFANANode exporterDCGM-Exporter 多容器Node exporterDCGM-ExporterDocker Compose 参考 引言 本文的是适用对象&#xff0c;是希望通过完全基于Doc…
阅读更多...
Java入门14——动态绑定（含多态）

Java入门14——动态绑定（含多态）

大家好&#xff0c;我们今天来学动态绑定和多态&#xff0c;话不多说&#xff0c;开始正题~ 但是要学动态绑定之前&#xff0c;我们要学习一下向上转型&#xff0c;方便后续更好地理解~ 一、向上转型 1.什么是向上转型 网上概念有很多&#xff0c;但其实通俗来讲&#xff0c…
阅读更多...
Request 和 Response 万字详解

Request 和 Response 万字详解

文章目录 1.Request和Response的概述2.Request对象2.1 Request 继承体系2.2 Request获取请求数据2.2.1 获取请求行数据2.2.2 获取请求头数据2.2.3 获取请求体数据2.2.4 获取请求参数的通用方式 2.3 解决post请求乱码问题 掌握内容讲解内容小结 2.4 Request请求转发 3.HTTP响应详…
阅读更多...
Qt QCustomplot 在采集信号领域的应用

Qt QCustomplot 在采集信号领域的应用

文章目录 一、常用的几种开源库：1、QCustomPlot:2、QChart:3、Qwt:QCustomplot 在采集信号领域的应用1、应用实例时域分析频谱分析2.数据筛选和处理其他参考自然界中的物理过程、传感器和传感器网络、电路和电子设备、通信系统等都是模拟信号的来源。通过可视化模拟信号，可以…
阅读更多...
【初阶数据结构与算法】沉浸式刷题之顺序表练习(顺序表以及双指针两种方法)

【初阶数据结构与算法】沉浸式刷题之顺序表练习(顺序表以及双指针两种方法)

文章目录 顺序表练习1.移除数组中指定的元素方法1&#xff08;顺序表&#xff09;方法2&#xff08;双指针&#xff09; 2.删除有序数组中的重复项方法1&#xff08;顺序表&#xff09;方法2&#xff08;双指针&#xff09; 3.双指针练习之合并两个有序数组方法1&#xff08;直…
阅读更多...
机器学习—矩阵乘法

机器学习—矩阵乘法

矩阵只是一个或两个数组。 如何在向量之间取点积&#xff1f; 让我们用列向量[1,2]*[[3,4]&#xff0c;如果z是这两个向量之间的点积&#xff0c;然后通过乘以第一个元素来计算z&#xff0c;通过这里的第一个元素&#xff0c;所以是1*3加第二个元素乘以第二个元素即2*4&#…
阅读更多...
使用 ADB 在某个特定时间点点击 Android 设备上的某个按钮

使用 ADB 在某个特定时间点点击 Android 设备上的某个按钮

前提条件 安装 ADB&#xff1a;确保你已经在计算机上安装了 Android SDK&#xff08;或单独的 ADB&#xff09;。并将其添加到系统环境变量中&#xff0c;以便你可以在命令行中运行 adb。 USB调试&#xff1a;确保 Android 设备已启用 USB 调试模式。这可以在设备的“设置” -…
阅读更多...
数据结构之二叉树前序，中序，后序习题分析（递归图）

数据结构之二叉树前序，中序，后序习题分析（递归图）

1.比较相同的树 二叉树不能轻易用断言&#xff0c;因为树一定有空 2.找结点值 3.单值二叉树 4.对称二叉树 5.前序遍历
阅读更多...
[CUDA] 将已有的地址空间设置为pinned memory

[CUDA] 将已有的地址空间设置为pinned memory

文章目录 1. cudaHostRegitster的使用构建pinned memory1.1 基本使用1.2 cudaHostRegister 需要设置cudaSetDevice? Reference 1. cudaHostRegitster的使用构建pinned memory 注意使用C申请的内存空间&#xff0c;在进行copy是无法实现流的最大异步性&#xff1b;因此使用cud…
阅读更多...
各种数据库介绍

各种数据库介绍

1. 关系型数据库&#xff08;RDBMS&#xff09; MySQL • 特点&#xff1a;开源、免费&#xff0c;社区版功能强大且稳定。支持大量的并发连接&#xff0c;常用于Web应用。 • 适用场景&#xff1a;中小型网站、博客、电商等。 PostgreSQL • 特点&#xff1a;功能丰富&#xf…
阅读更多...
ONLYOFFICE 8.2版本评测：超好用办公工具

ONLYOFFICE 8.2版本评测：超好用办公工具

前言 在技术的快速发展和工作方式的持续演进下&#xff0c;现代办公软件正变得越来越强大和多样化。ONLYOFFICE&#xff0c;作为市场上备受瞩目的一体化办公解决方案&#xff0c;以其全面的文档编辑、表格处理和演示制作功能&#xff0c;满足了用户在不同办公场景下的需求。最…
阅读更多...
Python基础学习_01

Python基础学习_01

目录 1、注释 2、数字和数学计算 3、变量 4、字符串 5、打印 6、本节总结 1、注释 • 什么是注释&#xff1f; 1&#xff09;注释就是用自然语言向代码阅读者说明代码的功能和意义 • 注释 1&#xff09;单行注释使用 # 为开头&#xff1b;并且不能换行…
阅读更多...
不容错过的电脑监控软件TOP10|电脑屏幕监控软件推荐（收藏）

不容错过的电脑监控软件TOP10|电脑屏幕监控软件推荐（收藏）

随着企业对员工管理和数据安全的要求日益提高&#xff0c;电脑监控软件已经成为许多公司确保工作效率、信息保密以及员工行为合规性的重要工具。无论是需要跟踪员工的工作进度&#xff0c;还是防止数据泄露和滥用&#xff0c;选择合适的监控软件至关重要。今天我们为你整理了十…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023