算法之路
1 删除排序数组中的重复项
给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
链接：leetcode-cn.com/leetbook/re… `
public int removeDuplicates(int[] nums) {
if (nums.length == 0) {
return 0;
}
if (nums.length == 1) {
return nums.length;
}
int i = 0;
int j = 1;
while (j < nums.length) {
if (nums[i] != nums[j]) {
nums[i + 1] = nums[j];
i++;
}
j++;
}
return i + 1;
}
`
2 买卖股票的最佳时机 II
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
class Solution {
public int maxProfit(int[] prices) {
int res = 0;
for (int i = 0; i < prices.length - 1; i++) {
if (prices[i] < prices[i + 1]) {
res += prices[i + 1] - prices[i];
}
}
return res;
}
}
3 股票的最大利润
假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？
示例 1:
输入: [7,1,5,3,6,4] 输出: 5 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。 示例 2:
输入: [7,6,4,3,1] 输出: 0 解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
来源：力扣（LeetCode）
链接：leetcode-cn.com/problems/gu…
public int maxProfit(int[] prices) {
if (prices.length <= 1) {
return 0;
}
int min = prices[0];
int max = 0;
for (int i = 1; i < prices.length; i++) {
max = Math.max(max, prices[i] - min);
min = Math.min(min, prices[i]);
}
return max;
}
4 旋转数组
给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
进阶：
尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。 你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？
链接：leetcode-cn.com/leetbook/re…
class Solution {
public void rotate(int[] nums, int k) {
k = k % nums.length;
//每次往后移一位，移动k次
for (int i = 0; i < k; i++) {
int fir = nums[nums.length - 1];
//从倒数第二个元素开始移动
for (int j = nums.length - 2; j >= 0; j--) {
nums[j + 1] = nums[j];
}
//每次的第一个元素都是移动前的最后一个
nums[0] = fir;
}
}
}
5 存在重复元素
给定一个整数数组，判断是否存在重复元素。
如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。
链接：leetcode-cn.com/leetbook/re…
class Solution {
public boolean containsDuplicate(int[] nums) {
// Set<Integer> set = new HashSet<>();
// for (int num : nums) {
// if (!set.add(num))
// return true;
// }
// return false;
Arrays.sort(nums);
for(int i = 0; i < nums.length - 1; i++) {
if (nums[i] == nums[i + 1]) {
return true;
}
}
return false;
}
}
6 只出现一次的数字
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
链接：leetcode-cn.com/leetbook/re…
public static int singleNumber(int nums[]) {
int result = 0;
for (int i = 0; i < nums.length; i++) {
result ^= nums[i];
}
return result;
}
2021.03.31 完成
7 合并两个有序数组
给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。
初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 的空间大小等于 m + n，这样它就有足够的空间保存来自 nums2 的元素。
示例 1：
输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3 输出：[1,2,2,3,5,6]
来源：力扣（LeetCode）
链接：leetcode-cn.com/problems/me…
public void merge(int[] nums1, int m, int[] nums2, int n) {
for (int i = 0; i != n; ++i) {
nums1[m + i] = nums2[i];
}
Arrays.sort(nums1);
}
8 两数之和 II - 输入有序数组
给定一个已按照 升序排列 的整数数组 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 。
来源：力扣（LeetCode）
链接：leetcode-cn.com/problems/tw…
public int[] twoSum(int[] numbers, int target) {
if (numbers == null || numbers.length < 2) {
return new int[]{0, 0};
}
int i = 0;
int j = numbers.length - 1;
while (i < j) {
if (numbers[i] + numbers[j] == target) {
return new int[]{i+1, j+1};
} else if (numbers[i] + numbers[j] < target) {
i++;
} else if (numbers[i] + numbers[j] > target){
j--;
}
}
return new int[]{0, 0};
}
9 两数之和
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
来源：力扣（LeetCode）
链接：leetcode-cn.com/problems/tw…
class Solution {
public int[] twoSum(int[] numbers, int target) {
if (numbers == null || numbers.length < 2) {
return new int[]{0, 0};
}
HashMap<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < numbers.length; i++) {
if (map.get(target - numbers[i]) != null) {
return new int[]{map.get(target - numbers[i]), i};
}
map.put(numbers[i], i);
}
return new int[]{0, 0};
}
}
10 二分查找
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9 输出: 4 解释: 9 出现在 nums 中并且下标为 4
来源：力扣（LeetCode）
链接：leetcode-cn.com/problems/bi…
class Solution {
public int search(int[] nums, int target) {
if (nums.length <= 0) {
return -1;
}
if (target < nums[0] || target > nums[nums.length - 1]) {
return -1;
}
int left = 0;
int right = nums.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (nums[mid] == target) {
return mid;
} else if (target > nums[mid]) {
left = mid + 1;
} else if (target < nums[mid]) {
right = mid - 1;
}
}
return -1;
}
}
