力扣周结03

最新推荐文章于 2024-11-04 10:13:26 发布
最新推荐文章于 2024-11-04 10:13:26 发布
阅读量4.5k 收藏 5
点赞数 14
分类专栏： 力扣周结 文章标签： 数据库 java 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/goddessccy/article/details/121465176
版权
这篇博客介绍了多种算法问题的解决方案，包括判断字母异位词的有效性、求解两个数组的交集、判断快乐数以及实现特定的数学操作，如赎金信和四数之和。文章深入探讨了如何利用哈希表、排序双指针和栈等数据结构有效地解决这些问题，提供了清晰的解题思路和核心代码。
摘要由CSDN通过智能技术生成

242. 有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

提示:

  • 1 <= s.length, t.length <= 5 * 104
  • s 和 t 仅包含小写字母

解题思路

数组是一种最简单的哈希表，因为两个字符串只包含小写字母所以我们可以设置一个长度为26的数组，0-25分别对应a-z出现的次数，最后再遍历一次数组如果出现了不为1的元素就表明两个字符串不是有效的字母异位词

核心代码

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

时间复杂度

O(n)

空间复杂度

O(1)

349. 两个数组的交集

给定两个数组，编写一个函数来计算它们的交集。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]

说明：

  • 输出结果中的每个元素一定是唯一的。
  • 我们可以不考虑输出结果的顺序。

解题思路

这道题是虚假的求交集，即只是求出元素并不要求元素的个数所以我们可以声明两个set集合，然后将两个set集合中包含的元素加入到结果数组中

也可以使用排序双指针求解这里就不做演示了

核心代码

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        HashSet<Integer> set = new HashSet<>();
        HashSet<Integer> set0 = new HashSet<>();
        int i = 0;
        for(int item : nums1) {
            set.add(item);
        }
        for(int item : nums2) {
            if(set.contains(item))
            set0.add(item);
        }
        int[] result = new int[set0.size()];
        for(int item : set0) {
            result[i] = item;
            i++;
        }
        return result;
    }
}

时间复杂度

O(n)

空间复杂度

O(n)

350. 两个数组的交集 II

给定两个数组，编写一个函数来计算它们的交集。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]

示例 2:

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[4,9]

说明：

  • 输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。
  • 我们可以不考虑输出结果的顺序。

解题思路

真正的求交集，和上一题一样也是两种思路，排序双指针的会简单一些

核心代码

排序双指针

class Solution {    public int[] intersect(int[] nums1, int[] nums2) {        //将数组排序        Arrays.sort(nums1);        Arrays.sort(nums2);        //定义双指针分别指向两个数组的头部        int a = 0, b = 0;        //定义结果集        int[] result = new int[Math.min(nums1.length,nums2.length)];        //定义遍历结果集指针        int k = 0;        while(a < nums1.length && b < nums2.length) {            if(nums1[a] == nums2[b]) { //第一种情况：如果两数相等就将数字加入到结果集中并让两个指针同时移动                result[k++] = nums1[a];                a++;                b++;             } else if(nums1[a] > nums2[b]) { //第二种情况：如果第一个数组的值大于第二个数组那么就让值小的数组的指针前移                b++;            } else { //第三种情况：如果第二个数组的值大于第一个数组那么就让值小的数组的指针前移                a++;            }        }        return Arrays.copyOfRange(result, 0, k);    }}

时间复杂度

O(n)
空间复杂度

O(n)

两个map模拟并集

class Solution {    public int[] intersect(int[] nums1, int[] nums2) {        //存储第一数组的元素和个数的key和value        HashMap<Integer,Integer> map0 = new HashMap<>();        //存储第二个数组的元素和个数的key和value        HashMap<Integer,Integer> map1 = new HashMap<>();        //存储并集        HashMap<Integer,Integer> temp = new HashMap<>();        //将第一数组的元素和对应的元素存储到map中        for(int i = 0; i < nums1.length; i++) {            if(map0.containsKey(nums1[i])) {                map0.replace(nums1[i], map0.get(nums1[i]) + 1);            } else {                map0.put(nums1[i], 1);            }        }        //将第二数组的元素和对应的元素存储到map中        for(int j = 0; j < nums2.length; j++) {            if(map1.containsKey(nums2[j])) {                map1.replace(nums2[j], map1.get(nums2[j]) + 1);            } else {                map1.put(nums2[j], 1);            }        }        //模拟并集的过程，将两个数组的相同元素作为key并将元素个数的最小值作为value存储到result结集合中        for(int index : map0.keySet()) {            if(map1.containsKey(index)) {                temp.put(index,Math.min(map0.get(index), map1.get(index)));            }        }        //定义数组长度        int length = 0;        //将并集的长度求出来        //具体做法为将result集合中所有的value求和        for(int index : temp.values()) {            length += index;        }        //定义返回数组        int[] result = new int[length];         /**         * k 用来遍历数组         * e 限制每个key的value循环         */        int k = 0, e = 0;        for(int index : temp.keySet()) {            e = 0;            while(e < temp.get(index)) {                result[k++] = index;                e++;            }        }        return result;    }}

时间复杂度

O(n)

空间复杂度

O(n)

202. 快乐数

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」定义为：

  • 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
  • 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
  • 如果 可以变为 1，那么这个数就是快乐数。

如果 n 是快乐数就返回 true ；不是，则返回 false 。

示例 1：

输入：n = 19输出：true解释：12 + 92 = 8282 + 22 = 6862 + 82 = 10012 + 02 + 02 = 1

示例 2：

输入：n = 2输出：false

提示：

  • 1 <= n <= 231 - 1

解题思路

将数通过%10分离个位数再通过/10移除个位数并让其他位数顺位减一，将分离完的个位数依次平方求和然后储存到set集合中，循环这个过程，如果平方和和set中的元素重复那么这个数就不是快乐数

核心代码

class Solution {    public boolean isHappy(int n) {        //定义哈希set存储每次sum的值如果添加sum的时候sum重复了那就返回false        HashSet<Integer> set = new HashSet<>();        int sum = n;        //如果sum不为1        while(sum != 1) {            if(set.contains(sum)){                return false;            }else{                set.add(sum);            }            sum = 0;            while(n != 0) {                sum += Math.pow(n % 10, 2);                n /= 10;            }            n = sum;        }        return true;        }}

时间复杂度

O(logn)

空间复杂度

O(logn)

1. 两数之和

给定一个整数数组 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 <= 104
  • -109 <= nums[i] <= 109
  • -109 <= target <= 109
  • 只会存在一个有效答案

解题思路

这道题求解思路很多，暴力硬A的，二分查找，也可以使用哈希表来求得

使用目标数字减去数组的值如果map中存在那么就返回这两个值如果map中不存在那么就将这个数组元素和数组下标存入map中

核心代码

class Solution {    public int[] twoSum(int[] nums, int target) {        int[] result = new int[2];        if(nums == null || nums.length == 0) {            return result;        }        HashMap<Integer,Integer> map = new HashMap<>();        for(int i = 0; i < nums.length; i++) {            int temp = target - nums[i];            if(map.containsKey(temp)) {                result[0] = i;                result[1] = map.get(temp);                return result;            }            map.put(nums[i], i);        }        return result;    }}

时间复杂度

O(n)

空间复杂度

O(n)

454. 四数相加 II

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

  • 0 <= i, j, k, l < n
  • nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

示例 1：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]输出：2解释：两个元组如下：1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 02. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

示例 2：

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]输出：1

提示：

  • n == nums1.length
  • n == nums2.length
  • n == nums3.length
  • n == nums4.length
  • 1 <= n <= 200
  • -228 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 228

解题思路

因为题解的最后是需要得到能够构成0的个数，所以我们可以将前两个数组的元素之和求出同时统计出现的次数记录到map中，然后再统计剩余元素的和，在map中寻找后两个元素相加求和的相反数如果能找到就记录出现的次数

核心代码

class Solution {    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {        Map<Integer, Integer> map = new HashMap<>();        int temp;        int res = 0;        //统计两个数组中的元素之和，同时统计出现的次数，放入map        for (int i : nums1) {            for (int j : nums2) {                temp = i + j;                if (map.containsKey(temp)) {                    map.put(temp, map.get(temp) + 1);                } else {                    map.put(temp, 1);                }            }        }        //统计剩余的两个元素的和，在map中找是否存在相加为0的情况，同时记录次数        for (int i : nums3) {               for (int j : nums4) {                temp = i + j;                if (map.containsKey(0 - temp)) {                    res += map.get(0 - temp);                }            }        }        return res;        }}

时间复杂度

O(n^2)

空间复杂度

O(n)

383. 赎金信

为了不在赎金信中暴露字迹，从杂志上搜索各个需要的字母，组成单词来表达意思。

给你一个赎金信 (ransomNote) 字符串和一个杂志(magazine)字符串，判断 ransomNote 能不能由 magazines 里面的字符构成。

如果可以构成，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

示例 1：

输入：ransomNote = "a", magazine = "b"输出：false

示例 2：

输入：ransomNote = "aa", magazine = "ab"输出：false

示例 3：

输入：ransomNote = "aa", magazine = "aab"输出：true

提示：

  • 1 <= ransomNote.length, magazine.length <= 105
  • ansomNote 和 magazine 由小写英文字母组成

解题思路

因为只需要magazine中的字符在ransomNote中出现的次数一致就可以了，所以我们用数组来记录赎金信中的字母及其个数，然后将杂志中的元素进行比对

核心代码

class Solution {    public boolean canConstruct(String ransomNote, String magazine) {        int[] result = new int[26];        for(int i = 0; i < ransomNote.length(); i++) { // 遍历赎金信并记录次数            result[ransomNote.charAt(i) - 'a']++;        }        for(int j = 0; j < magazine.length(); j++) { // 将杂志中的字符串和赎金信中的做比对            if(result[magazine.charAt(j) - 'a'] != 0)            result[magazine.charAt(j) - 'a']--;        }        for(int i = 0; i < 26; i++) {            if(result[i] != 0)            return false;        }        return  true;    }}

时间复杂度

O(n + m)

空间复杂度

O(1)

15. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]输出：[[-1,-1,2],[-1,0,1]]

示例 2：

输入：nums = []输出：[]

示例 3：

输入：nums = [0]输出：[]

解题思路

排序双指针，首先确认第一个元素，如果第一个元素大于0就没有后续的必要了，因为不可以包含重复的三元组所以还涉及到了去重的操作，再确认好第一个元素之后，剩下两个元素的值也很好确认可以使用双指针来分别指向末尾和第一个元素后一位的元素

核心代码

class Solution {    public List<List<Integer>> threeSum(int[] nums) {        //定义结果集LinkedList相比于ArrayList添加和删除效率比较高        List<List<Integer>> result = new LinkedList<List<Integer>>();        //如果数组长度小于3就不需要进行后续操作了直接返回空的结果集即可        if(nums.length < 3) {            return result;        }        //我们采用排序双指针的方法方便去重的操作        Arrays.sort(nums);        for(int i = 0; i < nums.length; i++) {            //因为数组已经排过序了如果第一个值是正数后面就没必要比较了            if(nums[i] > 0)                break;            //如果从数组第二个值开始，当前元素和前一个元素相同那么直接跳过本次循环            if(i > 0 && nums[i - 1] == nums[i])                continue;            //a > b > c 由于第一个元素的确认我们把他看作常数对待那么 满足函数 a(常数) + b(未知量) = -c(未知量) 形状有点像 y = -x            int left = i + 1;            int right = nums.length - 1;            while(left < right) {                // temp = a + b + c                if(nums[left] + nums[right] == -nums[i]) {                    result.add(new LinkedList<Integer>(Arrays.asList(nums[i], nums[left], nums[right])));                    left++;                    right--;                    //去重操作                    while(left < right && nums[left] == nums[left - 1])                        left++;                    while(left < right && nums[right] == nums[right + 1])                        right--;                                  } else if(nums[left] + nums[right] > -nums[i]) {                    right--;                } else if(nums[left] + nums[right] < -nums[i]) {                    left++;                }            }        }        return result;    }}

时间复杂度

O(n^2)

空间复杂度

O(n)

18. 四数之和

这道题和15题核心思路基本一致

class Solution {    public List<List<Integer>> fourSum(int[] nums, int target) {        //创建结果集        List<List<Integer>> result = new LinkedList<List<Integer>>();        if(nums.length < 4) {            return result;        }        //排序双指针        Arrays.sort(nums);        for(int i = 0; i < nums.length - 3; i++) {            //去重            if(i > 0 && nums[i - 1] == nums[i]) {                continue;            }            for(int j = i + 1; j < nums.length - 2; j++) {                //去重                if(j > i + 1 && nums[j - 1] == nums[j]) {                    continue;                }                int left = j + 1;                int right = nums.length - 1;                int temp = target - nums[i] - nums[j];                while(left < right) {                    int sum = nums[left] + nums[right];                    if(sum == temp) {                        result.add(new LinkedList<Integer>(Arrays.asList(nums[i], nums[j], nums[left], nums[right])));                        left++;                        right--;                        //去重                        while(left < right && nums[left] == nums[left - 1])                        left++;                        while(left < right && nums[right] == nums[right + 1])                        right--;                                            } else if(sum < temp) {                        left++;                    } else {                        right--;                    }                }            }        }        return result;    }}

232. 用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾
  • int pop() 从队列的开头移除并返回元素
  • int peek() 返回队列开头的元素
  • boolean empty() 如果队列为空，返回 true ；否则，返回 false

解题思路

模拟题仔细就可以了

核心代码

class MyQueue {    //定义两个栈    Stack<Integer> stack0 = null;    Stack<Integer> stack1 = null;    //初始化两个栈    public MyQueue() {        stack0 = new Stack<>();        stack1 = new Stack<>();    }    //如果栈1不为空那就先将栈1的元素全部出栈添加到栈0然后向栈0中添加新元素    public void push(int x) {        if(stack1.size() != 0) {            while(stack1.size() != 0) {                stack0.push(stack1.pop());            }        }        stack0.push(x);    }    //如果栈0中包含元素那么就将所有元素出栈并添加到栈1中移除并返回栈1的栈顶元素    public int pop() {        if(stack0.size() != 0) {            while(stack0.size() != 0) {                stack1.push(stack0.pop());            }        }        return stack1.pop();    }    //如果栈0中包含元素那么就将所有元素出栈并添加到栈1中返回栈1的栈顶元素    public int peek() {        if(stack0.size() != 0) {            while(stack0.size() != 0) {                stack1.push(stack0.pop());            }        }        return stack1.peek();    }    //查看栈0和栈1中是否含有元素    public boolean empty() {        return stack1.isEmpty() && stack0.isEmpty();    }}

225. 用队列实现栈

解题思路

模拟题我是使用一个队列实现的

核心代码

class MyStack {    List<Integer> list0 = null;    //初始化队列    public MyStack() {        list0 = new LinkedList<Integer>();    }            public void push(int x) {        list0.add(x);    }        public int pop() {        return list0.remove(list0.size() - 1);    }        public int top() {        return list0.get(list0.size() - 1);    }        public boolean empty() {        return list0.isEmpty();    }}

20. 有效的括号

解题思路

栈很适合用来做匹配消除，遍历整个字符串，如果栈中元素不为空并且栈顶元素和对应的右括号匹配就弹出栈

核心代码

class Solution {    public boolean isValid(String s) {        //定义一个栈        Stack<Character> stack = new Stack<>();        for(int i = 0; i < s.length(); i++) {            if(!stack.isEmpty() && stack.peek() == isType(s.charAt(i))) {                stack.pop();                continue;            }            stack.push(s.charAt(i));        }        return stack.isEmpty();    }    public char isType(char c) {        char flag = '\0';        if(c == ')') {            flag = '(';        }else if(c == ']') {            flag = '[';        }else if(c == '}') {            flag = '{';        }        return flag;    }}

时间复杂度

O(n)

空间复杂度

O(n)

1047. 删除字符串中的所有相邻重复项

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

输入："abbaca"输出："ca"解释：例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。

解题思路

  1. 消除相邻且相同的元素第一种思路用栈来实现
  2. 使用Stringbuffer模拟栈
  3. 双指针遍历字符串，让快慢指针同速前进，如果遇到需要删除的元素就让慢指针–下次循环直接就覆盖了

核心代码

/** * 第一种思路，用栈来实现 * 依次将字符串的字符入栈如果两两相当，那么就消除 */class Solution {    public String removeDuplicates(String s) {        LinkedList<Character> queue = new LinkedList<>();        char temp;        for(int i = 0; i < s.length(); i++) {            temp = s.charAt(i);            // 如果栈为空或者栈顶元素不等于temp就入栈，否则就出栈            if(queue.isEmpty() || queue.peek() != temp) {                queue.push(temp);            } else {                queue.pop();            }        }        // 剩余的元素就是最终字符串,但是由于栈的结构所以得出来的字符串是反的需要换一下        String result = "";        while(!queue.isEmpty()) {            result += queue.pop();        }        result = new StringBuffer(result).reverse().toString();        return result;    }}

/** * 第二种思路，字符串模拟栈 */class Solution {    public String removeDuplicates(String s) {        StringBuffer buffer = new StringBuffer();        char temp;        // 记录buffer的长度，为什么是-1？        // 之所以是-1是因为第一个元素是默认添加的，它的索引值为0，此时为了能够判断第二次循环条件，        // l模仿指向栈顶        int l = -1;        for(int i = 0; i < s.length(); i++) {            temp = s.charAt(i);            // 如果此时字符串的尾部元素和temp相同那么就把字符串尾部删除,为了添加第一个元素所以需要设置temp >= 0            if(l >= 0 && temp == buffer.charAt(l)) {                buffer.deleteCharAt(l);                l--;            } else {                buffer.append(temp);                l++;            }        }        return buffer.toString();    }}

/**
 * 第三种思路，双指针法,直接使用现有字符串使用双指针覆盖重复的元素
 */
class Solution {
    public String removeDuplicates(String s) {
        char[] c = s.toCharArray();
        int slow = 0;
        for(int fast = 0; fast < s.length(); fast++) {
            c[slow] = c[fast];
            // 如果slow指向的元素和slow-1所指向的元素相等那么就让slow指针后移，下次循环直接就覆盖掉了
            if(slow > 0 && c[slow] == c[slow - 1]) {
                slow--;
            } else {
                slow++;
            }
        }
        return new String(c,0,slow);
    }
}

时间复杂度

  1. O(n)
  2. O(n)
  3. O(n)

空间复杂度

  1. O(n)
  2. O(n)
  3. O(1)

150. 逆波兰表达式求值

根据 逆波兰表示法，求表达式的值。

有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

说明：

  • 整数除法只保留整数部分。
  • 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

输入：tokens = ["2","1","+","3","*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

示例 2：

输入：tokens = ["4","13","5","/","+"]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

解题思路

求解逆波兰表达式，如果是数字直接入栈，如果是操作符，从栈中取出两个元素进行操作后再压入栈

核心代码

class Solution {
    public int evalRPN(String[] tokens) {
        //定义一个栈便于存储运算数字
        Stack<Integer> stack = new Stack<Integer>();
        //因为遍历到+ - * /需要出栈两个字符计算后入栈所以设置两个变量
        int a = 0;
        int b = 0;
        for(int i = 0; i < tokens.length; i++) {
            if ("+".equals(tokens[i])) {
                a = stack.pop();
                b = stack.pop();
                stack.push(b + a);
            } else if ("-".equals(tokens[i])) {
                a = stack.pop();
                b = stack.pop();
                stack.push(b - a);
            } else if ("*".equals(tokens[i])) {
                a = stack.pop();
                b = stack.pop();
                stack.push(b * a);
            } else if ("/".equals(tokens[i])) {
                a = stack.pop();
                b = stack.pop();
                stack.push(b / a);
            } else {
                stack.push(Integer.valueOf(tokens[i]));
            }
        }
        return stack.pop();
    }
}

时间复杂度

O(n)

空间复杂度

O(n)

347. 前 K 个高频元素

解题思路

需要统计前k个高频元素，既需要统计元素出现的个数而且需要按照出现的个数进行排序，我们可以使用优先级队列维护一个小根堆，按照出现次数对元素进行升序排序，如果队列长度大于k就将队头元素弹出，最后优先级队列剩余的即是前k个元素

核心代码

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        //定义结果集
        int[] result = new int[k];
        //记录nums中不同元素出现的个数
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int temp : nums) {
            map.put(temp, map.getOrDefault(temp, 0) + 1);
        }
        //使用Map.Entry方法将map存入set中
        Set<Map.Entry<Integer, Integer>> set = map.entrySet();
        //使用优先队列将map存入，小根堆！！
        PriorityQueue<Map.Entry<Integer, Integer>> queue = new PriorityQueue<>((o1, o2) -> o1.getValue() - o2.getValue());
        for(Map.Entry<Integer, Integer> entry : set) {
            //将set中的元素存入
            queue.offer(entry);
            //如果队列长度大于k就弹出
            if(queue.size() > k) {
                queue.poll();
            }
        }
        for(int i = k - 1; i >= 0; i--) {
            result[i] = queue.poll().getKey();
        }
        return result;
    }
}

时间复杂度

O(nlogk)

空间复杂度

O(n)

239. 滑动窗口最大值

解题思路

维护一个单调队列模拟滑动窗口，队头到队尾单调递减
QAQ力扣优先级队列跑不过超时了

核心代码

/**
单调队列真是一种让人感到五味杂陈的数据结构，它的维护过程更是如此.....就拿此题来说，队头最大，往队尾方向单调......有机会站在队头的老大永远心狠手辣，当它从队尾杀进去的时候，如果它发现这里面没一个够自己打的，它会毫无人性地屠城，把原先队里的人头全部丢出去，转身建立起自己的政权，野心勃勃地准备开创一个新的王朝.....这时候，它的人格竟发生了一百八十度大反转，它变成了一位胸怀宽广的慈父！它热情地请那些新来的“小个子”们入住自己的王国......然而，这些小个子似乎天性都是一样的——嫉妒心强，倘若见到比自己还小的居然更早入住王国，它们会心狠手辣地找一个夜晚把它们通通干掉，好让自己享受更大的“蛋糕”；当然，遇到比自己强大的，它们也没辙，乖乖夹起尾巴做人。像这样的暗杀事件每天都在上演，虽然王国里日益笼罩上白色恐怖，但是好在没有后来者强大到足以干翻国王，江山还算能稳住。直到有一天，闯进来了一位真正厉害的角色，就像当年打江山的国王一样，手段狠辣，野心膨胀，于是又是大屠城......历史总是轮回的。
 */
class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        //定义结果集
        int[] result = new int[nums.length - k + 1];
        //定义指针遍历结果集
        int j = 0;
        //定义双端队列手动实现单调栈(单调递增)
        ArrayDeque<Integer> deque = new ArrayDeque<>();
        for(int i = 0; i < nums.length; i++) {
            //队头元素始终在窗口中如果不在窗口中就弹出 i - k + 1即根据右窗口得到左窗口
            while(!deque.isEmpty() && deque.peek() < i - k + 1) {
                deque.poll();
            }
            //队尾元素小于右窗口就将元素弹出
            while(!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
                deque.pollLast();
            }
            //存下标
            deque.offer(i);
            //当数组下标大于等于窗口大小-1的时候代表已经到达窗口最大值
            if(i >= k - 1) {
                result[j++] = nums[deque.peek()];
            }
        }
        return result;
    }
}

时间复杂度

O(n)

空间复杂度

O(k)

存量美团骑手
关注
专栏目录
力扣刷题day03
qq_54951190的博客
05-25 136
力扣刷题day03
力扣 c++ 快捷键
qq_40212968的博客
05-22 529
1.注释 加注释：ctrl+c+k 取消注释：ctrl+c+u
力扣-03 无重复字符的最长子串
ayu的博客
01-13 3339
题目： 代码： public static int lengthOfLongestSubstring(String s) { int start = 0; int maxlength = 0; Map<Character, Integer> hash = new HashMap<>(); char[] charArray = s.toCharArray(); for (int end = 0;
力扣刷题-题目以及答案
颜淡慕潇
03-21 5141
题目： 给定一个n个元素有序的（升序）整型数组nums 和一个目标值target ，写一个函数搜索nums中的 target，如果目标值存在返回下标，否则返回 -1。 示例 1: 输入: nums = [-1,0,3,5,9,12], target = 9 输出: 4 解释: 9 出现在 nums 中并且下标为 4 示例2: 输入: nums = [-1,0,3,5,9,12], target = 2 输出: -1 解释: 2 不存在 nums 中因此返回 -1 提示： ...
力扣的小记
sonichenn的博客
07-17 202
力扣
力扣HOT100题代码
媛旦的博客
03-21 829
49.字母异位词分组 #include<iostream> #include<string> #include<vector> #include<unordered_map> using namespace std; int main(){ //输入字符串数组 例：eat tea tan ate nat bat（MAC系统：回车+control D；win系统：回车+control Z；） string word; vector&
打家劫舍（力扣）
weixin_45746754的博客
03-21 1558
打家劫舍（力扣） 条件：不可偷相连的 分析思路： 假设一个有n间房，第i间房放有Mi金额的钱。 步骤一：定义原问题和子问题 原问题：从全部 n 间房中能够偷盗的最大金额； 子问题：从前 k 个(k<=n) 间房中能够偷的最大金额； 步骤二：定义状态 我们记 f(k) 为小偷能从前k间房中偷到的最大金额，这里k就表示这个小偷在子问题时的一个状态，即小偷仅能偷前 n 间房 步骤三：寻找状态转移方程 就是 寻找子问题之间的一个递推关系， 情况1： k=1时， 情况2： k=2时，只有第一间和第二间房，可
力扣算法练习
赵家乐
03-18 932
官方网址 https://leetcode-cn.com/
【力扣】反转链表
m0_51704552的博客
08-12 591
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
力扣算法个人总结开坑
weixin_44066592的博客
04-15 870
随着暑期实习和秋招的进行，准备针对力扣上的题目和代码随想录上的知识做一个系统的归纳和总结。
力扣
12-22
力扣（LeetCode）是一个知名的在线编程挑战平台，它提供了各种算法题目，旨在提升程序员的技能，特别是数据结构和算法的运用。其中，题目88“合并两个有序数组”是一道典型的数组操作问题，要求将两个已排序的整数数...
力扣题解大全-600多页版
08-29
力扣（LeetCode）是一个非常受欢迎的在线编程挑战平台，专注于提供各种算法题目来提升编程能力和解决问题的能力。这个“力扣题解大全-600多页版”显然是一个全面整理了力扣平台上众多题目的资源，涵盖了从基础到中...
Leet Code_力扣原题_leetcode官网_
10-01
力扣（LeetCode）是一个非常受欢迎的在线编程挑战平台，专为准备技术面试和提升编程技能而设计。它提供了各种算法和数据结构题目，涵盖了多种编程语言，包括但不限于Java、Python、C++和JavaScript。力扣上的问题...
力扣算法03——斐波那契数列
Sdwq12的博客
05-01 301
暴力迭代： 去重迭代： 双指针迭代： /** * 斐波那契数列三种解法 */ public class Fib { public static void main(String[] args) { System.out.println("直接迭代： "+calculate(10)); System.out.println("去重迭代： "+calculate(10)); System.out.println("双指针迭代...
oceanbase V4.2.2社区版集群离线部署
king_harry的专栏
11-01 725
版本，选择是上传文件，包含oceanbase-ce、oceanbase-ce-libs、oceanbase-ce-utils。关闭时展示，为 OBProxy 集群的访问地址，仅用于生成租户的连接串，不影响实际使用，需要自主配置负载均衡，如果是 VIP 地址，还需要您自主申请并绑定到 OBProxy Server。集群配置选项卡—更多配置—更改系统内存保留选项，默认是30G，如果测试机内存只有16G，则需要调小，本测试调整为2G，这样ocp-server安装不会失败。自定义待管理的集群的名称。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 941
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
安利一款开源企业级的报表系统SpringReport
最新发布
luck332的专栏
11-04 339
SpringReport是一款企业级的报表系统，支持在线设计报表，并绑定动态数据源，无需写代码即可快速生成想要的报表，可以支持excel报表和word报表两种格式，同时还可以支持excel多人协同编辑，后续考虑实现大屏设计器功能，通过简单的设计器可以生成炫酷的大屏效果。
【重学 MySQL】七十九、深入探索用户变量
CSDN全栈领域优秀博主，阿里云博客专家，工信部权威认证物联网技术开发工程师，曾30分钟高分通过C语言二级，两天手撸代码完成EasyX飞机大战，靠接软件私活一个月换苹果电脑
10-30 909
定义：用户变量以“@”符号开头，后面跟着变量名。变量名可以是任何随机的、复合的标量表达式，只要其中没有列指定。赋值可以使用SET语句来定义和赋值用户变量，如。也可以使用SELECT语句来为用户变量赋值，但必须使用“:=”赋值运算符，因为在SELECT语句中，MySQL将“=”运算符视为等于运算符。例如，。作用域：会话用户变量的作用域是当前会话，而局部变量的作用域是其定义的BEGIN/END语句块。命名：会话用户变量以“@”符号开头，而局部变量不需要。使用场景。
真·香！深度体验 zCloud 数据库云管平台 -- DBA日常管理篇
weixin_54551388的博客
11-01 703
点击蓝字 关注我们zCloud 作为一款业界领先的数据库云管平台，通过云化自治的部署能力、智能巡检和诊断能力、知识即代码的沉淀能力，为DBA的日常管理工作带来了革新式的简化与优化。经过一周的深度体验，今天笔者与您深入探讨 zCloud 在数据库用户、参数以及日志管理方面的具体应用，看它如何为DBA的日常管理工作带来价值。数据库用户管理“常在河边走哪有不湿鞋”，作为DBA或多或少都曾遇到过因权限配置...
力扣vscode使用
09-13
力扣是一个在线的编程题库平台，而VSCode是一款流行的代码编辑器。在使用力扣和VSCode进行编程时，可以有以下几种方式： 1. 编写力扣题目代码：使用VSCode打开力扣题目的代码模板，然后在VSCode中编写代码。你可以...
评论 24
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

存量美团骑手

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值