leetcode简单题解（一）

最新推荐文章于 2022-08-09 08:54:09 发布

Magic171

最新推荐文章于 2022-08-09 08:54:09 发布

阅读量1.3k

点赞数 3

分类专栏：刷题笔记文章标签： leetcode java 算法数组排序

本文链接：https://blog.csdn.net/magic171/article/details/119429611

版权

刷题笔记专栏收录该内容

9 篇文章 1 订阅

订阅专栏

文章目录

一、存在重复元素
二、两数之和 II - 输入有序数组
三、两数之和
四、移除元素
五、删除有序数组中的重复项
六、合并两个有序数组
七、有序数组的平方
八、移动零
九、旋转数组
十、二分查找
十一、第一个错误的版本
十二、搜索插入位置
十三、反转字符串
十四、反转字符串中的单词 III
总结

一、存在重复元素

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/contains-duplicate

描述：

给定一个整数数组，判断是否存在重复元素。

如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

示例：

输入: [1,2,3,1]
输出: true

解决：

执行用时：5 ms， 在所有 Java 提交中击败了61.32%的用户
内存消耗：42.5 MB, 在所有 Java 提交中击败了46.56%的用户

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Set numss=new HashSet();
        for(int i=0;i<nums.length;i++){
            if(!numss.add(nums[i])){
                return true;
            }
        }
        return false;
    }
}
直接暴力的话应该会超时，所以可以利用set不能存储相同值的特性，将数组元素一个个添加到hashset中，添加失败就是有重复值。

二、两数之和 II - 输入有序数组

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted

描述：

给定一个已按照 升序排列  的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。

函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 1 开始计数 ，所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。

你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。

示例1：

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。

示例2：

输入：numbers = [2,3,4], target = 6
输出：[1,3]

示例3：

输入：numbers = [-1,0], target = -1
输出：[1,2]

解决：

执行用时：1 ms, 在所有 Java 提交中击败了72.64%的用户
内存消耗：38.7 MB, 在所有 Java 提交中击败了29.02%的用户

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int i=0;
        int j=numbers.length-1;
        int[] re=new int[2];
        while(i<j){
            if(numbers[i]+numbers[j]==target){
                re[0]=i+1;
                re[1]=j+1;
                return re;
            }
            if(numbers[i]+numbers[j]>target){
                j--;
            }
            if(numbers[i]+numbers[j]<target){
                i++;
            }
        }
        return re;
    }
}
直接双指针，因为题中给的是升序的数组，所以让两个哨兵相加的话，如果大于给定值，那必然是右边界过大，所以j--；同理小于也是一样。

三、两数之和

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum

描述：

给定一个整数数组 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
只会存在一个有效答案

进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？

解决：

执行用时：2 ms, 在所有 Java 提交中击败了89.63%的用户
内存消耗：38.7 MB, 在所有 Java 提交中击败了26.46%的用户

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] numss=new int[2];
        HashMap<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<nums.length;i++){
            if(map.get(target-nums[i])!=null){
                numss[1]=i;
                numss[0]=map.get(target-nums[i]);
                return numss;      
          }
            map.put(nums[i],i);//这个不能放在if判断的上面，例如nums=[3,3]时，当i=1时，如果先map.put(),则因为key相同，会覆盖
        }
        return numss;
    }
}
直接暴力是n方，利用map的键值对是n。思路就是一层循环，同时把循环的数加入到map里面，假如循环到了i，那么接下来要找的数就是(目标值-i)，那么直接map获取值就可以得到下标。

四、移除元素

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-element

描述：

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。




说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

示例2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

解决：

执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：37.1 MB, 在所有 Java 提交中击败了35.95%的用户

一.双指针版
class Solution {
    public int removeElement(int[] nums, int val) {
        if(nums.length==0){
            return 0;
        }
        int i=0;
        int j=nums.length-1;
        int n=0;
        for(;i<j;){
            if(nums[i]==val&&nums[j]!=val){
                int temp=nums[i];
                nums[i]=nums[j];
                nums[j]=temp;
                n++;
                j--;
                i++;
            }else if(nums[i]==val&&nums[j]==val){
                j--;
            }else{
                i++;
                n++;
            }
        }
        if(nums[i]!=val)
             n++;
        return n;
    }
}

二.正常的解法
class Solution {
    public int removeElement(int[] nums, int val) {
        int i=0;
        for(int j=0;j<nums.length;j++){
            if(nums[j]!=val){
                nums[i]=nums[j];
                i++;
            }
        }
        return i;
    }
}
可能是我最近刷的基本都是双指针的题，所以看到这个题的第一念头就是双指针......过了之后看题解才发现压根用不着......不过时间复杂度都是一样的，只是空间上略微多了一些。

五、删除有序数组中的重复项

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array

描述：

给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。



为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例1：

输入：nums = [1,1,2]
输出：2, nums = [1,2]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例2：

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

解决：

执行用时：1 ms, 在所有 Java 提交中击败了94.59%的用户
内存消耗：39.9 MB, 在所有 Java 提交中击败了41.94%的用户

class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums.length==0)
            return 0;
        int n=0;
        int i=1;
        for(i=1;i<nums.length;i++){
            if(nums[i]!=nums[i-1]){
                nums[n]=nums[i-1];
                n++;
            }
        }
        nums[n]=nums[i-1];
        n++;
        return n;
    }
}
得益于上一道题，这个我没用双指针，虽然评论区几乎都是用的双指针，但是速度上这个是1ms，更快。

六、合并两个有序数组

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-sorted-array

描述：

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

示例1：

输入：nums = [1,1,2]
输出：2, nums = [1,2]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例2：

输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。

解决：

执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：38.7 MB, 在所有 Java 提交中击败了5.27%的用户

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int[] nums3=new int[m+n];
        int k=0;
        int i=0;
        int j=0;
        for(;i<m&&j<n;){
            if(nums1[i]>nums2[j]){
                nums3[k++]=nums2[j++];
            }else{
                nums3[k++]=nums1[i++];
            }
        }
        if(i<m){
            for(;i<m;){
                nums3[k++]=nums1[i++];
            }
        }
        if(j<n){
             for(;j<n;j++){
                nums3[k++]=nums2[j];
            }
        }
        for(int l=0;l<m+n;l++){
            nums1[l]=nums3[l];
        }
    }
}
由这个题目的叙述，很容易想到，这不就是一个归并排序嘛。这个代码我觉得还可以再优化一下，直接覆盖原数组，而不用开辟额外空间，有时间做一下。

七、有序数组的平方

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/squares-of-a-sorted-array

描述：

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

提示：

1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按 非递减顺序 排序

解决：

执行用时：2 ms, 在所有 Java 提交中击败了43.13%的用户
内存消耗：40 MB, 在所有 Java 提交中击败了80.06%的用户

class Solution {
    public int[] sortedSquares(int[] nums) {
        int l=0;
        int r=nums.length-1;
        int[] numss=new int[nums.length];
        for(;l<=r;l++,r--){
            numss[l]=nums[l]*nums[l];
            numss[r]=nums[r]*nums[r];
        }
        Arrays.sort(numss);
        return numss;
    }
}
照本宣科的双指针；排序懒得写了，直接调方法。

八、移动零

描述：

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

示例：

输入: [0,1,0,3,12]
输出: [1,3,12,0,0]

提示：

1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按 非递减顺序 排序

解决：

执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：38.9 MB, 在所有 Java 提交中击败了7.50%的用户

class Solution {
    public void moveZeroes(int[] nums) {
        int n=0;
        for(int i=0;i<nums.length;i++){
            if(nums[i]!=0){
                nums[n]=nums[i];
                n++;
            }
        }
        if(n!=nums.length){
            for(;n<nums.length;n++){
                nums[n]=0;
            }
        }
    }
}
第一眼直接想拷贝个新数组，然后看到不允许.....，不过没什么区别，无非是在本数组重新赋值；将每个非零的按顺序赋给数组，如果有0存在，那么n一定小于数组长度，将其全部填充0就可以了

九、旋转数组

描述：

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

 

进阶：

尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？

示例 1：

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]

示例2：

输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释: 
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]

提示：

1 <= nums.length <= 2 * 104
-231 <= nums[i] <= 231 - 1
0 <= k <= 105

解决：

执行用时：1 ms, 在所有 Java 提交中击败了63.08%的用户
内存消耗：55.4 MB, 在所有 Java 提交中击败了32.55%的用户

解法一：
		class Solution {
		    public void rotate(int[] nums, int k) {
		        int[] numss=new int[nums.length];
		        int n=0;
		        if(nums.length==1){
		            return ;
		        }
		        for(int i=0;i<nums.length;i++){
		            if(i+k>=nums.length){
		                n=i+k;
		                while(n>=nums.length){
		                    n=n-nums.length;
		                }
		                numss[n]=nums[i];
		            }else{
		                numss[i+k]=nums[i];
		            }
		        }
		        System.arraycopy(numss ,0 ,nums ,0 ,nums.length);
		    }
		}
		中等题，我这个写法的思路和上一道差不多，区别是多拷贝了一个数组以及越界的问题，大多数和我一样的新手应该都会这么做，但这样写其实没什么意义。

解法二：
	class Solution {
	    public void rotate(int[] nums, int k) {
	        k %= nums.length;
	        reverse(nums, 0, nums.length - 1);
	        reverse(nums, 0, k - 1);
	        reverse(nums, k, nums.length - 1);
	    }
	
	    public void reverse(int[] nums, int start, int end) {
	        while (start < end) {
	            int temp = nums[start];
	            nums[start] = nums[end];
	            nums[end] = temp;
	            start += 1;
	            end -= 1;
	        }
	    }
	}
	这个解法是力扣官方的三种解法之一，非常巧妙的利用了一个事实：将一个数组全体反转一次，再将前k个单独反转一次，再将后面的单独反转一次，最后得到的就是全体数组前进了k步的数组。这不是一个多难推的规律，但一开始竟然没看出来......

解法三：官方还给了一种解法叫环状替换，不过不是很懂，有兴趣的可以自己去看看。

十、二分查找

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-search

描述:

给定一个 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

提示：

你可以假设 nums 中的所有元素是不重复的。
n 将在 [1, 10000]之间。
nums 的每个元素都将在 [-9999, 9999]之间。

解决：

执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：39.5 MB, 在所有 Java 提交中击败了18.35%的用户

class Solution {
  public int search(int[] nums, int target) {
    int k, i = 0, j = nums.length - 1;
    while (i <= j) {
      k = i + (j - i) / 2;
      if (nums[k] == target){
          return k;
      } 
      if (target < nums[k]){
          j = k - 1;
      }else{
          i = k + 1;
      }
    }
    return -1;
  }
}
顾名思义，二分查找。

十一、第一个错误的版本

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/first-bad-version

描述:

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。

假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

示例 1:

输入：n = 5, bad = 4
输出：4
解释：
调用 isBadVersion(3) -> false 
调用 isBadVersion(5) -> true 
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。

示例 2:

输入：n = 1, bad = 1
输出：1

提示：

1 <= bad <= n <= 231 - 1

解决：

执行用时：11 ms, 在所有 Java 提交中击败了99.93%的用户
内存消耗：35.1 MB, 在所有 Java 提交中击败了59.10%的用户

public class Solution extends VersionControl {
    public int firstBadVersion(int n) {
        int left=1;
        int right=n;
        while(left<right){
            if(isBadVersion(left+(right-left)/2))
                right=left+(right-left)/2;
            else
                left=left+(right-left)/2+1;
        }
        return left;
    }
}
这个题稍微变化了一点，但也不多，二分最难的实际上就是边界值的确定，这个题就是这儿变了一下。
思路如下：如果目前的中间值是一个错误的版本，则代表这个中间值可能是第一个错误版本，所以右边界应该退到这个值得位子上来，因为他还有嫌疑；反之则他完全没有嫌疑，所以左边界直接跳过他就行。
（话说这种题中这种产品经理早就被打死了吧....）

十二、搜索插入位置

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-insert-position

描述:

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1

提示：

1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 为无重复元素的升序排列数组
-104 <= target <= 104

解决：

执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：38 MB, 在所有 Java 提交中击败了57.75%的用户

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left=1;
        int right=nums.length;
        while(left<=right){
            if(nums[left+(right-left)/2-1]==target)
                return left+(right-left)/2-1;
            else if(nums[left+(right-left)/2-1]<target)
                left=left+(right-left)/2+1;
            else if(nums[left+(right-left)/2-1]>target)
                right=left+(right-left)/2-1;
        }
        return left-1;
    }
}
这个也没多大变化，还是老套路，注意好边界问题。二分本质就是将一个大任务分成两个小的同样的任务，然后继续.....，所以和递归能够很好的结合在一起。

十三、反转字符串

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-string

描述:

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1:

输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]

示例 2:

输入：["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]

解决：

执行用时：1 ms, 在所有 Java 提交中击败了96.74%的用户
内存消耗：44.9 MB, 在所有 Java 提交中击败了66.66%的用户

class Solution {
    public void reverseString(char[] s) {
        for(int i=0,j=s.length-1;i<j;i++,j--){
            char temp=s[i];
            s[i]=s[j];
            s[j]=temp;
        }
    }
}
碰撞指针，互相交换值。

十四、反转字符串中的单词 III

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-string

描述:

给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

示例 :

输入："Let's take LeetCode contest"
输出："s'teL ekat edoCteeL tsetnoc"

提示:

在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。

解决：

执行用时：4 ms, 在所有 Java 提交中击败了84.48%的用户
内存消耗：39.1 MB, 在所有 Java 提交中击败了35.90%的用户

class Solution {
    public String reverseWords(String s) {
        String[] str=s.split(" ");
        StringBuffer sbr=new StringBuffer();
        for(int i=0;i<str.length;i++){
           sbr.append(new StringBuffer(str[i]).reverse().toString());
		   sbr.append(" ");
        }
        return sbr.toString().trim();
    }
}
将字符串切割，分别逆序，然后用可变字符串合并，需要注意的是这样写后，最后字符串输出会多一个空格，导致通不过测试（别问我怎么知道的），所以要使用trim清除掉。
如果用c或者c++的话，这个题可以原地逆序，但是java的string是不可变的，做不到。

总结

困难题我唯唯诺诺，简单题我重拳出击。作为初学者，很多代码还有优化的空间，大佬轻喷。

Magic171

关注

3
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
leetcode简单题解（一）

文章目录一、存在重复元素二、使用步骤1.引入库2.读入数据总结一、存在重复元素来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/contains-duplicate描述：给定一个整数数组，判断是否存在重复元素。如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。示例：输入: [1,2,3,1]输出: true解决：class Solution { public bo
复制链接

扫一扫