一、存在重复元素
来源：力扣（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是不可变的，做不到。
总结
困难题我唯唯诺诺，简单题我重拳出击。作为初学者，很多代码还有优化的空间，大佬轻喷。
|