算法-数组
1. 二分查找 (LeetCode 704)
题目：给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
关键：确定合法区间的形式。
常见的有2种：
- 左闭右闭
- 左闭右开
// 左闭右闭的写法
// target!=nums[mid]的情况下,left和right都不需要再等于mid
class Solution {
public int search(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
int mid = (left + right) / 2;
while (left <= right) { //左闭右闭的定义下 left=right是合法的
mid = (left + right) / 2;
if (nums[mid] == target)
return mid;
else if (nums[mid] > target) {
right = mid - 1;
} else if (nums[mid] < target) {
left = mid + 1;
}
}
return -1;
}
}
2. 删除元素(LeetCode 27)
题目：给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
2.1 暴力求解
两层for循环，每发现一个等于val的元素，就把它后面的元素依次往前移动一个位置。
// 暴力解法
class Solution {
public int removeElement(int[] nums, int val) {
int size = nums.length;
for(int i = 0; i<size;++i){
if(nums[i] == val){
for(int j = i+1; j<size;++j){
nums[j-1] = nums[j];
}
size--;
i--;
}
}
return size;
}
}
2.2 双指针
只需要O(n)的复杂度
slow表示新数组的下标fast遍历数组，每找到一个不等于val的元素，填入新数组。
class Solution {
public int removeElement(int[] nums, int val) {
int fast = 0;
int slow = 0;
for(fast = 0; fast < nums.length; ++fast){
if(nums[fast] != val){
nums[slow] = nums[fast];
slow++;
}
}
return slow;
}
}
3. 有序数组的平方(LeetCode 977)
题目：给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
思想：新数组的最大值只可能是nums两端数字的平方。
利用双指针，一个指向nums的左侧，一个指向nums的右侧。
k指向新数组的末尾，从右向左依次填充。
//双指针
//O(n)复杂度
class Solution {
public int[] sortedSquares(int[] nums) {
int i = 0; //i指向nums的左侧
int j = nums.length-1; //j指向nums的右侧
int k = nums.length-1; //k指向新数组的末尾
int[] new_nums = new int[nums.length];
while(i<=j) { //新数组从后往前扫，最大值只可能是两端值的平方
if(nums[i]*nums[i] >= nums[j]*nums[j]){
new_nums[k] = nums[i]*nums[i];
k--;
i++;
} else{
new_nums[k] = nums[j]*nums[j];
k--;
j--;
}
}
return new_nums;
}
}
4. 长度最小的子数组(LeetCode 209)（有难度）
题目：给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [nums_l, nums_l+1, ..., nums_r-1, nums_r] ，并返回其长度。如果不存在符合条件的子数组，返回 0 .
输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
思路：滑动窗口：动态调整窗口的起始和终止位置。
- j指向窗口的终止位置，对j进行for循环。
- i指向窗口的起始位置，如果sum大于target了，i逐渐右移，缩小窗口。
java库函数:Math.min(),Integer.MAX_VALUE
class Solution {
public int minSubArrayLen(int target, int[] nums) {
int i = 0;
int j = 0;
int sum = 0;
int sublength = 0;
int result = Integer.MAX_VALUE; //result初值要设最大
for(j = 0; j < nums.length; ++j){
sum += nums[j];
while(sum >= target){
result = Math.min(j-i+1, result); //sum大于target之后才记录result
sum -= nums[i];
++i;
}
}
return (result == Integer.MAX_VALUE) ? 0 : result;
}
}
5. 螺旋矩阵II(LeetCode 59)（有难度）
题目：给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。
示例
输入: 3
输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]
思路：
- 对于每条边都是左闭右开进行处理，即处理边上的第一个节点，不处理最后一个节点。
- 循环
n/2次，因为每次边长会减少2。 - 如果n为奇数，还需要填充中间的一个元素。
class Solution {
public int[][] generateMatrix(int n) {
int count = 1;
int loop = 0;
int start = 0;
int i = 0, j = 0;
int[][] matrix = new int[n][n];
while(loop < n/2 ){
loop++;
//从左到右
for(j = start; j<n-loop; ++j){
matrix[start][j] = count++;
}
//从上到下
for(i = start; i<n-loop; ++i){
matrix[i][j] = count++;
}
//从右到左
for(; j>=loop; --j){
matrix[i][j] = count++;
}
//从下到上
for(; i>=loop; --i){
matrix[i][j] = count++;
}
start++;
}
//n为奇数时中间一格的填充
if(n % 2 == 1){
matrix[start][start] = count;
}
return matrix;
}
}
