算法(第一周)

news2024/11/26 17:48:24

一周周五,总结一下本周的算法学习,从本周开始重新学习许久未见的算法,当然不同于大一时使用的 C 语言以及做过的简单题,现在是每天一题 C++ 和 JavaScript(还在学,目前只写了一题)

题单是代码随想录(JS)和面试 150 题(C++), 括号中是我所用的解题语言。

令我印象最深的不是题目的难度,而是 leecode 的提交方式与我所用过的学校 oj 还有洛谷都不同,它所提交的是核心代码,一开始我都是使用 ai 帮我浓缩成核心代码样式,后面发现其实只需要补充 public 中的函数就可以了…… 我还一直在想 leecode 的输入格式到底是什么样的,话不多说开始总结:

代码随想录
移除链表元素

给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。

示例 1:

输入:head = [1,2,6,3,4,5,6], val = 6
输出:[1,2,3,4,5]

示例 2:

输入:head = [], val = 1
输出:[]

示例 3:

输入:head = [7,7,7,7], val = 7
输出:[]

提示:

  • 列表中的节点数目在范围 [0, 104] 内
  • 1 <= Node.val <= 50
  • 0 <= val <= 50

这题是我觉得比较简单的一道题,复习一下链表知识就好

var removeElements = function (head, val) {
  // 创建一个虚拟头节点
  const dummy = new ListNode(0);
  dummy.next = head;

  let current = dummy; // 从虚拟头节点开始遍历

  while (current.next !== null) {
    if (current.next.val === val) {
      // 跳过当前值等于 val 的节点
      //跳过了,就再也不存在这个地址,相当于删除这个元素
      current.next = current.next.next;
    } else {
      // 否则,继续移动到下一个节点
      current = current.next;
    }
  }

  // 返回新的头节点
  return dummy.next;
};

// 定义链表节点的结构
class ListNode {
  constructor(val = 0, next = null) {
    this.val = val;
    this.next = next;
  }
}

   

面试 150
多数元素

给定一个大小为 n 的数组 nums ,返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的,并且给定的数组总是存在多数元素。

示例 1:

输入:nums = [3,2,3]
输出:3

示例 2:

输入:nums = [2,2,1,1,1,2,2]
输出:2

提示:

  • n == nums.length
  • 1 <= n <= 5 * 104
  • -109 <= nums[i] <= 109

进阶:尝试设计时间复杂度为 O (n)、空间复杂度为 O (1) 的算法解决此问题。

这题看上去很难,想明白了就很简单,简单来说是要找到出现最多的那个元素,但是要想明白怎么找最省力:我们假设找出一种生物,用一个计数器为 0,当这个生物遇到同类 + 1,遇到其他生物就会 - 1,当 cnt 为 0 时,说明这个生物数量不够,自然就 dead 了,以此类推,如果走到最后这个生物的数量没有为 0,则证明它是最多的一类,如果前面都不存在这种生物,那留在最后的自然而然就是最多的

class Solution {
public:
          int majorityElement(vector<int>& nums) {
        int temp;
        int cnt = 0;
            for(int i = 0; i < nums.size();i++){
                if(cnt  == 0)
                temp = nums[i];

                cnt+= (nums[i] == temp) ? +1 : -1;
            }
        return temp;
    }
};

   

合并两个有序数组

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2,另有两个整数 m 和 n ,分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中,使合并后的数组同样按 非递减顺序 排列。

注意:最终,合并后数组不应由函数返回,而是存储在数组 nums1 中。为了应对这种情况,nums1 的初始长度为 m + n,其中前 m 个元素表示应合并的元素,后 n 个元素为 0 ,应忽略。nums2 的长度为 n 。

示例 1:

输入:nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出:[1,2,2,3,5,6]
解释:需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ,其中斜体加粗标注的为 nums1 中的元素。

示例 2:

输入:nums1 = [1], m = 1, nums2 = [], n = 0
输出:[1]
解释:需要合并 [1] 和 [] 。
合并结果是 [1] 。

示例 3:

输入:nums1 = [0], m = 0, nums2 = [1], n = 1
输出:[1]
解释:需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意,因为 m = 0 ,所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

提示:

  • nums1.length == m + n
  • nums2.length == n
  • 0 <= m, n <= 200
  • 1 <= m + n <= 200
  • -109 <= nums1[i], nums2[j] <= 109

这题也简单,只需要从后往前查找,比较 nums1 和 nums2 的大小,如果 nums1 大于 nums2 就往后放,反之就往前放,如果有多,nums1 未放完的自然都在前面,nums2 潍坊玩的只需要接着仿就行

#include <vector>
using namespace std;

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int i = m - 1; // nums1 的有效元素索引
        int j = n - 1; // nums2 的有效元素索引
        int k = m + n - 1; // 合并后数组的最后一个索引

        // 从数组的最后一位开始查找
        while (i >= 0 && j >= 0) {
            if (nums1[i] > nums2[j]) {
                // 将较大的放到合并数组的末尾
                nums1[k] = nums1[i];
                i--;
            } else {
                nums1[k] = nums2[j];
                j--;
            }
            k--;
        }

        // 将 nums2 剩余的元素复制到 nums1 中
        while (j >= 0) {
            nums1[k] = nums2[j];
            j--;
            k--;
        }
        // nums1 的剩余元素不需要复制,因为它们已经在正确的位置上
    }
};

   

罗马数字转整数

罗马数字包含以下七种字符: I, V, X, LCD 和 M

字符          数值
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

例如, 罗马数字 2 写做 II ,即为两个并列的 1 。12 写做 XII ,即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。

通常情况下,罗马数字中小的数字在大的数字的右边。但也存在特例,例如 4 不写做 IIII,而是 IV。数字 1 在数字 5 的左边,所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地,数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况:

  • I 可以放在 V (5) 和 X (10) 的左边,来表示 4 和 9。
  • X 可以放在 L (50) 和 C (100) 的左边,来表示 40 和 90。 
  • C 可以放在 D (500) 和 M (1000) 的左边,来表示 400 和 900。

给定一个罗马数字,将其转换成整数。

示例 1:

输入: s = "III"
输出: 3

示例 2:

输入: s = "IV"
输出: 4

示例 3:

输入: s = "IX"
输出: 9

示例 4:

输入: s = "LVIII"
输出: 58
解释: L = 50, V= 5, III = 3.

示例 5:

输入: s = "MCMXCIV"
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.

提示:

  • 1 <= s.length <= 15
  • s 仅含字符 ('I', 'V', 'X', 'L', 'C', 'D', 'M')
  • 题目数据保证 s 是一个有效的罗马数字,且表示整数在范围 [1, 3999] 内
  • 题目所给测试用例皆符合罗马数字书写规则,不会出现跨位等情况。
  • IL 和 IM 这样的例子并不符合题目要求,49 应该写作 XLIX,999 应该写作 CMXCIX 。
  • 关于罗马数字的详尽书写规则,可以参考 罗马数字 – 百度百科。

这题需要学习一下关于 unordered_map,这里简单讲一下就是他可以存放名字+value,这样方便查找数字。思路是使用 for 循环遍历,使用 current 存储当前字母的数字,再用 next 去判断是否存在下一数字,只要存在就存入下一个字符的数字,不存在就入 0;然后进行比较,如果当前数字小于下一数字就减去当前数字,否则就加上当前数字,相等也要加上当前数字(IIII 这种情况),最后直接返回就行

class Solution {
public:
    int romanToInt(string s) {
         // 罗马数字字符与整数的映射
    unordered_map<char, int> romanMap = {
        {'I', 1}, {'V', 5}, {'X', 10}, {'L', 50},
        {'C', 100}, {'D', 500}, {'M', 1000}
    };

    int total = 0;
    int n = s.length();

    for (int i = 0; i < n; ++i) {
        // 获取当前字符和下一个字符的数字
        int current = romanMap[s[i]];
        int next = (i + 1 < n) ? romanMap[s[i + 1]] : 0;

        // 如果当前数字小于下一个数字,执行减法
        if (current < next) {
            total -= current;
        } else {
            // 否则,执行加法
            total += current;
        }
    }

    return total;
    }
};

   

买卖股票的最佳时机

给定一个数组 prices ,它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票,并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润,返回 0 。

示例 1:

输入:[7,1,5,3,6,4]
输出:5
解释:在第 2 天(股票价格 = 1)的时候买入,在第 5 天(股票价格 = 6)的时候卖出,最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格;同时,你不能在买入前卖出股票。

示例 2:

输入:prices = [7,6,4,3,1]
输出:0
解释:在这种情况下, 没有交易完成, 所以最大利润为 0。

提示:

  • 1 <= prices.length <= 105
  • 0 <= prices[i] <= 104

这题假设第一天是最低买入价格,将最大利润设置成 0(不能为负,不然不是利润),遍历数组,持续更新最低买入价格,要是比这个最低价格高就说明可能会存在最大利润,使用 max 函数比较最大利润(用当前价钱减去最低价格)

class Solution {
public:
   
 
 int maxProfit(vector<int>& prices) {
    if (prices.empty()) return 0;  // 防止空数组访问

    int minPrice = prices[0];  // 最低买入价格
    int maxProfit = 0;         // 最大利润

    for (int i = 1; i < prices.size(); i++) {
        if (prices[i] < minPrice) {
            minPrice = prices[i];  // 更新最低买入价格
        } else {
            maxProfit = max(maxProfit, prices[i] - minPrice);  // 计算当前利润
        }
    }

    return maxProfit;
}

};

   

删除有序数组中的重复项

给你一个 非严格递增排列 的数组 nums ,请你 原地 删除重复出现的元素,使每个元素 只出现一次 ,返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ,你需要做以下事情确保你的题解可以被通过:

  • 更改数组 nums ,使 nums 的前 k 个元素包含唯一元素,并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
  • 返回 k 。

判题标准:

系统会用下面的代码来测试你的题解:

int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案

int k = removeDuplicates(nums); // 调用

assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
    assert nums[i] == expectedNums[i];
}

如果所有断言都通过,那么您的题解将被 通过

示例 1:

输入:nums = [1,1,2]
输出:2, nums = [1,2,_]
解释:函数应该返回新的长度 2 ,并且原数组 nums 的前两个元素被修改为 1, 2 

不需要考虑数组中超出新长度后面的元素。

   

示例 2:

输入:nums = [0,0,1,1,1,2,2,3,3,4]
输出:5, nums = [0,1,2,3,4]
解释:函数应该返回新的长度 5 , 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

提示:

  • 1 <= nums.length <= 3 * 104
  • -104 <= nums[i] <= 104
  • nums 已按 非严格递增 排列

这题开始时我没想清楚从前开始算,这个比较应该是后一位与前一位比较,如果不相同,就将该元素赋值到一个新数组,再 cnt++,cnt 就是新数组长度(新数组是在原数组基础上添加,如果不相同那么添加的位置与原位置也相同,如果元素相同则删除一个元素,不管怎么样在原数组基础上增删都不会超过原数组长度,而且节省了空间)

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if (nums.empty()) return 0;  // 如果数组为空,返回 0

        int count = 1;  // count 用来追踪唯一元素的个数

        for (int i = 1; i < nums.size(); i++) {
            if (nums[i] != nums[i - 1]) {  // 如果当前元素和前一个不同
                nums[count++] = nums[i];   // 将当前元素移动到不重复部分的末尾
            }
        }

        return count;  // 返回不重复元素的个数
    }
};

   

移除元素

给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

假设 nums 中不等于 val 的元素数量为 k,要通过此题,您需要执行以下操作:

  • 更改 nums 数组,使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
  • 返回 k

用户评测:

评测机将使用以下代码测试您的解决方案:

int[] nums = [...]; // 输入数组
int val = ...; // 要移除的值
int[] expectedNums = [...]; // 长度正确的预期答案。
                            // 它以不等于 val 的值排序。

int k = removeElement(nums, val); // 调用你的实现

assert k == expectedNums.length;
sort(nums, 0, k); // 排序 nums 的前 k 个元素
for (int i = 0; i < actualLength; i++) {
    assert nums[i] == expectedNums[i];
}

如果所有的断言都通过,你的解决方案将会 通过

示例 1:

输入:nums = [3,2,2,3], val = 3
输出:2, nums = [2,2,_,_]
解释:你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
你在返回的 k 个元素之外留下了什么并不重要(因此它们并不计入评测)。

示例 2:

输入:nums = [0,1,2,2,3,0,4,2], val = 2
输出:5, nums = [0,1,4,0,3,_,_,_]
解释:你的函数应该返回 k = 5,并且 nums 中的前五个元素为 0,0,1,3,4。
注意这五个元素可以任意顺序返回。
你在返回的 k 个元素之外留下了什么并不重要(因此它们并不计入评测)。

提示:

  • 0 <= nums.length <= 100
  • 0 <= nums[i] <= 50
  • 0 <= val <= 100

与代码随想录题目相同,从 js 改成了 c++

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int newLength = 0;  // 用于记录新数组的有效长度
        
        // 遍历 nums 数组
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] != val) {
                nums[newLength] = nums[i];  // 将非 val 元素放到前面
                newLength++;  // 更新新数组的长度
            }
        }
        return newLength;  // 返回新数组的长度
    }
};

   

本周题解就到这里结束,下周见。

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

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

相关文章

华为云镜像仓库基本操作

1. 登陆华为云账户,在搜索框输入"镜像容器",如下图所示: 单击 输入名称后单击确定 创建成功 2. 回到这里 单击这里 获得登陆指令 复制到你的云服务器粘贴,回车后提示"Login Succeeded"表示登陆成功. 3. 还是在"总览"这里,单击这里 跟着复制操作…

【1个月速成Java】基于Android平台开发个人记账app学习日记——第10天,登录状态保持与退出登录

系列专栏链接如下&#xff0c;方便跟进&#xff1a; https://blog.csdn.net/weixin_62588253/category_12821860.html?fromshareblogcolumn&sharetypeblogcolumn&sharerId12821860&sharereferPC&sharesourceweixin_62588253&sharefromfrom_linkhttps://b…

MySQL系列之如何在Linux只安装客户端

导览 前言Q&#xff1a;如何安装一个Linux环境下的MySQL客户端一、准备文件1. 确认Server版本2. 选择Client安装文件 二、下载并安装1. 下载1.1 寻找文件1.2 文件说明 2. 安装2.1 上传至Linux服务器2.2 执行安装 三、连接验证1. 确认远程授权2. 建立远程连接 结语精彩回放 前言…

arcgis pro 学习笔记

二维三维集合在一起&#xff0c;与arcgis不同 一、首次使用&#xff0c;几个基本设置 1.选项——常规里面设置自动保存时间 2.新建工程文件&#xff0c;会自动加载地图&#xff0c;可以在选项里面设置为无&#xff0c;以提高启动效率。 3.设置缓存位置&#xff0c;可勾选每次…

【论文复现】MSA+抑郁症模型总结(三)

&#x1f4dd;个人主页&#x1f339;&#xff1a;Eternity._ &#x1f339;&#x1f339;期待您的关注 &#x1f339;&#x1f339; ❀MSA抑郁症模型 热门研究领域&#xff1a;情感计算的横向发展1. 概述2. 论文地址3. 研究背景4. 主要贡献5. 模型结构和代码6. 数据集介绍7. 性…

‌STAR法则

一&#xff1a;STAR法则 STAR法则是一种简单而实用的表现技巧&#xff0c;常被用于求职过程中的个人经历描述&#xff0c;富有条理性&#xff0c;可以帮助你在职场中脱颖而出。“STAR”分别对应的是situation-task-action-result&#xff0c;通过情境、目标、行动和结果四个方面…

java:使用Multi-Release Jar改造Java 1.7项目增加module-info.class以全面合规Java 9模块化规范

common-java是一个我维护了好多年的一个基础项目,编译目标为Java 1.7 现在整个团队的项目要做Java 9以上的技术迁移准备,就需要对这个在内部各项目中被广泛引用的基础项目进行改造,以适合Java 9的模块化规范。 Automatic-Module-Name Java 9的模块化规范(即Java Platform Mod…

力扣题库——75.颜色分类

这道题采用三路快速排序&#xff0c;快速排序思路看这里快速排序。将数列分为三组&#xff1a;小于基准、等于基准、大于基准。和快排一样&#xff0c;对左右递归进行快速排序。 先将题目简化&#xff0c;如果只有数字0和1&#xff0c;扫描一遍数组&#xff0c;遇到数字1不用管…

python - leetcode【数据结构-算法】-入门/通关手册

python的算法入门/通关/手册 前言&#xff1a;算法通关手册&#xff08;LeetCode&#xff09;-githubHello 算法&#xff1a;python数据结构和算法 - 中文版The Algorithms - Python最后刷题思维: python-leetcode刷题常用语法&#xff1a;变量定义&#xff1a;逻辑与或非和按位…

使用 Flask 和 ONLYOFFICE 实现文档在线编辑功能

提示&#xff1a;CSDN 博主测评ONLYOFFICE 文章目录 引言技术栈环境准备安装 ONLYOFFICE 文档服务器获取 API 密钥安装 Flask 和 Requests 创建 Flask 应用项目结构编写 app.py创建模板 templates/index.html 运行应用功能详解文档上传生成编辑器 URL显示编辑器回调处理 安全性…

EasyUI弹出框行编辑,通过下拉框实现内容联动

EasyUI弹出框行编辑&#xff0c;通过下拉框实现内容联动 需求 实现用户支付方式配置&#xff0c;当弹出框加载出来的时候&#xff0c;显示用户现有的支付方式&#xff0c;datagrid的第一列为conbobox,下来选择之后实现后面的数据直接填充&#xff1b; 点击新增&#xff1a;新…

C# 选择导入文件的路径、导出文件的路径

通过C#代码&#xff0c;调出windows风格的文件选择对话框和存储文件对话框。提供界面来选择文件的位置&#xff0c;并将完整路径以字符串形式返回。 1、选择导入文件&#xff0c;获取其路径 C#通过这段代码将弹出一个文件选择对话框&#xff0c;允许用户选择一个文件&#xff…

数据结构-并查集专题(1)

一、前言 因为要开始准备年底的校赛和明年年初的ACM、蓝桥杯、天梯赛&#xff0c;于是开始按专题梳理一下对应的知识点&#xff0c;先从简单入门又值得记录的内容开始&#xff0c;并查集首当其冲。 二、我的模板 虽然说是借用了jiangly鸽鸽的板子&#xff0c;但是自己也小做…

二手交易平台测试用例设计和执行

&#x1f384;欢迎来到边境矢梦的csdn博文&#x1f384; &#x1f384;追求开源思想和学无止境思想一直在提升技术的路上 &#x1f384; &#x1f308;涉及的领域有&#xff1a;Java、Python、微服务架构和分布式架构思想、基本算法编程&#x1f308; &#x1f386;喜欢的朋友可…

计算机图形学论文 | 多边形中的点可见性快速算法

&#x1f98c;&#x1f98c;&#x1f98c;读论文 &#x1f428;&#x1f428;摘要 针对点的可见性计算这一计算几何中的基础问题&#xff0c;提出一种支持任意查询点的可见多边形快速计算的基于多边形Voronoi图的点可见性算法。以与Voronoi骨架路径对应的Voronoi通道概念&…

Redis 高并发分布式锁实战

目录 环境准备 一 . Redis 安装 二&#xff1a;Spring boot 项目准备 三&#xff1a;nginx 安装 四&#xff1a;Jmeter 下载和配置 案例实战 优化一&#xff1a;加 synchronized 锁 优化二&#xff1a;使用 redis 的 setnx 实现分布式锁 优化三&#xff1a;使用 Lua 脚本…

LLM大模型学习精华系列:VLLM性能优化部署实践——全面加速从推理到部署的流程

训练后的模型会用于推理或者部署。推理即使用模型用输入获得输出的过程&#xff0c;部署是将模型发布到恒定运行的环境中推理的过程。一般来说&#xff0c;LLM的推理可以直接使用PyTorch代码、使用[VLLM]等框架&#xff0c;也可以使用[llama.cpp]等c推理框架。 常见推理方法 G…

【大数据学习 | kafka高级部分】kafka的快速读写

1. 追加写 根据以上的部分我们发现存储的方式比较有规划是对于后续查询非常便捷的&#xff0c;但是这样存储是不是会更加消耗存储性能呢&#xff1f; 其实kafka的数据存储是追加形式的&#xff0c;也就是数据在存储到文件中的时候是以追加方式拼接到文件末尾的&#xff0c;这…

SpringCloud篇(微服务)

目录 一、认识微服务 1. 单体架构 2. 分布式架构 3. 微服务 3.1. 特点 3.2. 优点 3.3 缺点 二、微服务设计、拆分原则 1. AKF 拆分原则 2. Y轴&#xff08;功能&#xff09;关注应用中功能划分&#xff0c;基于不同的业务拆分 3. X轴&#xff08;水平扩展&#xff09…

Hive简介 | 体系结构

Hive简介 Hive 是一个框架&#xff0c;可以通过编写sql的方式&#xff0c;自动的编译为MR任务的一个工具。 在这个世界上&#xff0c;会写SQL的人远远大于会写java代码的人&#xff0c;所以假如可以将MR通过sql实现&#xff0c;这个将是一个巨大的市场&#xff0c;FaceBook就这…