leetcode刷题笔记（4）

已于 2022-02-08 12:40:44 修改
阅读量3k 收藏
点赞数
文章标签： leetcode 算法 职场和发展
于 2022-01-12 21:58:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zeng_q_yan/article/details/122362482
版权

leetcode刷题笔记（4）

主题：哈希表

（1）30. 串联所有单词的子串（错1）

一顿操作猛如虎，提交击败百分五；

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> res = new ArrayList<Integer>();
        Map<String,Integer> map = new HashMap<String,Integer>();
        for(String str : words){
            if(map.get(str) == null){
                map.put(str,1);
            }else{
                map.put(str,map.get(str)+1);
            }
        }
        int wlen = words[0].length();
        int len = s.length();
        for(int start= 0;start < len-wlen+1;start++){
            int left = start;
            int n = 0;
            while(left+wlen <= len && n < words.length){
                if(map.get(s.substring(left,left+wlen)) == null || map.get(s.substring(left,left+wlen)) == 0){
                    break;
                }else{
                    map.put(s.substring(left,left+wlen), map.get(s.substring(left,left+wlen))-1);
                    left += wlen;
                    n++;
                }
            }
            if(n == words.length){
                res.add(start);
            }
            map.clear();
            for(String str : words){
                if(map.get(str) == null){
                    map.put(str,1);
                }else{
                    map.put(str,map.get(str)+1);
                }
            }

        }
        return res;
    }
}

题解思路:使用temp_map和，map做比较，而不用每遍历一次重新生成map；双指针

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> res = new ArrayList<>();
        if (s == null || s.length() == 0 || words == null || words.length == 0) return res;
        HashMap<String, Integer> map = new HashMap<>();
        int one_word = words[0].length();
        int word_num = words.length;
        int all_len = one_word * word_num;
        for (String word : words) {
            map.put(word, map.getOrDefault(word, 0) + 1);
        }
        for (int i = 0; i < one_word; i++) {
            int left = i, right = i, count = 0;
            HashMap<String, Integer> tmp_map = new HashMap<>();
            while (right + one_word <= s.length()) {
                String w = s.substring(right, right + one_word);
                right += one_word;
                if (!map.containsKey(w)) {
                    count = 0;
                    left = right;
                    tmp_map.clear();
                } else {
                    tmp_map.put(w, tmp_map.getOrDefault(w, 0) + 1);
                    count++;
                    while (tmp_map.getOrDefault(w, 0) > map.getOrDefault(w, 0)) {
                        String t_w = s.substring(left, left + one_word);
                        count--;
                        tmp_map.put(t_w, tmp_map.getOrDefault(t_w, 0) - 1);
                        left += one_word;
                    }
                    if (count == word_num) res.add(left);
                }
            }
        }
        return res;
    }
}

（2）36. 有效的数独

我的思路：分别判断行、列、九宫格中的数字是否满足要求

class Solution {
    public boolean isValidSudoku(char[][] board) {
        for(int i = 0; i < 9; i++){
            if(!hang(board,i)){
                return false;
            }
            if(!lie(board,i)){
                return false;
            }
            if(!nine(board,i)){
                return false;
            }
        }
        return true;
    }

    public boolean hang(char[][] board, int row){
        HashSet set = new HashSet();
        for(int i = 0; i < 9;i++){
            if(board[row][i] == '.'){
                continue;
            }
            if(!set.contains(board[row][i])){
                set.add(board[row][i]);
            }else{
                return false;
            }
        }
        return true;
    }

    public boolean lie(char[][] board, int col){
        HashSet set = new HashSet();
        for(int i = 0; i < 9;i++){
            if(board[i][col] == '.'){
                continue;
            }
            if(!set.contains(board[i][col])){
                set.add(board[i][col]);
            }else{
                return false;
            }
        }
        return true;
    }

    public boolean nine(char[][] board, int index){
        HashSet set = new HashSet();
        int row = index / 3;
        int col = index % 3;
        for(int i = row*3 + 0; i < row*3+3;i++){
            for(int j = col*3+0; j < col*3+3;j++){
                if(board[i][j] == '.'){
                    continue;
                }
                if(!set.contains(board[i][j])){
                    set.add(board[i][j]);
                }else{
                    return false;
                }
            }
        }
        return true;
    }
}

题解思路：用三个哈希表分别记录行、列、小九宫格每个数字出现的次数

class Solution {
    public boolean isValidSudoku(char[][] board) {
        int[][] rows = new int[9][9];
        int[][] columns = new int[9][9];
        int[][][] subboxes = new int[3][3][9];
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                char c = board[i][j];
                if (c != '.') {
                    int index = c - '0' - 1;
                    rows[i][index]++;
                    columns[j][index]++;
                    subboxes[i / 3][j / 3][index]++;
                    if (rows[i][index] > 1 || columns[j][index] > 1 || subboxes[i / 3][j / 3][index] > 1) {
                        return false;
                    }
                }
            }
        }
        return true;
    }
}

（3）41. 缺失的第一个正数（错1）

题解思路：将负数变为n+1；将<=n的元素对应的位置变为负数；返回第一个大于0的下标+1；

class Solution {
    public int firstMissingPositive(int[] nums) {
        int n = nums.length;
        for(int i = 0; i < n; i++){
            if(nums[i] <= 0){
                nums[i] = n + 1;
            }
        }
        for(int i = 0; i < n; i++){
            int num = Math.abs(nums[i]);
            if(num <= n){
                nums[num-1] = -Math.abs(nums[num-1]);
            }
        }
        for(int i = 0; i < n; i++){
            if(nums[i] > 0){
                return i+1;
            }
        }
        return n+1;
    }
}

（4）49. 字母异位词分组（错1）

方法1：排序

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<String, List<String>>();
        for (String str : strs) {
            char[] array = str.toCharArray();
            Arrays.sort(array);
            String key = new String(array);
            List<String> list = map.getOrDefault(key, new ArrayList<String>());
            list.add(str);
            map.put(key, list);
        }
        return new ArrayList<List<String>>(map.values());
    }
}

方法2：计数

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        HashMap<String, List<String>> map = new HashMap<String, List<String>>();
        for(String str : strs){
            int[] temp = new int[26];
            String t = "";
            for(char c: str.toCharArray()){
                temp[c-'a']++;
            }
            for(int i = 0; i < temp.length; i++){
                t += (i+'a' + temp[i]); 
            }
            List<String> list = new ArrayList<String>();
            list = map.getOrDefault(t, list);
            list.add(str);
            map.put(t,list);
        }
        return new ArrayList<List<String>>(map.values());

    }
}

（5）73. 矩阵置零

我的思路：先遍历一遍矩阵，记录0元素所在行和列，再分别将行和列改为0；

class Solution {
    public void setZeroes(int[][] matrix) {
       boolean[] col = new boolean[matrix[0].length];
       boolean[] row = new boolean[matrix.length];
        for(int i = 0; i < matrix.length; i++){
            for(int j = 0; j < matrix[0].length; j++){
                if(matrix[i][j] == 0){
                    row[i] = true;
                    col[j] = true;
                }

            }
        }
        for(int i = 0; i < matrix.length; i++){
            if(row[i]){
                for(int j = 0; j < matrix[0].length; j++){
                    matrix[i][j] = 0;
                }
            }
        }
        for(int j = 0; j < matrix[0].length; j++){
            if(col[j]){
                for(int i = 0; i < matrix.length; i++){
                    matrix[i][j] = 0;
                }
            }
        }
    }
}

（6）146. LRU 缓存

python

class LRUCache:
    def __init__(self, capacity: int):
        self.count = capacity
        self.lis = []
        self.dic = {}
    def get(self, key: int) -> int:
        if key in self.dic:
            self.lis.remove(key)
            self.lis.append(key)
            return self.dic[key]
        else:
            return -1
    def put(self, key: int, value: int) -> None:
        if key in self.dic:
            self.dic[key] = value
            self.lis.remove(key)
            self.lis.append(key)
        else:
            if self.count == 0:
                self.lis.append(key)
                del self.dic[self.lis.pop(0)]
                self.dic[key] = value
            else:
                self.dic[key] = value
                self.lis.append(key)
                self.count -= 1

题解思路：哈希表+双向链表,使用hashmap存储key-value，同时使用双向链表管理key的出入

class LRUCache {
    class DLinkedNode{
        int key;
        int value;
        DLinkedNode prev;
        DLinkedNode next;
        public DLinkedNode(){
        }
        public DLinkedNode(int key, int value){
            this.key = key;
            this.value = value;
        }
    }
    private Map<Integer, DLinkedNode> cache = new HashMap<Integer, DLinkedNode>();
    private int size;
    private int capacity;
    private DLinkedNode head,tail;
    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head.next = tail;
        tail.prev = head;
    }
    public int get(int key) {
        DLinkedNode node = cache.get(key);
        if(node == null){
            return -1;
        }else{
            moveToHead(node);
            return node.value;
        }
    }
    public void put(int key, int value) {
        DLinkedNode node = cache.get(key);
        if(node == null){
            DLinkedNode newNode = new DLinkedNode(key,value);
            cache.put(key,newNode);
            addToHead(newNode);
            size++;
            if(size > capacity){
                DLinkedNode tail = removeTail();
                cache.remove(tail.key);
                size--;
            }
        }else{
            node.value = value;
            moveToHead(node);
        }
    }
    private void addToHead(DLinkedNode node){
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
    }
    private void removeNode(DLinkedNode node){
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }
    private void moveToHead(DLinkedNode node){
        removeNode(node);
        addToHead(node);
    }
    private DLinkedNode removeTail(){
        DLinkedNode res = tail.prev;
        removeNode(res);
        return res;
    }
}

（7）139. 单词拆分

错误思路：使用一个boolean变量标记是否可以拆分；用一个函数递归查找；当遇到很长的重复变量时，超出时间限制；
题解思路：动态规划，从开头由短至长检索子串是否可以拆分，去接与前长度为j的字符串是否可以拆分，以及后面这段字符是否在列表内；

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        int len = s.length();
        boolean[] dp = new boolean[len+1];
        dp[0] = true;
        for(int i = 0; i <= len; i++){
            for(int j = 0; j <= i; j++){
                if(dp[j] && wordDict.contains(s.substring(j,i))){
                    dp[i] = true;
                }
            }
        }
        return dp[len];
    }
}

（8）202. 快乐数

我的思路：使用一个列表记录前面出现过的数字，如果再次出现，说明进入死循环false。

class Solution {
    public boolean isHappy(int n) {
        if(n == 1){
            return true;
        }
        ArrayList<Integer> list = new ArrayList<Integer>();
        int temp = n;
        while(temp != 1){
            String s = (temp +"");
            int record = 0;
            for(int i = 0; i < s.length(); i++){
                record += (s.charAt(i)-'0')*(s.charAt(i)-'0');
            }
            temp = record;
            if(list.contains(temp)){
                return false;
            }
            list.add(temp);
        }
        return true;
    }
}

题解其他思路：快慢指针法；

（9）147. 对链表进行插入排序

我的思路：从前往后插入。先遍历一遍获得链表长度len，将执行len-1次插入，使用temp复制一个要插入的节点，将原来的节点删除，每次插入先移动到有序链表的前面，再进行比较，如果temp大于当前节点，且下一个节点不为null，后移，如果temp小于当前节点，将其插入该节点前，否则插入节点后。

class Solution {
    public ListNode insertionSortList(ListNode head) {
        if(head == null && head.next == null){
            return head;
        }              
        ListNode dummy = new ListNode(0,head);
        ListNode pre = dummy;
        ListNode cur = head;
        int len = 0;
        while(cur != null){
            cur = cur.next;
            len++;
        }
        for(int i = 0; i < len-1; i++){
            int moveCount = len-i-2;
            ListNode temp = new ListNode(dummy.next.val);
            dummy.next = dummy.next.next;
            pre = dummy;
            cur = dummy.next;
            while(moveCount > 0){
                pre = pre.next;
                cur = cur.next;
                moveCount--;
            }
            while(cur != null && cur.next != null && temp.val > cur.val){
                pre = pre.next;
                cur = cur.next;
            }
            if(temp.val <= cur.val){
                temp.next = cur;
                pre.next = temp;
            }else{
                cur.next = temp;
            }
             
        }
        return dummy.next;
    }
}

（10）106. 从中序与后序遍历序列构造二叉树（错1）

class Solution {
    int post_idx;
    int[] postorder;
    int[] inorder;
    Map<Integer,Integer> idx_map = new HashMap<Integer, Integer>();

    public TreeNode buildTree(int[] inorder, int[] postorder) {
        this.inorder = inorder;
        this.postorder = postorder;
        post_idx = postorder.length-1;
        
        int idx = 0;
        for(Integer val: inorder){
            idx_map.put(val,idx++);
        }
        return findRoot(0,inorder.length-1);
    }
    public TreeNode findRoot(int in_left, int in_right){
        if(in_left > in_right){
            return null;
        }
        int root_val = postorder[post_idx];
        TreeNode root = new TreeNode(root_val);
        
        int index = idx_map.get(root_val);

        post_idx--;
        root.right = findRoot(index+1, in_right);
        root.left = findRoot(in_left, index-1);
        return root;
    }
}
eyeyeyyyyys
关注
leetcode刷题笔记
m0_58600477的博客
12-31 1514
这里写目录标题剑指offer1.整数除法2.二进制加法3.前 n 个数字二进制中 1 的个数4.只出现一次的数字5.单词长度的最大乘积6.排序数组中两个数字之和7.数组中和为 0 的三个数8.和大于等于 target 的最短子数组9.乘积小于 K 的子数组10.和为 k 的子数组11.0 和 1 个数相同的子数组12.左右两边子数组的和相等反转链表 剑指offer.....................
谷歌高畅Leetcode刷题笔记.pdf
08-04
这本书名为《LeetCode101：和你一起你轻松刷题（C++）》的电子书，作者高畅ChangGao，旨在帮助有C++基础但缺乏刷题经验的读者。本文将详细阐述该电子书中提及的IT知识点，覆盖算法与数据结构两大板块，以及十五个...
LeetCode刷题笔记
m0_73731708的博客
06-12 944
第二遍重新遍历链表，同时记录前缀和 sum，哈希表中对应 sum 的节点是最后一次出现相同前缀和的节点，我们将这个节点的下一个节点，赋值给当前节点的下一个节点，中间跳过的部分总和即为 0。给你一个链表的头节点 head，反复删去链表中总和值为 0 的连续节点组成的序列。遍历一遍链表，同时记录前缀和，以当前前缀和为 key，当前节点为，存入哈希表中。简单来说就是，在原来链表基础上，头部添加0，利用前缀和的性质，前轴和相同时，两者之间的和为0(包括后一个)；两数之和梦开始的地方，让我们开始追逐自己的梦想吧！
LeetCode刷题笔记4——栈
weixin_47692652的博客
03-16 184
LeetCode刷题笔记4——栈
Leetcode刷题笔记
qq_40636667的博客
03-17 198
1,首先从后向前查找第一个顺序对（i,i+1），满足a[i] < a[i+1] ,(后一个元素比前一个元素大，从i开始就不满足降序序列了)，比如例子中的4，从4开始不满足关系式a[i] < a[i+1]2.找到了顺序对，在区间[ i+1,n)中从后向前查找第一个元素j满足a[i] < a[j]. 较大数即为 a[j]， 比如例子中的5.3.交换a[i] 和a[j], 则【i+1,n)必定是降序。下一个排列 举例：1，2，3，4，5 -> 1，2，3，5，4。对于长度为n的排列a,
leetcode刷题笔记（c语言）
q13099138865的博客
10-10 204
4.函数要返回一个线性表作为结果，在函数中要用malloc申请这个线性表内存，不能直接申请数组，因为函数结束这个数组会被销毁。2.接上一条，如果不在输出数组末尾写上'\0'，则会报地址错误，可以用msmset，或者结束了加'\0'1.力扣如果要返回数组指针，该数组首元素不能是空，否则系统认为数组内全是空。10.malloc申请的内存就算不返回用也要在末尾加'\0'，不然报错。6.int型变量如果使用负值，就报错，类似地址溢出的错误。11.a[10]是定义了有十个元素的数组，元素为从0~9。
leetcode刷题笔记4
iamtasty的博客
03-17 77
来源：力扣（LeetCode） 链接：https://leetcodecn.com/problems/shuzuzhongzhongfudeshuzilcof 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 找出数组中重复的数字。 在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复...
LeetCode刷题笔记 --- python
纸短情长的博客
01-21 2233
Leecode刷题笔记
leetcode刷题笔记目录
timoraty的博客
09-27 185
leetcode刷题笔记目录，持续更新 按题号 题号 题目 题解 难度 标签 445 分发饼干 c++ 贪心算法 按算法
阿里大神的Leetcode刷题笔记.PDF
涛哥聊Python
03-28 1172
点击上方蓝色小字，关注“涛哥聊Python”重磅干货，第一时间送达今天推荐一个阿里朋友的算法刷题的开源项目。截至 2020 年 11 月，该开源项目配套的网站已经有一百二十万的访问量，在 ...
leetCode刷题笔记
qq452562499的博客
08-13 381
leetCode刷题笔记。
LeetCode 刷题笔记 with Java.zip
11-23
《LeetCode刷题笔记withJava》是一份专为Java开发者准备的算法实战指南，涵盖了LeetCode网站上前一百道编程挑战题目。这份资料旨在帮助程序员提升算法能力，掌握数据结构和问题解决技巧，对于准备面试或者想要提升...
LeetCode刷题笔记.rar
07-05
《LeetCode刷题笔记》是针对LeetCode这个在线编程挑战平台的个人学习心得与总结，主要涵盖数据结构和算法两大核心领域。LeetCode是一个全球知名的编程训练网站，它提供了丰富的编程题目，帮助开发者提升编程技能，...
LeetCode:LeetCode 刷题笔记(C++, Python 实现)
04-12
LeetCode刷题笔记 ＃ 标题 标签 1个 两次总和 哈希表 2个 加两个数字 链表 3 最长子串，无重复字符 细绳 4 两个排序数组的中位数 大批 5 最长回文子串 细绳 6 之字形转换 细绳 7 反整数 数学 8 字符串到整数 ...
谷歌师兄的leetcode刷题笔记-blog:博客
06-30
谷歌师兄的leetcode刷题笔记完美无瑕 一个基于 Tufte CSS 的漂亮、快速、兼容 AMP 的 Jekyll 主题。 Immaculate 真的很快，这要归功于 Google AMP。 当通过 Google 的 CDN 提供服务时，您会看到典型的...
Python世界：力扣29题两数相除算法实践
来知晓的博客
09-13 439
除法运算本质是减法，从理解原理到真正实现还是有距离，建议初步理解后，不参考任何代码，完全自己复现一遍，体会更深。注意提示：目的就是提醒越界问题：-2^31/-1=2&31，超过了整数表达范围。本问题来自于力扣29题，在做完大数相乘后，顺带也看下两数相除。将两数相除，要求不使用乘法、除法和 mod 运算符。给定两个整数，被除数。
【Hot100】LeetCode—64. 最小路径和
weixin_44382896的博客
09-12 505
64. 最小路径和。
【JavaScript】LeetCode：707设计链表
最新发布
weixin_45980065的博客
09-14 661
【代码】【JavaScript】LeetCode：707设计链表。
LeetCode 692.前K个高频单词
m0_63816268的博客
09-13 361
首先用map存储该字典，然后放进vector进行排序，注意sort的排序规则与我们想要的规则不一致，所以我们需要写一个伪函数来判断second(value值)，由于该题要求了稳定性，所以我们在伪函数还需要继续判断相等情况的顺序。排完序后用vector将前k个单词存储起来返回。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值