算法复盘——LeetCode hot100:哈希

已于 2024-08-31 15:17:59 修改
阅读量1.1k 收藏 22
点赞数 7
分类专栏： LeetCode解析 文章标签： 哈希算法 算法 leetcode
于 2024-08-31 15:12:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79579651/article/details/141751427
版权

文章目录

哈希表

先来搞清楚什么是哈希表吧~ 概念不清楚方法不清楚怎么做题捏

哈希表（Hash Table），也被称为散列表，是一种使用哈希函数组织数据，以支持快速插入和搜索的数据结构。它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数称为哈希函数，存放记录的数组称为哈希表。

哈希表的基本概念

  1. 哈希函数（Hash Function）：
    哈希函数是一个将任意长度的输入（通常称为“关键码”或“键”）通过某种算法变换成固定长度的输出（通常是一个整数）的函数。理想的哈希函数应该能够均匀地、随机地将输入映射到输出范围上，以减少哈希冲突。
  2. 哈希表（Hash Table）：
    哈希表是一种数据结构，用于存储键值对（key-value pairs）。它通过哈希函数将键映射到表中的一个位置来存储和访问数据。哈希表可以快速地插入、删除和查找数据项，时间复杂度通常接近O(1)。
  3. 哈希冲突（Hash Collision）：
    由于哈希函数的输出范围有限，而输入范围是无限的，因此有可能出现两个或多个不同的输入映射到哈希表的同一位置的情况，这就是哈希冲突。处理哈希冲突的方法有多种，如开放寻址法（open addressing）和链地址法（chaining）。

哈希表的使用

1. 插入操作
  • 计算哈希值：使用哈希函数对键进行哈希运算，得到哈希值。
  • 处理哈希冲突：如果哈希值对应的位置已经被占用，则根据采用的冲突解决策略（如链地址法中的链表插入，或开放寻址法中的线性探测等）来处理冲突。
  • 存储键值对：将键值对存储在哈希表中计算出的位置。
2. 查找操作
  • 计算哈希值：与插入操作相同，首先使用哈希函数计算键的哈希值。
  • 处理哈希冲突：如果哈希值对应的位置有多个键值对（如链地址法中的链表），则遍历这些键值对，直到找到匹配的键或遍历完所有键值对。
  • 返回结果：如果找到匹配的键，则返回对应的值；否则，返回未找到。
3. 删除操作
  • 计算哈希值：与插入和查找操作相同，首先计算键的哈希值。
  • 处理哈希冲突：根据哈希值找到对应的位置，然后按照哈希表的冲突解决策略找到具体的键值对。
  • 删除键值对：从哈希表中删除找到的键值对。

哈希表的优点和缺点

优点：

  • 查找效率高：在理想情况下，哈希表的查找、插入和删除操作的时间复杂度都接近O(1)。
  • 空间效率高：相对于其他数据结构，哈希表通常能以较小的空间存储相同数量的元素。

缺点：

  • 哈希冲突：哈希冲突是哈希表的一个固有问题，它可能导致查找、插入和删除操作的时间复杂度增加。
  • 对哈希函数的依赖：哈希表的性能高度依赖于哈希函数的质量。一个设计不好的哈希函数可能导致哈希冲突频繁发生，从而降低哈希表的性能。
  • 动态扩容：当哈希表中的元素数量超过一定阈值时，需要动态扩容以维持良好的性能。扩容操作通常比较耗时，并可能导致重新计算所有元素的哈希值。

在这里插入图片描述

1.两数之和

1. 两数之和

  • 暴力解法直接开敲

    …解法略

  • 使用哈希表

class Solution {
    public int[] twoSum(int[] nums, int target) {
        // 维护 val -> index 的映射
        HashMap<Integer, Integer> valToIndex = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            // 查表，看看是否有能和 nums[i] 凑出 target 的元素
            int need = target - nums[i];
            if (valToIndex.containsKey(need)) {
                return new int[]{valToIndex.get(need), i};
            }
            // 存入 val -> index 的映射
            valToIndex.put(nums[i], i);
        }
        return null;
    }
}

复盘

关键点

  • 哪个是键，哪个是值

在这个twoSum方法中，HashMap<Integer, Integer>的valToIndex用于存储数组中元素的值（nums[i]）到其索引（i）的映射。这里，键（Key）是数组中的元素值（Integer类型），而值（Value）是该元素值在数组中的索引（也是Integer类型）。

  • 为什么这样放？

效率：使用哈希表（HashMap）来存储这种映射关系可以极大地提高查找效率。在遍历数组时，对于每个元素，我们都可以立即通过哈希表检查是否存在一个与之相加等于目标值target的另一个元素。如果存在，我们可以立即返回这两个元素的索引，而不需要继续遍历数组。

  1. 空间换时间：虽然这种方法使用了额外的空间来存储映射关系，但它显著减少了时间复杂度。如果不使用哈希表，我们可能需要使用两层循环来遍历数组，寻找满足条件的两个数，这会导致时间复杂度为O(n^2)。而使用哈希表后，时间复杂度可以降低到O(n)。
  2. 方便性：将值作为键，索引作为值，使得在找到满足条件的值时，我们可以直接通过哈希表获取到该值在数组中的索引，从而方便地构造出结果数组。

示例

假设我们有数组nums = [2, 7, 11, 15]和目标值target = 9。

  • 当遍历到nums[0] = 2时，我们计算need = 9 - 2 = 7，然后检查哈希表中是否包含键7。此时不包含，所以我们将2和它的索引0存入哈希表。
  • 当遍历到nums[1] = 7时，我们计算need = 9 - 7 = 2，然后检查哈希表，发现已经存在键2，对应的值为0。这意味着我们找到了两个数2和7，它们的索引分别是0和1，它们的和等于target。因此，我们可以立即返回结果[0, 1]。

通过这种方式，我们可以高效地解决“两数之和”问题。

  • 不能反过来设计键值对

在解决“两数之和”问题时，你不能简单地将索引作为键（Key）和数组中的值（Value）作为值（Value）在哈希表中反过来放，即不能创建HashMap<Integer, Integer>其中键是索引，值是数组中的元素值。这样做的主要原因是它不符合我们查找两个数使它们之和等于目标值的需求。

如果我们尝试将索引作为键，数组中的值作为值来存储，那么在遍历数组时，我们将无法有效地利用哈希表来快速查找是否存在与当前元素相加等于目标值的另一个元素。因为此时，哈希表并不能直接告诉我们哪个元素的值与当前元素相加等于目标值，而只能告诉我们某个值在数组中的位置。

然而，我们真正需要的是一种方式来快速查找是否存在一个数，它与当前遍历到的数相加等于目标值。这正是通过将数组中的值作为键，并将该值在数组中的索引作为值存储在哈希表中来实现的。这样，当我们遍历数组时，我们可以立即检查哈希表中是否存在一个与target - 当前值相等的键，如果存在，则说明我们找到了两个数，它们的和等于目标值。

因此，正确的做法是将数组中的值作为键（Key），并将该值在数组中的索引作为值（Value）存储在哈希表中，以便在遍历数组时能够快速查找和匹配。

  • 哈希表中的健是无序的吗?

哈希表中的键（Key）在大多数实现中是无序的。这种无序性主要源于哈希表的工作原理。

在Java中，HashMap是一个典型的无序哈希表实现，而LinkedHashMap和TreeMap则提供了有序的哈希表实现。其中，LinkedHashMap按照插入顺序或访问顺序来维护键的顺序，而TreeMap则按照键的自然顺序或构造时提供的Comparator进行排序。这些有序哈希表实现为需要在保持键顺序的同时进行快速查找、插入和删除操作的应用场景提供了有力的支持。

242.有效的字母异位词

242. 有效的字母异位词

复盘

  • 快速定位字符串中的字母
  • 定义一个数组叫做record用来上记录字符串s里字符出现的次数

需要把字符映射到数组也就是哈希表的索引下标上，因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。

再遍历 字符串s的时候，只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。 这样就将字符串s中字符出现的次数，统计出来了。

那看一下如何检查字符串t中是否出现了这些字符，同样在遍历字符串t的时候，对t中出现的字符映射哈希表索引上的数值再做-1的操作。

那么最后检查一下，record数组如果有的元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符，return false。

  • 空间换时间
  • 错误记录：
    方法中一定要有对应的返回值，不要缺失返回语句

正确答案

class Solution {
    public boolean isAnagram(String s, String t) {
        int[] num = new int[26];
        if(s.length() != t.length()) return false;
        for(int i = 0;i < s.length(); i++){
                num[s.charAt(i) - 'a'] ++;
        }
        for(int j = 0;j < t.length();j++){
                num[t.charAt(j)-'a'] --; 
                if(num[t.charAt(j)-'a'] < 0){
                    return false;}
        }
        return true;
    }
}

优化思路

  • 先判断长度是否相等，不相等则直接false
  • 记录字符出现的次数
  • 记录数=-1时直接返回false

其他解法

  • 排序
    t 是 s 的异位词等价于「两个字符串排序后相等」。因此我们可以对字符串 s 和 t 分别排序，看排序后的字符串是否相等即可判断。此外，如果 s 和 t 的长度不同，t 必然不是 s 的异位词。
class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        char[] str1 = s.toCharArray();
        char[] str2 = t.toCharArray();
        Arrays.sort(str1);
        Arrays.sort(str2);
        return Arrays.equals(str1, str2);
    }
}

49.字母异位词分组

49. 字母异位词分组 - 力扣（LeetCode）

在这里插入图片描述

  • 每个排序后的字符串作为key，value为字符串数组的形式
  • 最后遍历哈希表，输出value

复盘

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        HashMap<String,List<String>> hashMap = new HashMap<>();
        for(String s :strs){
            char[] tmp = s.toCharArray();
            Arrays.sort(tmp);
            String key  = new String(tmp);
            if(!hashMap.containsKey(key)){
                hashMap.put(key,new ArrayList());
            }
            hashMap.get(key).add(s);
        }
        return new ArrayList(hashMap.values());
        }
        }

注意细节:

  • 对于数组（如int[] nums），使用nums.length来访问长度。
  • 对于字符串（如String str），使用str.length()来调用方法获取长度（尽管它看起来像属性访问，但实际上是一个方法调用）。

错误复盘 细节大错特错，直接哭哭

  • 错误分析（错了好哇，错了好，错误能让人更快进步（其实很奔溃…））

  1. 错误的方法调用和属性访问

    • Array.sort(tmp); 应该是 Arrays.sort(tmp);。注意是 Arrays 而不是 Array，且是 sort 而不是 Sort。
    • hashMap.containKey(key) 应该是 hashMap.containsKey(key)。注意是 containsKey 而不是 containKey。
    • hashMap.putKey(key,new ArrayList[]); 和 hashMap.getKey(key).add(s); 都是错误的。正确的方法是 hashMap.put(key, new ArrayList<String>()) 和 hashMap.get(key).add(s)。

  2. 类型声明错误

    • new ArrayList[] 是不合法的。应该使用 new ArrayList<String>() 来创建一个新的 ArrayList 实例。

  3. 逻辑错误

    • 最后的 for(new ArrayList[] m: hashMap) {...} 循环完全不正确。hashMap 是一个 HashMap，而不是 ArrayList 数组。您可能想遍历 hashMap.values() 集合，但在这个上下文中，您并不需要这个循环，因为您只是要返回整个 HashMap 的值。
    • return hashMap.getValues(); 应该是 return new ArrayList<>(hashMap.values());。但在这个上下文中，您应该直接返回 hashMap.values() 的一个列表表示，但请注意 values() 返回的是 Collection<List<String>>，所以您可能需要将其转换为 List<List<String>>。

反思：基础不扎实 什么是ArrayList 我竟然搞不清

是 Java 中的一个类，它属于 Java 集合框架（Java Collections Framework）的一部分。ArrayList 是一个基于动态数组实现的列表（List），它可以包含重复的元素，并且允许根据索引快速访问、插入和删除元素。

  • 主要特点
  1. 动态数组：ArrayList 内部使用一个动态增长的数组来存储元素。当元素数量超过当前数组容量时，ArrayList 会自动创建一个更大的数组，并将旧数组中的元素复制到新数组中，以便能够继续添加更多元素。
  2. 有序集合：ArrayList 维护了元素的插入顺序，即元素是按照它们被添加到列表中的顺序存储的。
  3. 允许重复元素：与 HashSet 不同，ArrayList 允许存储重复的元素。
  4. 非同步：ArrayList 不是同步的。如果多个线程同时访问一个 ArrayList 实例，并且至少有一个线程从结构上修改了列表，那么它必须保持外部同步。
  5. 随机访问：ArrayList 提供了对列表中元素的随机访问，即可以通过索引直接访问任何位置的元素，这使得 ArrayList 在需要频繁访问列表元素时非常高效。
  • 常用方法
  • boolean add(E e): 将指定的元素添加到此列表的末尾。
  • E remove(int index): 移除此列表中指定位置上的元素。
  • E get(int index): 返回列表中指定位置的元素。
  • int size(): 返回列表中的元素数。
  • void clear(): 移除此列表中的所有元素。
  • boolean contains(Object o): 如果此列表包含指定的元素，则返回 true。
  • 示例
import java.util.ArrayList;  
  
public class Main {  
    public static void main(String[] args) {  
        ArrayList<String> list = new ArrayList<>();  
          
        // 添加元素  
        list.add("Apple");  
        list.add("Banana");  
        list.add("Cherry");  
          
        // 访问元素  
        System.out.println(list.get(1)); // 输出: Banana  
          
        // 移除元素  
        list.remove(0); // 移除索引为0的元素，即"Apple"  
          
        // 遍历列表  
        for (String fruit : list) {  
            System.out.println(fruit);  
        }  
          
        // 获取列表大小  
        System.out.println(list.size()); // 输出: 2  
    }  
}

128. 最长连续序列

128. 最长连续序列 - 力扣（LeetCode）

复盘

  • 要求时间复杂度为 O(n)

整数数组的排序时间复杂度取决于所使用的排序算法。不同的排序算法具有不同的时间复杂度，这主要取决于数组的大小（n）以及数组的初始状态（例如，是否已部分排序）。以下是一些常见排序算法及其时间复杂度的概述：

  1. 冒泡排序（Bubble Sort）
    • 平均时间复杂度：O(n^2)
    • 最坏时间复杂度：O(n^2)
    • 最好时间复杂度：O(n)（当数组已经是有序的时）
  2. 选择排序（Selection Sort）
    • 平均时间复杂度：O(n^2)
    • 最坏时间复杂度：O(n^2)
    • 最好时间复杂度：O(n^2)（与数组初始状态无关）
  3. 插入排序（Insertion Sort）
    • 平均时间复杂度：O(n^2)
    • 最坏时间复杂度：O(n^2)
    • 最好时间复杂度：O(n)（当数组已经是有序的时）
    • 插入排序对于小数组或部分有序的大数组表现良好。
  4. 希尔排序（Shell Sort）
    • 平均时间复杂度：取决于间隙序列，但通常认为是O(nlog2n)到O(n2)之间
    • 希尔排序是插入排序的一种更高效的改进版本，通过允许交换距离较远的元素来工作。
  5. 快速排序（Quick Sort）
    • 平均时间复杂度：O(nlogn)
    • 最坏时间复杂度：O(n^2)（但在实际应用中，通过随机化或三数取中法等方法可以大大降低出现最坏情况的可能性）
    • 快速排序是一种分治算法，通常被认为是实际应用中性能最好的排序算法之一。
  6. 归并排序（Merge Sort）
    • 平均时间复杂度：O(nlogn)
    • 最坏时间复杂度：O(nlogn)
    • 归并排序也是一种分治算法，它将数组分成两半，递归地对它们进行排序，然后将结果合并在一起。
  7. 堆排序（Heap Sort）
    • 平均时间复杂度：O(nlogn)
    • 最坏时间复杂度：O(nlogn)
    • 堆排序利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。

所以不能排序

  • 整数包括正整数、负整数、0 不能用数组模拟哈希表，用容器
  • 使用hashset

HashSet

HashMap 和 HashSet 是 Java 集合框架中的两个非常重要的类，它们各自有独特的用途和内部实现机制。尽管它们在某些方面相似（比如都不保证元素的顺序，并且都允许存储 null 值），但它们在设计和用途上存在显著的区别。

  1. 底层实现
  • HashMap：基于哈希表的 Map 接口的实现。它存储键值对（key-value pairs），允许使用键（key）来快速查找、更新或删除对应的值（value）。HashMap 允许一个 null 键和多个 null 值。
  • HashSet：基于 HashMap 实现的 Set 接口。它不允许重复元素，但允许 null 元素。HashSet 实际上是通过在内部维护一个 HashMap 来实现的，其中所有的键（key）都是 HashSet 中的元素，而所有的值（value）都是相同的一个虚拟值（通常是 HashMap 的一个静态常量）。
  1. 用途
  • HashMap：当你需要存储键值对，并且能够通过键快速访问值时，使用 HashMap。例如，存储用户ID到用户信息的映射。
  • HashSet：当你只需要存储不重复的元素，而不需要关心它们的顺序时，使用 HashSet。例如，存储一个不重复的字符串集合。
  1. 性能
  • 两者在查找、插入和删除操作上的性能通常是常数时间（O(1)），但这取决于哈希函数的效率和哈希表的负载因子。
  • 由于 HashSet 内部是通过 HashMap 实现的，所以 HashSet 的性能特性与 HashMap 相似。
  1. 迭代顺序
  • HashMap 和 HashSet 都不保证迭代顺序。这意味着，当你遍历它们时，元素的顺序可能与它们被添加的顺序不同，并且这个顺序在不同的 Java 实现或不同的 JVM 运行时环境中可能有所不同。
  1. 线程安全性
  • HashMap 和 HashSet 都不是线程安全的。如果需要在多线程环境中使用它们，需要外部同步或使用线程安全的替代方案，如 ConcurrentHashMap 和 CopyOnWriteArraySet。

总结

HashMap 和 HashSet 的主要区别在于它们的用途和内部实现。HashMap 用于存储键值对，而 HashSet 用于存储不重复的元素。尽管 HashSet 内部是通过 HashMap 实现的，但它们在 Java 集合框架中扮演着不同的角色，并且应根据具体需求选择使用。

  • 错误思路
  • 记录每个整数 键 为相对 值 但是整数的范围很大？不是26个字母。走不通。
  • 遍历数组，需要 比该数<1的值，存为键，遍历得整数判断 有键相等 说明该数被需要 ，新建数组放该数 最后+1，因为第一个数没有被放进数组 大错特错
    怎么算最长 Math.max(int1,int2)
class Solution {
    public int longestConsecutive(int[] nums) {
        HashSet<Integer> need = new HashSet<>();
        for(int i = 0;i < nums.length; i++){
            need.add(nums[i]+1);
            if(need.contains(nums[i])){
                int[] arr = new 
                return new int[] arr.add(nums[i])
            }
        }
        return  max arr.length + 1;
    }
}

试图使用 HashSet 来跟踪某些值，但并不符合解决问题的最佳方法。HashSet 通常用于检查元素是否存在，而不是用于存储需要连续增加的序列。

正确思路是：

  1. 使用 HashSet 来存储数组中的所有数字，以便快速检查某个数字是否存在。
  2. 遍历数组中的每个数字 num，对于每个 num，检查 num-1 是否存在于 HashSet 中。如果不存在（即 num 是序列的起始点），则从 num 开始，向两边扩展，直到找到不连续的数字，记录这个序列的长度。
  3. 跟踪并更新找到的最长连续序列的长度。
  • 正确答案
class Solution {
    public int longestConsecutive(int[] nums) {
        HashSet<Integer> need = new HashSet<>();
        for(int i = 0;i < nums.length; i++){
            need.add(nums[i]);
        
        }
        int res = 0;
        for(int i = 0;i < nums.length; i++){
            if(!need.contains(nums[i]-1)){
               int cur = nums[i];
               int length = 1;
               while(need.contains(cur+1)){//②
                cur = cur + 1;
                length += 1;
               }
               res = Math.max(res,length);
            }
    }
    return res;
}
}

  • 错误记录

  • 泛型<>里不能是基本类型

  • 在寻找最长连续序列的问题中，使用 ②cur 变量是必要的，原因有以下几点：

    1. 避免修改原始索引：在遍历数组 nums 时，我们通常使用索引 i 来访问数组中的元素。然而，如果我们试图在内部循环中直接修改 i 或使用 nums[i] 来追踪当前正在检查的连续序列的下一个数字，那么我们将无法正确地遍历整个数组，因为 i 的值会被意外地改变或 nums[i] 总是指向数组中的同一个位置。使用 cur 变量可以让我们独立地追踪当前正在检查的数字，而不影响数组的遍历过程。
    2. 追踪连续序列的下一个数字：在内部循环中，我们需要递增地检查连续序列中的下一个数字。由于我们不能直接修改 nums[i]（它指向数组中的一个固定位置），我们需要一个变量（如 cur）来存储当前正在检查的数字，并在每次迭代时递增它。这样，我们就可以继续检查 cur + 1 是否存在于哈希集合中，从而确定连续序列的长度。
    3. 保持代码的清晰性和可维护性：使用 cur 变量可以使代码更加清晰和易于理解。它明确地表示了当前正在处理的数字，并且与数组的遍历索引 i 分开，从而避免了潜在的混淆和错误。
    4. 适应算法逻辑：在这个特定的问题中，算法的逻辑要求我们找到每个可能的连续序列的起点（即不是某个较大数字的前一个数字的数字），并从该起点开始递增地检查连续序列的长度。使用 cur 变量是实现这一逻辑的关键步骤之一。

    综上所述，使用 cur 变量是寻找最长连续序列问题中的一个重要且必要的步骤，它有助于我们正确地遍历数组、追踪连续序列的下一个数字，并保持代码的清晰性和可维护性。
    注意理清多层循环的逻辑，什么时候return

Xxxeel
关注
  • 7
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
蓄水池算法leetcode-Leetcode_diary:Leetcode就是你所需要的
06-30
蓄水池算法 leetcode Leetcode_diary Leetcode is all you need. 日常刷的记录 知识点1：数组（array） Easy： Normal: Hard: 知识点2：动态规划（dynamic programming） 经典： Easy： Normal: Hard: 知识点3：字符...
蓄水池算法leetcode-LeetCode:LeetCode刷题
06-30
蓄水池算法 leetcode LeetCode 一、编译器 （1）Visual Studio Code 简单的代码都用 VSCode 来实现。 （2）Visual Studio 复杂的代码（查找内存溢出）使用 VS 进行调试。 二、代码——C/C++ （1）所有代码都是 gcc(c...
多米诺骨牌算法leetcode-leetcode-problems:包含Leetcode的所有算法问题
07-01
多米诺骨牌算法leetcode leetcode-问题 包含其支持的语言中的所有算法问题和解决方案框架。 此存储库用于教育目的。 每个问题都链接回相应的 Leetcode 页面。 请 fork 以添加您自己的解决方案。 问题 简单的 中等的 ...
多米诺骨牌算法leetcode-leetcode:leetcode
07-01
多米诺骨牌算法leetcode 力码 力扣算法 # 标题 解决方案 困难 771 简单的 468 中等的 151 中等的 65 难的 43 中等的 15 中等的 11 中等的 9 中等的 7 简单的 5 中等的 4 难的 力扣大赛 # 比赛 标题 解决方案 困难 ...
蓄水池算法leetcode-leetcode:leetcode练习
06-30
蓄水池算法 leetcode leetcode practice 动态规划 DynamicProgramming 贪心算法 GreedyAlgorithm 分治算法 DivideAndConquer 头脑风暴 Brainteaser 堆 Heap 栈 Stack 数学 Math 队列 Queue 排序 Sort Random Trie ...
算法的学习笔记—连续子数组的最大和
业精于勤，荒于嬉
08-29 3625
通过上述的动态规划方法，我们能够有效地解决连续子数组的最大和问题。该方法简单易懂，并且具有较高的效率，适合在大多数情况下使用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😁如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🤞。
Leetcode42接雨水（单调栈）
AGNING的博客
08-28 452
维护一个栈，满足从栈底到栈顶元素大小递减。如果当前元素高于栈顶，且栈内有至少2个元素，则形成了一个凹槽，及一个图中横着的红色矩形，将它的面积累加即可，第一次写难在维护单调栈中计算面积和。求出前缀最大和后缀最大，用两者较小值减去当前高度，累加即可，这个思路容易想到，这里不赘述。
递归、搜索与回溯算法
无聊_人的博客
08-29 7077
所谓的递归其实就是函数自己调用自己的情况。
力扣（无重叠区间）
yyssas的博客
08-29 7783
先按照左侧数字排序，然后对于i位置和i+1位置，如果i位置右侧数字大于i+1位置左侧数字，则说明这两个区间有重叠，则需要移除更可能和后面重叠的那一个，因为排序是按照左边从小到大排序的，所以左边一定是小的，此时要关注的就是右边，也就是选择i和i+1右侧更小的那个，即右侧大的那个删除。一直到右侧小于k的左侧停止，此时剩下的一定是不会重叠的那个。需要移除区间的最小数量，使剩余区间互不重叠。
代码随想录算法训练营第62天|Floyd 算法精讲、A * 算法精讲 （A star算法）
Yinems的博客
08-28 1318
分两种情况，一种是节点 i 到节点 j 的最短路径经过节点 k，grid[i][j][k] = grid[i][k][k-1] + grid[k][j][k-1]；另一种情况，节点 i 到节点 j 的最短路径不经过节点 k，grid[i][j][k] = grip[i][j][k-1]；刚开始初始化 k 是不确定的，如果赋值为1，那么不能知道节点 i 到节点 j 经过1个节点的最短距离，所以只能把 k 赋值为0，本题中节点0是无意义的，节点是从1到n。本题求的是最小值，所以其余值初始化为最大值。
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 4558
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
算法训练营|图论第8天 拓扑排序 dijkstra
最新发布
qq_53125539的博客
09-02 217
拓扑排序。
精选算法编程题
A18937260063的博客
08-30 3115
数组编程
冒泡排序算法
m0_74051652的博客
08-28 1405
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行的，直到没有再需要交换的元素为止，这意味着数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（或说是排序的开头位置），就如同水中的气泡一样上升到水面。冒泡排序的写法可以简单分为两种方式，分别是：前同后异、前异后同。
[E二叉树] lc110. 平衡二叉树(dfs+自底向上)
Y-puyu 的博客
08-31 369
【代码】[E二叉树] lc110. 平衡二叉树(dfs+自底向上)
算法的学习笔记—把数字翻译成字符串
业精于勤，荒于嬉
08-31 895
通过动态规划的方法，我们可以高效地计算出一个数字字符串有多少种不同的翻译方法。这个问题不仅考察了我们对动态规划的理解，还让我们熟悉了如何处理字符串中的边界情况和状态转移。希望通过这个例子的讲解，能够帮助你更好地理解动态规划的应用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybit欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论
字节跳动（社招）三面算法原题
宫水三叶的刷题日记
08-29 1815
但当招聘市场"供过于求"的时候，为了不让招聘过程显得突兀（距离招聘截止日期还有很久，但人已招满），这时候通常会卡住一些流程，尽量拖时间，此时越到后面要求越高，希望越少。当我们有了所有排好序的候选边集合之后，我们可以对边进行从前往后处理，每次加入一条边之后，使用并查集来查询「起点」和「终点」是否连通（并查集部分）。所以，虽然目前某些字节跳动的 BU 已经开始拖流程，但在下半年，必然会有新业务大量招兵买马，抓紧准备吧各位。你每次可以往「上，下，左，右」四个方向之一移动，你想要找到耗费体力最小的一条路径。
977.有序数组的平方
argcargv的博客
08-31 200
将双指针l、r分别从头和尾向中间移动（简化了很多，不用再处理边界条件）：基本相同写法（将双指针从中将最小值的下表，向两边移动）组成的新数组，要求也按。
【CSP】坐标变换2(问题拆解,快速输入,知识补充)
weixin_72391681的博客
08-30 3210
总结在这道题目中，我们通过旋转矩阵公式解决了二维平面上的坐标旋转问题，并且通过对浮点数的精度控制，满足了输出精度要求。我们还讨论了如何通过设定缓冲区和自定义输入函数优化大规模数据的输入输出效率。启发几何问题的推广：旋转矩阵的思路不仅适用于二维旋转，还可以推广到三维或更高维度的旋转问题，甚至可以应用于计算机图形学中的各种变换操作。精度控制的重要性：在涉及到浮点数运算的题目中，精度控制是至关重要的。了解并合理使用C++中的格式化输出可以有效避免因为精度丢失导致的错误。高效输入输出的技巧。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值