LeetCode Hot 100 题解[java版本，冲大厂]

LeetCode Hot 100 题解[java版本，冲大厂]

1. 两数之和

题目描述

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

你可以按任意顺序返回答案。

思路：

使用HashMap构建哈希表，然后需要注意一下里面的键值对。

每遍历一个元素，看看 hashMap 中是否存在满足要求的目标数字。

注意查询的时候，查询的是target - nums[i]

时间复杂度为O(n),空间复杂度也为O（n)

代码：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        //哈希表思路
        HashMap<Integer, Integer> map = new HashMap<>();
        int n = nums.length;
        for(int i = 0; i < n; i++){
            if(map.containsKey(target - nums[i])){
                return new int[]{map.get(target - nums[i]), i};
            }else{
                map.put(nums[i], i);
            }
        }
        return new int[]{};
    }
}

2. 字母异位词分组

题目描述

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的所有字母得到的一个新单词。

思路：

属于hash表的题目，只不过需要注意一下，传入hash里面的键值对的形式。

传入的键是排序好的字符；传入的值是没有排序的字符的list表

每次遍历字符串数组得到的字符串，先对其进行排序，排序之后，在将其插入hash表中

注意hash表中一个比较好的用法就是getOrDefault，如果没有，我们就new一个新的ArrayList

最后面，hash的值就是我们要返回的数据，可以直接使用values()方法获取到hash表当中的值

代码：

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        //对每个字符串进行排序,排序完之后，加入hash表
        HashMap<String, ArrayList<String>> map = new HashMap<>();
        for(String str : strs){
            char ch[] = str.toCharArray();      //先转化为字符数组，方便排序
            Arrays.sort(ch);                    //排序
            String compare = new String(ch);    //再转化为string，方便hash表比较
            ArrayList<String> list = map.getOrDefault(compare, new ArrayList<String>());
            list.add(str);
            map.put(compare, list);             //将新的list插入hash表
        }
        return new ArrayList<>(map.values());   //将hash表的值作为返回值，返回
    }
}

3. 最长连续序列

题目描述

给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。

请你设计并实现时间复杂度为 O(n) 的算法解决此问题。

思路：

一开始这里本来想着可以尝试使用数组模拟hash表的实现。

但是写完之后，发现这个数组里面的元素可能是负数就不好处理。

然后就使用hashset,但是由于hashset的话，不好判断是不是起点。

所以这里有一步是比较关键就是set.contains(x-1).

如果这个都不存在，那么说明x就是整个连续序列的起点。

代码：

class Solution {
    public int longestConsecutive(int[] nums) {
        //最长连续序列，采用整数数组模拟hash表,有负数怎么处理？不好处理负数，采用hashset，
        //采用hashset怎么按断是起点，看看前一个结点在不在hashset当中，如果前一个结点不在hashset当中，说明就是起点
        HashSet<Integer> set = new HashSet<>();
        //先全部存入hashset当中，然后再遍历hashset
        for(int x : nums){
            set.add(x);
        }
        int ans = 0;                     //返回的最长的连续序列的长度
        for(int x : nums){
            if(!set.contains(x-1)){     //不存在前一个结点，说明是起点
                int len = 0;
                while(set.contains(x)){
                    x++;
                    len++;
                }
                ans = Math.max(ans, len);       //保存更长的长度
            }
        }
        return ans;
    }
}

4. 移动零

题目描述

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

思路：

双指针解法的话，就是多使用一个变量k来保留变量。

但是就是有一个问题，后面k之后的怎么变成数字零。

比较暴力的解法就是，在全部非零数字往前移动了之后，直接再来一个for循环，从k开始遍历，往后的元素全部置为零。

还有一个就是比较优雅的解法。

就是采用一个临时变量，先保存这个元素的值，然后再对其进行赋值。

解法一代码：

class Solution {
    public void moveZeroes(int[] nums) {
        //双指针类型的题目，移动0，需要保持非零元素的相对顺序
        int k = 0;
        //先将非0元素往前移动
        for(int i =0; i < nums.length; i++){
            if(nums[i] != 0){
                nums[k++] = nums[i];
            }
        }
        //然后再对后面的元素进行赋值为0
        for(int i = k; i < nums.length; i++){
            nums[i] = 0;
        }

    }
}

解法二代码：

class Solution {
    public void moveZeroes(int[] nums) {
        //双指针类型的题目，移动0，需要保持非零元素的相对顺序
        int k = 0;
        for(int i =0; i < nums.length; i++){
            if(nums[i] != 0){
                int temp = nums[i];     //先保留这个位置的元素的值
                nums[i] = 0;            //直接将这个位置的元素置为0，方便后序不需要再for循环置为0
                nums[k++] = temp;       //这里就利用前面保留的值，进行赋值。
            }
        }
    }
}

5. 盛最多水的容器

题目描述

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

**说明：**你不能倾斜容器。

思路：

这个就是比较典型的左右双指针解法。

左指针和右指针，看谁的高度更低，就走哪个。

然后计算容器的高度也是看更低的那个。

整个代码都比较简单。

代码：

class Solution {
    public int maxArea(int[] height) {
        //双指针解法，左指针和右指针，看哪个比较短，短的先走
        int n = height.length;
        int left = 0,  right  = n - 1;
        int maxWater = 0;
        while(left < right){
            //高度取较低的那个
            int len = height[left] > height[right] ? height[right] : height[left];
            int curWater = len *  (right - left);
            maxWater = Math.max(curWater, maxWater);
            //高度更新较低的那个，这样才能保证下次找到更大的
            if(height[left] > height[right]){
                right--;
            }else{
                left++;
            }
        }
        return maxWater;
    }
}