LeetCode Hot 100~Day2

最新推荐文章于 2024-07-22 16:27:42 发布
最新推荐文章于 2024-07-22 16:27:42 发布
阅读量1.2k 收藏 1
点赞数 1
分类专栏： Java 算法训练 文章标签： leetcode 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58284486/article/details/128284356
版权

目录

三数之和

电话号码的字母组合

括号生成

合并k个升序链表 

下一个排列 

搜索旋转排序数组 

在排序数组中查找元素的第一个和最后一个位置 

组合总数 

全排列

旋转图像

三数之和

题目链接：15.三数之和

 示例

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

解题思路

双指针思想，先对数组进行排序，排序后从第一个位置开始枚举，需要确保下一个枚举的数不等于本次枚举的数，如果相等，得到的结果是相同的。 

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        int n = nums.length;
        Arrays.sort(nums);
        List<List<Integer>> ret = new ArrayList<>();
        for (int first = 0; first < n; first++) {
            //保证与上一次枚举的数不同
            if (first > 0 && nums[first] == nums[first - 1]) {
                continue;
            }
            int third = n - 1;
            int target = -nums[first];
            //-4 -1 -1 0 1 2
            for (int second = first + 1; second < nums.length; second++) {
                //保证与上一次枚举的不同
                if (second > first + 1 && nums[second] == nums[second - 1]) {
                    continue;
                }
                //保证second在third的左边
                while (second < third && nums[second] + nums[third] > target) {
                    third--;
                }
                //指针重合就退出循环
                if (second == third) {
                    break;
                }
                if (nums[second] + nums[third] == target) {
                    List<Integer> list = new ArrayList<>();
                    list.add(nums[first]);
                    list.add(nums[second]);
                    list.add(nums[third]);
                    ret.add(list);
                }
            }
        }
        return ret;
    }
}

电话号码的字母组合

题目链接：17.电话号码的字母组合

示例

输入：digits = "23"

输出：["ad","ae","af","bd","be","bf","cd","ce","cf"] 

解题思路 

维护一个深度和当前的可能的字母组合，当输入的数字长度等于深度时，就将当前的字母组合加入到结果集中，结束该路径并继续向上回溯；根据深度找到当前的数字，再根据这个数字得到该数字所代表的字符，依次遍历每一种可能，直至所有字符遍历结束。

class Solution {
    String[] mapString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
    List<String> ret = new ArrayList<>();
    public List<String> letterCombinations(String digits) {
        if (digits == null || digits.length() == 0) {
            return ret;
        }
        StringBuilder s = new StringBuilder("");
        dfs(digits, s, 0);
        return ret;
    }

    private void dfs(String digits, StringBuilder s, int depth) {
        if (depth == digits.length()) {
            ret.add(s.toString());
            return;
        }
        int index = digits.charAt(depth) - '0';
        String curMap = mapString[index];
        for (int i = 0; i < curMap.length(); i++) {
            dfs(digits, s.append(curMap.charAt(i)), depth + 1);
            s.deleteCharAt(s.length() - 1);
        }
    }
}

括号生成

题目链接： 22.括号生成

解题思路

回溯思想，只在序列有效时添加括号，通过跟踪当前的左括号和右括号数来实现，如果左括号数量不大于n，添加左括号，如果右括号数量小于左括号，添加左括号，当括号数量等于2*n，加入结果集 

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> ret = new ArrayList<>();
        dfs(ret, new StringBuilder(), 0, 0, n);
        return ret;
    }

    private void dfs(List<String> ret, StringBuilder cur, int open, int close, int n) {
        if (cur.length() == n * 2) {
            ret.add(cur.toString());
            return;
        }
        if (n > open) {
            cur.append('(');
            dfs(ret, cur, open + 1, close, n);
            cur.deleteCharAt(cur.length() - 1);
        }
        if (open > close) {
            cur.append(')');
            dfs(ret, cur, open, close + 1, n);
            cur.deleteCharAt(cur.length() - 1);
        }
    }
}

合并k个升序链表 

题目链接：23.合并k个升序链表

 解题思路

分治思想，要合并k个升序链表，则首先将每两个链表合并，第一轮合并过后，继续两两合并，直至得到最终结果。

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) {
            return null;
        }
        return merge(lists, 0, lists.length - 1);
    }
    private ListNode merge(ListNode[] lists, int start, int end) {
        if (start == end) {
            return lists[end];
        }
        int mid = (start + end) / 2;
        ListNode l1 = merge(lists, start, mid);
        ListNode l2 = merge(lists, mid + 1, end);
        return mergeTwoList(l1, l2);
    }
    private ListNode mergeTwoList(ListNode l1, ListNode l2) {
        if (l1 == null || l2 == null) {
            return l1 == null ? l2 : l1;
        }
        if (l1.val > l2.val) {
            l2.next = mergeTwoList(l1, l2.next);
            return l2;
        } else {
            l1.next = mergeTwoList(l1.next, l2);
            return l1;
        }
    }
}

下一个排列 

题目链接：31.下一个排列

 示例

输入：nums = [1,2,3]

输出：[1,3,2]

解题思路：将左边的一个较小数与右边的一个较大数进行交换，需要满足左边的较小数尽可能靠右，较大数尽可能的小，再交换结束后，再将较大数右边的数按照升序重新排列即可 

class Solution {
    public void nextPermutation(int[] nums) {
        //8 5 3 6 2 1
        int i = nums.length - 2;
        while (i >= 0 && nums[i] >= nums[i + 1]) {
            i--;
        }
        if (i >= 0) {
            int j = nums.length - 1;
            while (j >= 0 && nums[j] <= nums[i]) {
                j--;
            }
            swap(nums, i, j);
        }
        reverse(nums, i + 1);
    }
    private void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
    private void reverse(int[] nums, int start) {
        int end = nums.length - 1;
        while (start < end) {
            swap(nums, start, end);
            start++;
            end--;
        }
    }
}

搜索旋转排序数组 

题目链接：33. 搜索旋转排序数组

 

示例

输入：nums = [4,5,6,7,0,1,2], target = 0

输出：4

解题思路：二分思想，查找相当于是不断地缩小范围，通过nums[mid]、nums[left]、nums[right]、target的对比，不断缩小范围，直至获得结果或者左边界left > 右边界right为止.

class Solution {
    //1 2 3 4 5
    //2 3 4 5 1
    //5 1 2 3 4
    public int search(int[] nums, int target) {
        if (nums.length == 0 || nums == null) {
            return -1;
        }
        if (nums.length == 1) {
            return nums[0] == target ? 0 : -1;
        }
        int left = 0;
        int right = nums.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] == target) {
                return mid;
            }
            if (nums[left] <= nums[mid]) {
                if (nums[mid] >= target && nums[left] <= target) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            } else {
                if (nums[right] >= target && nums[mid] <= target) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
        }
        return -1;
    }
}

在排序数组中查找元素的第一个和最后一个位置 

题目链接：34. 在排序数组中查找元素的第一个和最后一个位置

 

 示例

输入：nums = [5,7,7,8,8,10], target = 8

输出：[3,4]

输入：nums = [5,7,7,8,8,10], target = 6

输出：[-1,-1]

解题思路：二分查找，查找第一个大于等于target的下标位置，即为第一个位置，查找第一个大于target的下标，即为最后一个位置，因为可能不存在target，因此在查询结束后验证一下left和right下标对应的值是否为target，如果是则输出，left，right，反之输出-1，-1. 

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int left = binarySearch(nums, target, true);
        int right = binarySearch(nums, target, false) - 1;
        if (left <= right && right < nums.length && nums[left] == target && nums[right] == target) {
            return new int[]{left, right};
        }
        return new int[]{-1, -1};
    }
    private int binarySearch(int[] nums, int target, boolean lower) {
        int left = 0;
        int right = nums.length - 1;
        int ret = nums.length;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] > target || (lower && nums[mid] >= target)) {
                right = mid - 1;
                ret = mid;
            } else {
                left = mid + 1;
            }
        }
        return ret;
    }
}

组合总数 

题目链接：39. 组合总和

 示例

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

解题思路：由于同一个数字可以无限制重复被选取，因此每次从上一个位置开始搜索，边界值的设定：当目前的累加值大于给定的值就返回，当累加值等于给定的值就将其加入结果集中。 

class Solution {
    List<List<Integer>> ret = new ArrayList<>();
    List<Integer> curRet = new ArrayList<>();
    int curAdd = 0;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        if (candidates == null || candidates.length == 0) {
            return ret;
        }
        dfs(candidates, target, 0);
        return ret;
    }
    private void dfs(int[] candidates, int target, int pre) {
        if (curAdd > target) {
            return;
        }
        if (curAdd == target) {
            ret.add(new ArrayList<>(curRet));
            return;
        }
        for(int i = pre; i < candidates.length; i++) {
            if (candidates[i] > target) {
                continue;
            }
            curRet.add(candidates[i]);
            curAdd += candidates[i];
            dfs(candidates, target, i);
            curAdd -= curRet.get(curRet.size() - 1);
            curRet.remove(curRet.size() - 1); 
        }
    }
}

全排列

题目链接：46. 全排列

 

示例

输入：nums = [1,2,3]

输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

解题思路：回溯算法，依次从每个位置开始添加元素，注意需要维护一个数组来记录每个下标对应的值是否已经添加到排列中，如果已经添加则不需要继续添加，反之，则添加入排列中。 

class Solution {
    List<List<Integer>> ret = new ArrayList<>();
    List<Integer> curRet = new ArrayList<>();
    public List<List<Integer>> permute(int[] nums) {
        if (nums == null || nums.length == 0) {
            return ret;
        }
        int[] visited = new int[nums.length];
        dfs(nums, visited);
        return ret;
    }
    private void dfs(int[] nums, int[] visited) {
        if (curRet.size() == nums.length) {
            ret.add(new ArrayList<>(curRet));
            return;
        }

        for (int i = 0; i < nums.length; i++) {
            if (visited[i] == 1) {
                continue;
            }
            visited[i] = 1;
            curRet.add(nums[i]);
            dfs(nums, visited);
            visited[i] = 0;
            curRet.remove(curRet.size() - 1);
        }
    }
}

旋转图像

题目链接：48. 旋转图像

 

解题思路：找规律问题，先水平翻转一次，再沿着对角线翻转一次即可得到结果 

class Solution {
    public void rotate(int[][] matrix) {
        int n = matrix.length;
        //水平翻转
        for (int i = 0; i < n / 2; i++) {
            for (int j = 0; j < n; j++) {
                int tmp = matrix[i][j];
                matrix[i][j] = matrix[n - i - 1][j];
                matrix[n - i - 1][j] = tmp;
            }
        }
        //对角线翻转
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < i; j++) {
                int tmp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = tmp;
            }
        }
    }
}

 

 

 

Li_yizYa
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
leetcode数组下标大于间距-leetcode-hot100:leetcode-hot100-python
06-30
leetcode-hot100 leetcode-hot100-python 关键词与解题思路（实时更新） Hot100 按出现频率排序—解题思路 review 1-10 两数之和。Hashmap，空间换时间，扩展：on 时间复杂度寻找两数之差等于定值，用在求子数组和为...
LeetCode-Hot-100
03-25
《LeetCode-Hot-100》是针对程序员面试中热门的100道LeetCode题目集合，主要涉及C++编程语言。LeetCode是一个在线平台，提供了一系列算法问题，旨在帮助开发者提升编程技能，尤其是面试准备阶段。这些题目涵盖了数据...
LeetCode Hot 100~Day3
qq_58284486的博客
12-26 373
LeetCode Hot 100~
LeetCode Hot 100~Day1
qq_58284486的博客
12-12 366
挑战十天完成leetcode hot 100~第一天
leetcode hot100_day20
weixin_45782005的博客
04-14 788
4/14/2024。
leetcode hot100_day08
weixin_45782005的博客
03-13 1057
思路：先获取两个链表的长度差，让长度较长的链表先走长度差个步数，然后在开始一起遍历直到地址相等的位置返回。注意审题，一开始没过的原因是头结点搞错了，题目中的头结点就是链表的第一个含值节点，而不是附加的头结点。关于官方的方法，首先是哈希表感觉前面做二叉树的时候见过，将其中一个链表的所有元素都加入哈希表，然后查找另一个链表中是否有元素存在其中。官方的第二种解法就是数学，画个图也就明白了，不过多叙述。
leetcode hot100_day05
weixin_45782005的博客
03-06 796
这题比较简单，就不贴代码了，主要是要注意不能中序遍历，可以想象一棵最简单的二叉树，首先是遍历完左孩子，然后执行交换左右孩子，再去遍历右孩子，这时遍历的右孩子其实是没遍历前的左孩子，如果左孩子还有孩子那么在根节点翻转之前已经遍历过了，翻转之后再遍历翻转相当于没翻转。就这样吧，写的很明白了。在这道题中也是一样的道理，二叉树从根节点到某个子节点的路径是唯一的。这题是medium，自己ac了，但是是笨法子，看题目肯定是要遍历完所有路径的，2点要求：路径只能往下走，路径开头不一定是根节点。
leetcode hot100_day10
weixin_45782005的博客
03-18 439
题目里说拼接，那应该不能复制，地址不能变，这个题目不知道做过多少次了，看到这个总会想到归并排序。
leetcode hot100_day06
weixin_45782005的博客
03-11 358
以为想到了却又没想到，最后还是屎山代码憋出来了。这道hard说难也不难。分析题目，主要是路径，这个路径可以是跨越根节点的，也就是可以左根右这种，之前做的遍历题目都是从根节点出发不会出现横跨根节点的路径。对于二叉树类的复杂题目，好像还是先考虑最简单的二叉树情况然后递归，因此如果是最简单的三个节点的二叉树，它的最大路径和都有6种，三个节点和三个组合（根+左，根+右，左+根+右），我们需要分类讨论，这也是DP（dynamic programing）的一个重要思想。
leetcode hot100_day01
weixin_45782005的博客
02-29 383
还是看题解完成的，结果输出树的根节点，应该就是这个树的层序遍历，root是根节点，一开始还没特别明白，好像也不是层序遍历。题目的要求是构造二叉树返回根节点。在这里有个问题，ArrayList是定义的包装类，而add的是int类型，得益于Java的自动装箱（大佬勿喷）。才能复原二叉树，要恢复二叉树必须知道中序序列，只是知道前序和后序，不能恢复二叉树，因为不知道中序序列无法获知根节点的左右子树位置。105.从前序和中序序列构造二叉树Medium。已经忘完了，前中后序遍历指的是根节点的顺序。
leetcode hot100_day02
weixin_45782005的博客
02-29 400
如果当前节点为null，说明遍历到了叶子节点，这时更新最大深度。不可以在更新之后马上置零，首先置零就是不对，毕竟递归返回时深度是逐渐减一，应该在遍历完右子树的时候减一，也就是弹栈的时候，更简明的说，深度减一的时候应该发生在当前层遍历完的时候。在每次遍历到达叶子节点的时候，为当前最长路径并更新结果， 关键是到达叶子节点后的做法，附上自己的代码。仔细体会一下好像是在弹栈的时候直接进行深度的计算，比我那个简单，我是出入栈时对深度加减。，和一般的BFS不同的是，这里记录每层节点的个数，更够出队节点个数个元素。
lrucacheleetcode-leetcode-hot-100:LeetCode热题HOT100
06-29
热题100的思路及解决方法 简单 1. 两数之和 LeetCode地址: class Solution: def twoSum(self, nums: List[int], target: int) -> List[int]: if not nums: return [] usedNums = {} for index, num in enumerate...
什么水平能刷leetcode-leetcode::airplane_departure:Tujietg的leetcode刷机记录~
06-30
2⃣ 遍历，一个一个条件的判断。 No53 设置max字段的初始值为最小的整数。 No66 该算法解法中做了合适的小于9的判断。 No88 插入之后采用Arrays.sort()排序。 No121 一次死循环，利用中间值做判断。 No122 一次循环...
lrucacheleetcode-leetcode:记录自己的leetcode解题历程~Welcomeeveryonetocomment:grinning_face:~
06-29
lru缓存leetcode 我们使用python来处理关于leetcode和linkcode的话题。 leetcode 网址 = 链接代码网址 = 大致分为几个主题： ————————————————————————————————————————...
stack(leetcode练习题,牛客)
2301_81692739的博客
07-19 444
最开始写的，总会有一些样例过不了，没考虑全，后来看题解上的方法，将下标压入栈中，用右括号的下标减去栈顶下标，就是有效长度。不然只顾着最长，反而无法得到正确的有效长度。一个完整的括号，要么是1，要么里边包含其他括号，进行了 *2。所以，可以每遇到一个右括号，进行一次运算，第一次为 1，以后每次乘二，累加到栈顶。遇到左括号，就向栈压入0，重新运算，当遇到右括号，再弹出.如果数字比栈顶小就压入，否则，将栈顶删除直到，比栈顶小或这栈为空。关于stack的知识，可以看点击查看上面的博客，以下题目全在。
力扣 102题 二叉树的层次遍历 记录
最新发布
m0_49800270的博客
07-22 623
队列是一种先进先出（FIFO）的数据结构，非常适合于层序遍历，因为我们总是希望按照从树的上层到下层的顺序处理节点。队列操作：使用一个队列来管理待处理的树节点。队列的先进先出特性保证了树的每一层都按照从左到右的顺序被处理。
leetcode hot100 （面试复习用）
大厂小码农的博客
07-20 916
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。输入：nums = [5,7,7,8,8,10], target = 8输出：[3,4]// 继续向左查找} else {// 查找目标值在数组中的结束位置// 继续向右查找} else {
【LeetCode】分隔链表
qq_26521261的博客
07-20 423
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
leetcode hot100有哪些
05-30
Hot 100题目是指LeetCode中最热门的100道题目，这些题目涵盖了许多经典的算法和数据结构问题，非常适合提高编程能力和算法水平。以下是LeetCode Hot 100题目的一些例子： 1. Two Sum 2. Add Two Numbers 3. Longest...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Li_yizYa

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

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

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

打赏作者

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

抵扣说明：

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

余额充值