leetcode算法刷题记录--7

最新推荐文章于 2024-09-13 16:27:15 发布
最新推荐文章于 2024-09-13 16:27:15 发布
阅读量232 收藏
点赞数 1
文章标签： 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62460336/article/details/140957227
版权

两数之和（leetcode1）

C++

#include <vector>
#include <unordered_map>
using namespace std;

// 两数之和
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> ans;
        // 定义unordered_map存储值和索引
        unordered_map<int,int> tmp;
        for(int i=0;i<nums.size();i++){
            auto it = tmp.find(target - nums[i]);
            if(it != tmp.end()){
                ans.push_back(it->second);
                ans.push_back(i);
                return ans;
            }
            tmp[nums[i]]=i;
        }
        return ans;
    }
};

Python

from typing import List
# 两数之和
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        # 创建一个字典存储数值和对应的下标
        dic = {}
        for i,num in enumerate(nums):
            if (target-num) in dic:
                return [dic[target-num],i]
            dic[num] = i
        return []

买卖股票的最佳时机（leetcode121）

C++

#include <vector>
using namespace std;
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int profit = 0;
        int min_prices = prices[0];
        for(int i=1;i<prices.size();i++){
            profit = max(profit,prices[i]-min_prices);
            min_prices = min(min_prices,prices[i]);
        }
        return profit;
    }
};

Python

from typing import List
# 买卖股票的最佳时机
class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        profit = 0
        min_price = prices[0]
        for i in prices[1:]:
            profit = max(profit,i-min_price)
            min_price = min(min_price, i)
        return profit

有效的括号（leetcode20） 

C++

#include<string>
#include <vector>
using namespace std;
// 有效的括号
class Solution {
public:
    bool isValid(string s) {
        vector<char> stack;
        for (int i=0;i<s.length();i++) {
            if(s[i]==']'){
                if(!stack.empty() && stack.back()=='['){
                    stack.pop_back();
                }else{
                    return false;
                }
            }
            else if(s[i]=='}'){
                if(!stack.empty() && stack.back()=='{'){
                    stack.pop_back();
                }else{
                    return false;
                }
            }
            else if(s[i]==')'){
                if(!stack.empty() && stack.back()=='('){
                    stack.pop_back();
                }else{
                    return false;
                }
            }
            else{
                stack.push_back(s[i]);
            }
        }
        if(stack.empty()) return true;
        return false;
    }
};

Python

# 有效的括号
class Solution:
    def isValid(self, s: str) -> bool:
        # 使用一个列表模拟栈操作
        stack = []
        for i in s:
            # 右括号则匹配
            if i == ")":
                if stack and stack[-1]=="(":
                    del stack[-1]
                else:
                    return False
            elif i == "}":
                if stack and stack[-1]=="{":
                    del stack[-1]
                else:
                    return False
            elif i == "]":
                if stack and stack[-1]=="[":
                    del stack[-1]
                else:
                    return False
            # 左括号则进入栈中
            else:
                stack.append(i)

        if len(stack)==0:
            return True
        return False

合并两个有序数组（leetcode88）

C++

#include <vector>
using namespace std;
// 合并两个有序数组
class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        // muns1无值则将nums2逐个添加到nums1中
        if(m==0){
            for(int i=0;i<n;i++){
                nums1[i] = nums2[i];
            }
        }
        // nums2无值则不做处理
        if(n==0){
            return;
        }
        // 定义i指向nums1当前处理位置，
        int i = m-1;
        // 定义j指向nums2当前处理位置，
        int j = n-1;
        for(int index=0;index<m+n;index++){
            if(i<0 || j<0) break;
            if(nums1[i]>nums2[j]){
                nums1[m+n-1-index] = nums1[i];
                i--;
            }else{
                nums1[m+n-1-index] = nums2[j];
                j--;
            }
        }
        // 如果nums2未处理完，则将nums2中未处理的值填入到nums1中
        while(j>=0){
            nums1[j] = nums2[j];
            j--;
        }
    }
};

Python

from typing import List
# 合并两个有序数组
class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        if m==0:
            for i in range(n):
                nums1[i] = nums2[i]
        if n==0:
            return
        i = m-1
        j = n-1
        for index in range(n+m):
            if i<0 or j<0:
                break
            # 判断将最大值向后填充
            if nums1[i]>nums2[j]:
                nums1[n+m-1-index] = nums1[i]
                i-=1
            else:
                nums1[n + m - 1 - index] = nums2[j]
                j -= 1
        # 如果nums2指针没走完，则将num2余下元素放置到nums1中
        if j>=0:
            for k in range(j+1):
                nums1[k] = nums2[k]
if __name__ == '__main__':
    # nums1 = [1, 2, 3, 0, 0, 0]
    # m = 3
    # nums2 = [2, 5, 6]
    # n = 3
    nums1 = [2,0]
    m = 1
    nums2 =[1]
    n=1
    s = Solution()
    s.merge(nums1,m,nums2,n)
    print(nums1)

LRU缓存（leetcode146）

C++

#include <unordered_map>
using namespace std;
// LRU缓存
struct DiListNode {
    int key;
    int val;
    DiListNode *pre;
    DiListNode *next;

    DiListNode() : key(0), val(0), pre(nullptr), next(nullptr) {}

    DiListNode(int key, int val) : key(key), val(val), pre(nullptr), next(nullptr) {}

    DiListNode(int key, int val, DiListNode *pre, DiListNode *next) : key(key), val(val), pre(pre), next(next) {}
};

class LRUCache {
public:
    // 总容量
    int capacities;
    // 已使用容量
    int used;
    // 虚拟头节点
    DiListNode* dummy;
    // 尾节点
    DiListNode* end;
    // 存储key与节点对应关系的harsh表
    unordered_map<int, DiListNode*> cache;

    LRUCache(int capacity) {
        capacities = capacity;
        used = 0;
        dummy= new DiListNode(-1,0);
        end = nullptr;
    }

    int get(int key) {
        // 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1。
        if(cache.find(key)!=cache.end()){   //存在
            DiListNode *cur = cache.find(key)->second;
            // 将cur移动到链表头后，返回val
            if(cur->pre==dummy) return cur->val;    // 原本在表头则无需移动
            movetohead(cur);
            return cur->val;
        }
        return -1;
    }

    void put(int key, int value) {
        // 如果关键字 key 已经存在，则变更其数据值 value ；
        if(cache.find(key)!=cache.end()){
            // 变更其值
            DiListNode*cur = cache.find(key)->second;
            cur->val = value;
            // 移动到链表头部
            if(cur->pre==dummy) return;
            movetohead(cur);
        } else{     // 如果不存在，则向缓存中插入该组 key-value 。
            if(used==capacities){       // 如果插入操作导致关键字数量超过 capacity ，则应该逐出最久未使用的关键字。
                cache.erase(end->key);
                end->pre->next = nullptr;
                end = end->pre;
                used--;
            }
            DiListNode *cur = new DiListNode(key, value);
            cache[key] = cur;
            cur->next = dummy->next;
            if(used!=0){
                dummy->next->pre = cur;
            }else{
                end = cur;
            }
            cur->pre = dummy;
            dummy->next = cur;
            used++;
        }
    }
    void movetohead(DiListNode* L){
        if(L==end){  // L是尾节点
            end->pre->next = nullptr;
            end = end->pre;
        }else{   //L是中间节点
            L->pre->next = L->next;
            L->next->pre = L->pre;
        }
        L->next = dummy->next;
        dummy->next->pre = L;
        L->pre = dummy;
        dummy->next = L;
    }
};

Python

# LRU缓存
# 定义双向链表用于
class DiLinkList:
    def __init__(self, key=0, val=0, pre=None, next=None):
        self.key = key
        self.val = val
        self.pre = pre
        self.next = next

class LRUCache:

    def __init__(self, capacity: int):
        # 缓存容量
        self.capacity = capacity
        # 已使用容量
        self.used = 0
        # 定义一个字典存储键值对
        self.harsh = {}
        # 定义虚拟头节点
        self.dummy = DiLinkList(-1)     # 取-1作为key
        # 定义链表尾节点
        self.end = None

    def get(self, key: int) -> int:
        if key in self.harsh:
            # 将对应节点移动到表头
            head = self.harsh[key]
            if head.pre==self.dummy:    # 是头节点则无需移动
                return self.harsh.get(key).val
            self.movetohead(head)
            return self.harsh.get(key).val
        return -1

    def put(self, key: int, value: int) -> None:
        # 如果关键词存在则变更其值，如果关键词不存在则插入，如果关键词超量则删除尾节点后在头节点插入
        # 存在
        if key in self.harsh:
            head = self.harsh[key]
            head.val = value
            # 移动到链表头
            if head.pre == self.dummy:  # 是头节点则无需移动
                return
            self.movetohead(head)
        else:
            # 超量先删除尾节点,
            if self.used==self.capacity:
                # 更新链表,删除
                self.harsh.pop(self.end.key)
                self.end.pre.next = None
                self.end = self.end.pre
                self.used -= 1

            # 插入，更新链表
            node = DiLinkList(key,value,self.dummy,self.dummy.next)
            if self.used !=0:   # 不是第一个节点
                self.dummy.next.pre = node
                self.dummy.next = node
            else:
                self.dummy.next = node
                self.end = node    # 是第一个节点

            # 更新harsh表
            self.harsh[key] = node
            # 更新已使用空间
            self.used+=1
    def movetohead(self,head):  # 将某个节点移动到链表头部

        if head.next == None:  # 是尾节点
            self.end = head.pre
            head.pre.next = None
        else:  # 不是尾节点
            head.pre.next = head.next
            head.next.pre = head.pre
        head.next = self.dummy.next
        head.pre = self.dummy
        self.dummy.next.pre = head
        self.dummy.next = head

if __name__ == '__main__':
    lRUCache = LRUCache(2)
    lRUCache.put(2, 1)
    lRUCache.put(1, 1)
    lRUCache.put(2, 3)
    lRUCache.put(4, 1)
    print(lRUCache.get(1))
    print(lRUCache.get(2))
桥呗
关注
leetcode刷题记录(7)-简单
weixin_42733155的博客
07-24 464
1.重复的子字符串 题目：给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。 思路：可以遍历从下标0到长度的一半，如果当前的长度除总长度的余数为0，说明长度可以整除。然后重复这个字符串到总长度，和原字符串相比，如果相等，则满足条件。如果到l/2还没找到相等的，则不满足条件 /** * @param {string} s * @return {boolean} */ var repeatedSubstringPattern
LeetCode刷题记录（四）
记录只为更好地前行
09-27 399
LeetCode刷题记录（四） 1、数组拆分 I 题目： 我的思路： 这一题我的思路分为两步：首先要将这个数组中的元素进行排序，使其成为一个有序数组，然后挑选出其中第奇数个元素，将它们相加的和就是结果。 为什么是第奇数个元素相加呢？根据题目中要求，要选出两两组合中较小的元素相加然后得到最大的总和，所以我们就要使两两组合中较小的那个元素尽量大，因为已经先对这个数组进行了排序，所以这2n个数中值最大...
LeetCode刷题-007-整数反转
sinat_21560581的博客
03-02 434
题目地址 https://leetcode-cn.com/problems/reverse-integer/ 解法 不得不说大佬的解法是真的牛逼，我之前是按照记录位数解的，但是太麻烦，最后发现大佬的位数直接是一位一位的进行*10。 代码 class Solution { public int reverse(int x) { long n = 0; while (x != 0) { n = n * 10 + x % 10;
LeetCode 算法刷题目录 (Java)
热门推荐
代码星辰的博客
01-13 1万+
保存自己的刷题纪录，方便以后复习。
Leetcode刷题总结--基本图算法
qq_41283672的博客
07-13 1651
Leetcode刷题总结 基本图算法 图的问题算是比较复杂的类型的题目了，我觉得需要把握住的有几点。 首先是要学会构建图，如何从题目给你的信息中，抽象出图的关系。 其次是要会表示图，邻接表，邻接矩阵至少要会（特定题目条件下要使用特殊的数据机构） 然后是要会遍历图，DFS, BFS是最基本的算法，很多图的题目都是从遍历而来的。 最后，要回一些特定问题的特定解决方法。图的问题，使用遍历方法，基本都可以得到简单问题的解，但是当数据规模上去以后，这种遍历问题很容易变成NP问题，此时就要考虑使用特定的算法或者思想，达
用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录-Java-下载.zip
09-15
在本压缩包“用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录-Java-下载.zip”中，包含的是一个Java编程项目，主要目的是通过代码实践来理解和掌握数据结构、排序算法以及经典的计算机算法。...
leetcode刷题账号-LeetCode:LeetCode刷题记录(C#)
07-06
这个压缩包文件"LeetCode-master"很可能包含了某个用户在刷题过程中的代码记录或者解决方案。 在刷LeetCode的过程中，有几个关键知识点是值得深入探讨的： 1. **基础数据结构**：在LeetCode的题目中，常见数据结构...
leetcode跳跃-leetcode-golang:leetcode个人刷题记录
06-30
标题 "leetcode跳跃-leetcode-golang:leetcode个人刷题记录" 暗示这是一个关于使用Go语言在LeetCode平台上解决算法问题的项目。LeetCode是一个在线平台，它提供了大量的编程题目，帮助开发者提升算法技能和面试准备...
leetcode下载-leetcode-study:leetcode算法刷题
06-29
最近在准备校招暑期实习，算法题必不可少，所以开一个项目，将一些前端必须要掌握的算法题记录下来。 安装 下载项目后，运行： npm install 安装依赖后，运行： npm test 说明 master 分支存放初始项目环境 code ...
javalruleetcode-Leetcode:Leetcode的刷题记录-Java实现
06-29
在这个名为"javalruleetcode-Leetcode"的项目中，作者专注于使用Java语言解决LeetCode中的问题，并记录下易于理解和最优的解决方案。对于学习和提升Java编程技巧，以及准备面试的人来说，这是一个非常有价值的资源。...
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
qq_61936886的博客
09-12 503
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
算法知识点——常用输入输出数据的方式
5233的博客
09-12 294
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
输出一个三位数
最新发布
2301_77501988的博客
09-13 386
本题要求编写程序，输入一个三位数，输出其个位数字、十位数字和百位数字。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1185
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 320
试除法求约数、约数个数、约数之和、最大公约数
【Hot100】LeetCode—64. 最小路径和
weixin_44382896的博客
09-12 482
64. 最小路径和。
算法练习题24——查找杨辉三角中的组合数
hello77的blogggg 祝你得偿所愿
09-12 586
逐项递推法适合处理较小的数据量，计算较为直观，但当杨辉三角行数较大时，效率较低。 二分查找法利用组合数的单调性，显著提高查找效率，适合处理较大的数据范围。这两种解法在不同场景下都可以使用，二分查找法尤其适合大规模数据下的查找问题。
18068 选择排序
huang1xiao1sheng的博客
09-11 435
输入10个整数，编写一个实现对数组进行选择排序的函数 #include int sort(int a[], int n) { int i,j,k,tmp; for(i=0;i
二分系列(二分查找)9/12
2301_78191305的博客
09-12 969
排序数组->使用二分。第一个位置:>=；第二个位置:=(target+1)-1；所以直接写一个>=的函数。
"详细代码解析：Leetcode刷题记录
在本文中，我将分享我的leetcode刷题记录，包括我在解决每个问题时所使用的代码和思路讲解。这份记录非常详细，旨在帮助其他人更好地理解leetcode题目的解法和编程技巧。 21、TWO SUM 这道题的关键在于要找到数组中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值