Rust每日一练(leetDay0001) 两数之和、两数相加、最长子串

news2024/11/22 16:33:21

 

目录

1. 两数之和 Two Sum  🌟

2. 两数相加 Add Two Numbers  🌟🌟

3. 无重复字符的最长子串 Longest substring without repeating characters  🌟🌟

🌟 每日一练刷题专栏 🌟

Rust每日一练 专栏

Golang每日一练 专栏

Python每日一练 专栏

C/C++每日一练 专栏

Java每日一练 专栏

1. 两数之和 Two Sum

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

  • 2 <= nums.length <= 10^4
  • -10^9 <= nums[i] <= 10^9
  • -10^9 <= target <= 10^9
  • 只会存在一个有效答案

进阶：你可以想出一个时间复杂度小于 O(n^2) 的算法吗？

代码1： 暴力枚举

fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
    let n = nums.len();
    for i in 0..n {
        for j in i+1..n {
            if nums[i] + nums[j] == target {
                return vec![i as i32, j as i32];
            }
        }
    }
    vec![]
}

fn main() {

    let nums = [2, 7, 11, 15];
    let target = 9;
    println!("{:?}", two_sum((&nums).to_vec(), target));

    let nums = [3, 2, 4];
    let target = 6;
    println!("{:?}", two_sum((&nums).to_vec(), target));

    let nums = [3, 3];
    println!("{:?}", two_sum((&nums).to_vec(), target));
}

 代码2： 二分查找

fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
    let n = nums.len();
    for i in 0..n {
        let complement = target - nums[i];
        if let Ok(j) = nums.binary_search(&complement) {
            if i != j {
                return vec![i as i32, j as i32];
            }
        }
    }
    vec![]
}

fn main() {

    let nums = [2, 7, 11, 15];
    let target = 9;
    println!("{:?}", two_sum((&nums).to_vec(), target));

    let nums = [3, 2, 4];
    let target = 6;
    println!("{:?}", two_sum((&nums).to_vec(), target));

    let nums = [3, 3];
    println!("{:?}", two_sum((&nums).to_vec(), target));
}

 代码3： 哈希表

use std::collections::HashMap;

fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
    let mut map = HashMap::new();
    for (i, num) in nums.iter().enumerate() {
        let complement = target - num;
        if let Some(j) = map.get(&complement) {
            return vec![*j as i32, i as i32];
        }
        map.insert(num, i);
    }
    vec![]
}

fn main() {

    let nums = [2, 7, 11, 15];
    let target = 9;
    println!("{:?}", two_sum((&nums).to_vec(), target));

    let nums = [3, 2, 4];
    let target = 6;
    println!("{:?}", two_sum((&nums).to_vec(), target));

    let nums = [3, 3];
    println!("{:?}", two_sum((&nums).to_vec(), target));
}

 数组 + 哈希表 

fn two_sum(nums: &[i32], target: i32) -> Vec<i32> {
    let mut imap = std::collections::HashMap::new();
    for (i, num) in nums.iter().enumerate() {
        let two = target - num;
        if let Some(&j) = imap.get(&two) {
            return vec![j as i32, i as i32];
        }
        imap.insert(num, i);
    }
    vec![]
}

fn main() {

    let nums = [2, 7, 11, 15];
    let target = 9;
    println!("{:?}", two_sum(&nums, target));

    let nums = [3, 2, 4];
    let target = 6;
    println!("{:?}", two_sum(&nums, target));

    let nums = [3, 3];
    println!("{:?}", two_sum(&nums, target));
}

代码4： 排序+双指针

fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
    let mut nums = nums;
    let n = nums.len();
    for i in 0..n {
        nums[i] = nums[i].clone() as i32;
    }
    let mut pairs: Vec<(i32, usize)> = nums.iter()
        .enumerate()
        .map(|(i, &x)| (x, i))
        .collect();
    pairs.sort_unstable();
    let (mut i, mut j) = (0, n - 1);
    while i < j {
        let sum = pairs[i].0 + pairs[j].0;
        if sum == target {
            let (index1, index2) = (pairs[i].1 as i32, pairs[j].1 as i32);
            return vec![index1, index2];
        } else if sum < target {
            i += 1;
        } else {
            j -= 1;
        }
    }
    vec![]
}

fn main() {

    let nums = [2, 7, 11, 15];
    let target = 9;
    println!("{:?}", two_sum((&nums).to_vec(), target));

    let nums = [3, 2, 4];
    let target = 6;
    println!("{:?}", two_sum((&nums).to_vec(), target));

    let nums = [3, 3];
    println!("{:?}", two_sum((&nums).to_vec(), target));
}

输出：

[0, 1]
[1, 2]
[0, 1]

2. 两数相加 Add Two Numbers

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：

  • 每个链表中的节点数在范围 [1, 100] 内
  • 0 <= Node.val <= 9
  • 题目数据保证列表表示的数字不含前导零

代码1： 模拟竖式加法

use std::fmt;

struct ListNode {
    data: i32,
    next: Option<Box<ListNode>>,
}

impl ListNode {
    fn new(data: i32) -> Self {
        ListNode { data, next: None }
    }

    fn build(list: &[i32]) -> Option<Box<ListNode>> {
        let mut head = None;
        for i in (0..list.len()).rev() {
            head = Some(Box::new(ListNode {
                data: list[i],
                next: head,
            }));
        }
        head
    }
}

impl fmt::Debug for ListNode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let mut p = Some(self);
        while let Some(node) = p {
            write!(f, "{}->", node.data)?;
            p = node.next.as_ref().map(|x| x.as_ref());
        }
        write!(f, "<nil>")
    }
}

fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
    let mut dummy_head = ListNode::new(0);
    let (mut p1, mut p2, mut curr) = (l1, l2, &mut dummy_head);
    let mut carry = 0;
    while p1.is_some() || p2.is_some() || carry != 0 {
        let mut sum = carry;
        if let Some(node) = p1 {
            sum += node.data;
            p1 = node.next;
        }
        if let Some(node) = p2 {
            sum += node.data;
            p2 = node.next;
        }
        carry = sum / 10;
        curr.next = Some(Box::new(ListNode::new(sum % 10)));
        curr = curr.next.as_mut().unwrap();
    }
    dummy_head.next
}

fn main() {
    let l1 = ListNode::build(&[2, 4, 3]);
    let l2 = ListNode::build(&[5, 6, 4]);
    println!("{:?}", l1);
    println!("{:?}", l2);
    println!("{:?}", add_two_numbers(l1, l2));

    let l1 = ListNode::build(&[9,9,9,9,9,9,9]);
    let l2 = ListNode::build(&[9,9,9,9]);
    println!("{:?}", l1);
    println!("{:?}", l2);
    println!("{:?}", add_two_numbers(l1, l2));
}

代码2： 模拟竖式加法2

use std::fmt;

struct ListNode {
    data: i32,
    next: Option<Box<ListNode>>,
}

impl ListNode {
    fn new(data: i32) -> Self {
        ListNode { data, next: None }
    }

    fn build(list: &[i32]) -> Option<Box<ListNode>> {
        let mut head = None;
        for i in (0..list.len()).rev() {
            head = Some(Box::new(ListNode {
                data: list[i],
                next: head,
            }));
        }
        head
    }
}

impl fmt::Debug for ListNode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let mut p = Some(self);
        while let Some(node) = p {
            write!(f, "{}->", node.data)?;
            p = node.next.as_ref().map(|x| x.as_ref());
        }
        write!(f, "<nil>")
    }
}

fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
    let mut dummy_head = ListNode::new(0);
    let mut p = &mut dummy_head;
    let mut p1 = l1.as_ref();
    let mut p2 = l2.as_ref();
    let mut carry = 0;
    while p1.is_some() || p2.is_some() {
        let mut sum = carry;
        if let Some(node) = p1 {
            sum += node.data;
            p1 = node.next.as_ref();
        }
        if let Some(node) = p2 {
            sum += node.data;
            p2 = node.next.as_ref();
        }
        carry = sum / 10;
        p.next = Some(Box::new(ListNode::new(sum % 10)));
        p = p.next.as_mut().unwrap();
    }
    if carry > 0 {
        p.next = Some(Box::new(ListNode::new(carry)));
    }
    dummy_head.next
}

fn main() {
    let l1 = ListNode::build(&[2, 4, 3]);
    let l2 = ListNode::build(&[5, 6, 4]);
    println!("{:?}", l1);
    println!("{:?}", l2);
    println!("{:?}", add_two_numbers(l1, l2));

    let l1 = ListNode::build(&[9,9,9,9,9,9,9]);
    let l2 = ListNode::build(&[9,9,9,9]);
    println!("{:?}", l1);
    println!("{:?}", l2);
    println!("{:?}", add_two_numbers(l1, l2));
}

代码3： 递归法

use std::fmt;

struct ListNode {
    data: i32,
    next: Option<Box<ListNode>>,
}

impl ListNode {
    fn new(data: i32) -> Self {
        ListNode { data, next: None }
    }

    fn build(list: &[i32]) -> Option<Box<ListNode>> {
        let mut head = None;
        for i in (0..list.len()).rev() {
            head = Some(Box::new(ListNode {
                data: list[i],
                next: head,
            }));
        }
        head
    }
}

impl fmt::Debug for ListNode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let mut p = Some(self);
        while let Some(node) = p {
            write!(f, "{}->", node.data)?;
            p = node.next.as_ref().map(|x| x.as_ref());
        }
        write!(f, "<nil>")
    }
}

fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
    add_helper(l1.as_ref(), l2.as_ref(), 0)
}

fn add_helper(l1: Option<&Box<ListNode>>, l2: Option<&Box<ListNode>>, carry: i32) -> Option<Box<ListNode>> {
    if l1.is_none() && l2.is_none() && carry == 0 {
        return None;
    }
    let mut sum = carry;
    if let Some(node) = l1 {
        sum += node.data;
    }
    if let Some(node) = l2 {
        sum += node.data;
    }
    let mut node = ListNode::new(sum % 10);
    node.next = add_helper(l1.map(|x| x.next.as_ref()).flatten(), l2.map(|x| x.next.as_ref()).flatten(), sum / 10);
    Some(Box::new(node))
}

fn main() {
    let l1 = ListNode::build(&[2, 4, 3]);
    let l2 = ListNode::build(&[5, 6, 4]);
    println!("{:?}", l1);
    println!("{:?}", l2);
    println!("{:?}", add_two_numbers(l1, l2));

    let l1 = ListNode::build(&[9,9,9,9,9,9,9]);
    let l2 = ListNode::build(&[9,9,9,9]);
    println!("{:?}", l1);
    println!("{:?}", l2);
    println!("{:?}", add_two_numbers(l1, l2));
}

输出：

2->4->3-><nil>
5->6->4-><nil>
7->0->8-><nil>
9->9->9->9->9->9->9-><nil>
9->9->9->9-><nil>
8->9->9->9->0->0->0->1-><nil>

3. 无重复字符的最长子串 Longest substring without repeating characters

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

提示：

  • 0 <= s.length <= 5 * 10^4
  • s 由英文字母、数字、符号和空格组成

代码1： 滑动窗口

use std::collections::HashSet;
fn length_of_longest_substring(s: String) -> i32 {
    let s = s.as_bytes();
    let mut set = HashSet::new();
    let mut left = 0;
    let mut right = 0;
    let mut max_len = 0;
    while right < s.len() {
        if !set.contains(&s[right]) {
            set.insert(s[right]);
            right += 1;
            max_len = max_len.max(right - left);
        } else {
            set.remove(&s[left]);
            left += 1;
        }
    }
    max_len as i32
}

fn main() {
    let str = String::from("abcabcbb");
    println!("{}", length_of_longest_substring(str));

    let str = "bbbbb".to_string();
    println!("{}", length_of_longest_substring(str));

    let str = "pwwkew".to_string();
    println!("{}", length_of_longest_substring(str));
}

代码2： 动态规划

fn length_of_longest_substring(s: String) -> i32 {
    let s = s.as_bytes();
    let mut dp = vec![0; s.len()];
    let mut max_len = 0;
    for i in 0..s.len() {
        if i == 0 || !s[0..i].contains(&s[i]) {
            dp[i] = if i == 0 { 1 } else { dp[i-1] + 1 };
        } else {
            let last_pos = s[0..i].iter().rposition(|&x| x == s[i]).unwrap();
            dp[i] = i - 1 - last_pos + 1;
        }
        max_len = max_len.max(dp[i]);
    }
    max_len as i32
}

fn main() {
    let str = String::from("abcabcbb");
    println!("{}", length_of_longest_substring(str));

    let str = "bbbbb".to_string();
    println!("{}", length_of_longest_substring(str));

    let str = "pwwkew".to_string();
    println!("{}", length_of_longest_substring(str));
}

代码3： 双指针

fn length_of_longest_substring(s: String) -> i32 {
    let s = s.as_bytes();
    let mut last_pos = vec![-1; 256];
    let mut left = 0;
    let mut right = 0;
    let mut max_len = 0;
    while right < s.len() {
        if last_pos[s[right] as usize] < left as i32 {
            last_pos[s[right] as usize] = right as i32;
            right += 1;
            max_len = max_len.max(right - left);
        } else {
            left += 1;
        }
    }
    max_len as i32
}

fn main() {
    let str = String::from("abcabcbb");
    println!("{}", length_of_longest_substring(str));

    let str = "bbbbb".to_string();
    println!("{}", length_of_longest_substring(str));

    let str = "pwwkew".to_string();
    println!("{}", length_of_longest_substring(str));
}

输出：

3
1
3

🌟 每日一练刷题专栏 🌟

✨ 持续，努力奋斗做强刷题搬运工！

👍 点赞，你的认可是我坚持的动力！ 

🌟 收藏，你的青睐是我努力的方向！ 

✎ 评论，你的意见是我进步的财富！  

☸ 主页：https://hannyang.blog.csdn.net/

Rust每日一练 专栏

Golang每日一练 专栏

Python每日一练 专栏

C/C++每日一练 专栏

Java每日一练 专栏

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

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

相关文章

如何在Windows11下开启IE浏览器

如何在Windows11下开启IE浏览器

在Windows11下开启IE浏览器 Microsoft 发布 Windows 11 之后&#xff0c;系统使用基于 Chromium 内核的 Edge 浏览器来代替被人唾骂已久的 IE 浏览器&#xff0c;IE 浏览器入口也已经被屏蔽掉了。通过任何常规方式打开 IE 浏览器都会自动使用 Edge 浏览器打开。 最新消息&…
阅读更多...
语音与语言处理技术交流会（深圳）

语音与语言处理技术交流会（深圳）

嘉宾介绍 嘉宾介绍&#xff1a;罗艺&#xff0c;2021年在美国哥伦比亚大学获得博士学位后加入腾讯AI Lab Shenzhen任高级研究员&#xff0c;研究方向主要为音频前端处理&#xff0c;包括但不限于音频分离、单/多通道语音增强等。 报告题目&#xff1a;腾讯AI Lab音频与语音前端…
阅读更多...
网站备案：阿里云ICP备案服务码是什么？申请流程来了

网站备案：阿里云ICP备案服务码是什么？申请流程来了

阿里云备案服务码是什么&#xff1f;ICP备案服务码怎么获取&#xff1f;阿里云备案服务码分为免费和付费两种&#xff0c;申请备案服务码是有限制条件的&#xff0c;需要你的阿里云账号下有可用于申请备案服务码的云产品&#xff0c;如云服务器、建站产品、虚拟主机等&#xff…
阅读更多...
关于扇区、簇、块、页等概念的区分

关于扇区、簇、块、页等概念的区分

1、什么是扇区和&#xff08;磁盘&#xff09;块&#xff1f; 物理层面&#xff1a;一个磁盘按层次分为 &#xff1a; 磁盘组合 -> 单个磁盘 -> 某一盘面 &#xff08;platter&#xff09;-> 某一磁道 &#xff08;track&#xff09;-> 某一扇区&#xff08;secto…
阅读更多...
未针对内部单位 D 的语言 ZH 定义任何语言特定的单位

未针对内部单位 D 的语言 ZH 定义任何语言特定的单位

在写ABAP程序的时候调用功能函数或者调用BDC的时候会要求输入单位。当我们正常输入单位后调用函数就会报错 提示&#xff1a;未针对内部单位 ** 的语言 ZH 定义任何语言特定的单位。但是我们检查表T006和T006A两个后台表的时候&#xff0c; 发现单位在两个表中都存在&#xff0…
阅读更多...
vue通过sync标识符 在子组件中更便捷的修改父组件的值

vue通过sync标识符 在子组件中更便捷的修改父组件的值

这里 我们创了一个vue2 项目 根组件 App.vue参考代码如下 <template><div><span>{{ name }}</span><text-data :name "name" /></div> </template><script> import textData from "/components/textData&quo…
阅读更多...
python网络爬虫笔记20：批量下载图片并将其转换为pdf文档

python网络爬虫笔记20：批量下载图片并将其转换为pdf文档

对于有些网页，你可以预览所有的页面内容，并且也可以通过F12获取到页面的URL，但是面对动辄几十页的图片，手动下载显然是不可行的。 在这里我们给出一个人机交互的通用解决策略。 第一步：使用F12获取页面所有感兴趣图片的URL 这一步看似简单，其实也暗藏玄机。因为有些网…
阅读更多...
Java的继承与组合

Java的继承与组合

继承可以帮助实现类的复用。 所以&#xff0c;很多开发人员在要复用代码时会自然的使用类的继承的方式。 但是&#xff0c;遇到想要复用的场景就直接使用继承&#xff0c;这样做是不对的。长期大量的使用继承会给代码带来很高的维护成本。 本文将介绍一种可以帮助复用的新的…
阅读更多...
速锐得解码奔驰Actros 系列网关CAN总线应用车载互联微系统

速锐得解码奔驰Actros 系列网关CAN总线应用车载互联微系统

近年来&#xff0c;改变信号处理方式的低成本高速电子电路和制造技术的进步推动了传感技术的发展。借助这些协同领域内的新发展&#xff0c;传感器和制造商可以采用一套全新的方法&#xff0c;如远程自监控和自校准系统智能化&#xff0c;来提高产品的性能。 类似的&#xff0c…
阅读更多...
数据结构与算法lab1-哈工大

数据结构与算法lab1-哈工大

title: 数据结构lab1-一元多项式的代数运算 date: 2023-05-16 11:42:26 tags: 数据结构与算法 git地址&#xff1a;https://github.com/944613709/HIT-Data-Structures-and-Algorithms 哈尔滨工业大学计算机科学与技术学院 实验报告 课程名称&#xff1a;数据结构与算法 课…
阅读更多...
探索iOS之AudioUnit音效框架

探索iOS之AudioUnit音效框架

iOS的AVAudioUnit提供的音效包括&#xff1a;混响、延迟、均衡器、失真、变速、变调等。按照类型划分为Audio Effect和Time Effect&#xff0c;其中Audio Effect包括混响、延迟、均衡器和失真&#xff0c;而Time Effect主要是变速、变调。 一、音效应用层框架 音效的应用层框…
阅读更多...
Kali-linux使用Metasploit基础

Kali-linux使用Metasploit基础

Metasploit是一款开源的安全漏洞检测工具。它可以帮助用户识别安全问题&#xff0c;验证漏洞的缓解措施&#xff0c;并对某些软件进行安全性评估&#xff0c;提供真正的安全风险情报。当用户第一次接触Metasploit渗透测试框架软件&#xff08;MSF&#xff09;时&#xff0c;可能…
阅读更多...
限速神器RateLimiter源码解析 | 京东云技术团队

限速神器RateLimiter源码解析 | 京东云技术团队

作者&#xff1a;京东科技 李玉亮 目录指引 限流场景 软件系统中一般有两种场景会用到限流&#xff1a; •场景一、高并发的用户端场景。 尤其是C端系统&#xff0c;经常面对海量用户请求&#xff0c;如不做限流&#xff0c;遇到瞬间高并发的场景&#xff0c;则可能压垮系统…
阅读更多...
优秀的产品经理需要具备的能力和素质

优秀的产品经理需要具备的能力和素质

1. 适应性强。市场不断发展&#xff0c;用户的需求也在不断变化。如果产品不能满足需求&#xff0c;那就改变路线&#xff1b;如果会议不再有效&#xff0c;取消它&#xff1b;如果你需要更多的帮助&#xff0c;尽管开口。了解沉没成本&#xff0c;并采取措施使产品朝着正确的方…
阅读更多...
Nature Neuroscience：焦虑为何导致“社恐”？李晓明团队揭示相关脑机制

Nature Neuroscience：焦虑为何导致“社恐”？李晓明团队揭示相关脑机制

焦虑是一种常见的负面情绪&#xff0c;也是当今社会的一个热词。在刚刚落幕的《脱口秀大会第五季》中&#xff0c;鸟鸟以一句“躺的时候想卷&#xff0c;卷的时候想躺&#xff0c;永远年轻&#xff0c;永远左右为难&#xff0c;一切都是最不好的安排。”戳中了无数观众的“焦”…
阅读更多...
服务器架构-架构图（三）

服务器架构-架构图（三）

前言 项目不同&#xff0c;架构自然也不同&#xff0c;所以没有唯一的架构&#xff0c;只有合适项目的架构。 这章以休闲类手游为例。 1&#xff1a;架构图 2张差别&#xff0c;就是中间件 用中间件 主要 异步化提升性能、降低耦合度、流量削峰 根据需求选择一种服务器间的消息…
阅读更多...
Sui NFT应用实例：将NFT变成咖啡！

Sui NFT应用实例：将NFT变成咖啡！

近期在台北智慧城市峰会和博览会中&#xff0c;展示了使用NFT购买咖啡的系统。 在2023年3月28–31日举行的台北智慧城市峰会和博览会中&#xff0c;参与者向大家演示了如何使用NFT兑换一杯香醇的咖啡。此系统由Sui基金会、MomentX以及Suia共同创建&#xff0c;演示了如何使用在…
阅读更多...
【牛客网面试必刷TOP101】链表篇（一）

【牛客网面试必刷TOP101】链表篇（一）

【牛客网面试必刷TOP101】链表篇&#xff08;一&#xff09; 前言刷题网站刷题&#xff01;BM1 反转链表思路一&#xff1a;用栈解决思路二&#xff1a;双链表求解思路三&#xff1a;递归解决 总结 BM2 链表内指定区间反转思路一&#xff1a;头插法迭代思路二&#xff1a;递归 …
阅读更多...
几乎涵盖微服务所有操作，阿里2023最新SpringCloudAlibaba实战进阶笔记太强了

几乎涵盖微服务所有操作，阿里2023最新SpringCloudAlibaba实战进阶笔记太强了

近两年&#xff0c;“大厂裁员”总是凭实力冲上各大媒体头条&#xff0c;身在局中的我们早已习以为常。国内的京东&#xff0c;阿里&#xff0c;腾讯&#xff0c;字节&#xff0c;快手&#xff0c;小米等互联网公司都以不同程度的裁员比例向社会输送人才。大量有大厂经验的卷王…
阅读更多...
常用性能指标、性能指标评估及性能测试通过标准

常用性能指标、性能指标评估及性能测试通过标准

一、常用性能指标 1、并发用户数&#xff1a; 指同一时间点对系统进行操作的用户数。准确说为"同时向服务器发送服务请求,给服务器产生压力的用户数量" 并发用户数和注册用户数、在线用户数的概念不同&#xff1a; 并发用户数一定会对服务器产生压力的&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023