来源:力扣(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
来源:力扣(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(itarget){
j--;
}
if(numbers[i]+numbers[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 map=new HashMap<>();
for(int i=0;i
来源:力扣(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
来源:力扣(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
来源:力扣(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(;inums2[j]){
nums3[k++]=nums2[j++];
}else{
nums3[k++]=nums1[i++];
}
}
if(i
来源:力扣(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
描述:
给定一个数组,将数组中的元素向右移动 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){
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
来源:力扣(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)
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
来源:力扣(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
困难题我唯唯诺诺,简单题我重拳出击。作为初学者,很多代码还有优化的空间,大佬轻喷。