数组篇-代码随想录

数组篇

跳-二分查找-704-力扣

class Solution {public int search(int[] nums, int target) {if (nums == null || nums.length == 0) return -1;if (target < nums[0] || target > nums[nums.length - 1])return -1;int left = 0, right = nums.length - 1;while (left <= right) {int mid = left + (right - left) / 2; // 避免溢出if (nums[mid] == target) {return mid;} else if (nums[mid] > target) {right = mid - 1;} else {left = mid + 1;}}return -1;}
}

跳-移除元素-27-力扣

class Solution {//方案二：双指针法public int removeElement(int[] nums, int val) {int left = 0;int right = nums.length-1;int counts = 0;while(left<=right){while (left<=right && nums[right]==val){right--;}while (left<=right && nums[left]!=val){left++;}if(left<right){nums[left]=nums[right];nums[right]=val;}}return right+1;}// // 方案一： 正常遍历// public int removeElement(int[] nums, int val) {//     int counts = nums.length;//     for(int i=nums.length-1; i>=0; i--) {//         if (nums[i] == val) {//             counts--;//             for(int j=i+1; j<nums.length; j++) {//                 nums[j-1] = nums[j];//             }//             nums[nums.length-1] = val;//         }//     }//     return counts;// }
}

做-有序数组的平方-977-力扣

给你一个按 非递减顺序 排序的整数数组 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]

// 双指针法，方法一
class Solution {public int[] sortedSquares(int[] nums) {int n = nums.length;int[] ant = new int[n];for (int i=0,j=n-1,pos=n-1; i<=j;) {if (nums[i]*nums[i] > nums[j]*nums[j]) {ant[pos] = nums[i]*nums[i];i++;} else {ant[pos] = nums[j] * nums[j];j--;}pos--;}return ant;}
}

方法二：
利用数组中元素是升序的这一条件：即如果数组中元素有负有正
-4  -2  1  3*l  *r
左指针向左，右指针向右遍历，然后左右指针进行比较

//方法三：将数组里面的元素平方之后，再进行快排算法class Solution {public int[] sortedSquares(int[] nums) {int len = nums.length;for (int i=0; i<len; i++) {nums[i] = nums[i]*nums[i];}quickSort(nums, 0, len-1);return nums;}private void quickSort(int[] nums, int low, int high) {int left, right, temp, t;if (low >= high){return;}// 左右指针left = low;right = high;temp = nums[low];    //temp就是基准位while (left < right) {//先看右边，依次往左递减while (nums[right]>=temp && left<right) {right--;}//再看左边，依次往右递增while (nums[left]<=temp && left<right) {left++;}//如果满足条件则交换if (left < right) {t = nums[right];nums[right] = nums[left];nums[left] = t;}}//最后将基准为与left和right相等位置的数字交换nums[low] = nums[left];nums[left] = temp;//递归调用左半数组quickSort(nums, low, right-1);//递归调用右半数组quickSort(nums, right+1, high);}}

思考-长度最小的子数组-209-力扣

给定一个含有 n 个正整数的数组和一个正整数 target 。找出该数组中满足其总和大于等于 target 的长度最小的 
子数组[numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。示例 1：输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
示例 2：输入：target = 4, nums = [1,4,4]
输出：1
示例 3：输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

滑动窗口(就使用这个)

class Solution {public int minSubArrayLen(int target, int[] nums) {int len = nums.length;int count = len + 1;int left = 0;long sum = 0;for (int right=0; right<len; right++) {sum += nums[right];while (sum >= target) {count = Math.min(count, right-left+1);sum -= nums[left++];}}return count==len+1 ? 0 : count;}
}

我自己写的（有问题）

代码估计没有错误，但是时间超出了限制 O(n^2)级别了

class Solution {public int minSubArrayLen(int target, int[] nums) {int len = nums.length;int count = len+1;for(int left=len-1; left>=0; left--) {int sum = 0;for(int right=left; right<len; right++) {sum+=nums[right];if(right-left+1<count && sum>=target){count = right - left + 1;break;}}}return count==len+1 ? 0 : count;}
}

思考-螺旋矩阵||-59-力扣

题目：给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。示例 1：输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]
示例 2：输入：n = 1
输出：[[1]]

class Solution {public int[][] generateMatrix(int n) {int[][] nums = new int[n][n];int startX = 0, startY = 0; // 每一圈的起始点int offset = 1;int count = 1;  // 矩阵中需要填写的数字int loop = 1; // 记录当前的圈数int i, j; // j 代表列, i 代表行;while (loop <= n/2) {// 顶部// 左闭右开，所以判断循环结束时， j 不能等于 n - offsetfor (j=startY; j<n-offset; j++) {nums[startX][j] = count++;}// 右列// 左闭右开，所以判断循环结束时， i 不能等于 n - offsetfor (i=startX; i<n-offset; i++) {nums[i][j] = count++;}// 底部// 左闭右开，所以判断循环结束时， j != startYfor (; j>startY; j--) {nums[i][j] = count++;}// 左列// 左闭右开，所以判断循环结束时， i != startXfor (; i>startX; i--) {nums[i][j] = count++;}startX++;startY++;offset++;loop++;}if (n%2 == 1) {nums[startX][startY] = count;}return nums;}
}

小结：这道题要注意的地方，就在于整个逻辑。

​ 记录当前的圈数、记录每圈开始的起始位置、记录每圈的偏移量

跳-区间和-58-卡码网

题目描述
给定一个整数数组 Array，请计算该数组在每个指定区间内元素的总和。
输入描述
第一行输入为整数数组 Array 的长度 n，接下来 n 行，每行一个整数，表示数组的元素。随后的输入为需要计算总和的区间下标：a，b （b > = a），直至文件结束。
输出描述
输出每个指定区间内元素的总和。
输入示例
5
1
2
3
4
5
0 1
1 3
输出示例
3
9

代码

import java.util.Scanner;public class mm {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int n = scanner.nextInt();int[] vec = new int[n];int[] p = new int[n];int presum = 0;for (int i=0; i<n; i++) {vec[i] = scanner.nextInt();presum+=vec[i];p[i] = presum;}while (scanner.hasNextInt()) {int a = scanner.nextInt();int b = scanner.nextInt();int sum = 0;if (a == 0) {sum = p[b];} else {sum = p[b] -p[a-1];}System.out.println(sum);}scanner.close();}
}

思路

第一个位置：前一个和

第二个位置：前二个和

.........

第n个位置：前n个和

跳-开发商购买土地-44-卡码网

题目描述
在一个城市区域内，被划分成了n * m个连续的区块，每个区块都拥有不同的权值，代表着其土地价值。目前，有两家开发公司，A 公司和 B 公司，希望购买这个城市区域的土地。 现在，需要将这个城市区域的所有区块分配给 A 公司和 B 公司。然而，由于城市规划的限制，只允许将区域按横向或纵向划分成两个子区域，而且每个子区域都必须包含一个或多个区块。 为了确保公平竞争，你需要找到一种分配方式，使得 A 公司和 B 公司各自的子区域内的土地总价值之差最小。 注意：区块不可再分。输入描述
第一行输入两个正整数，代表 n 和 m。 接下来的 n 行，每行输出 m 个正整数。输出描述
请输出一个整数，代表两个子区域内土地总价值之间的最小差距。

解题思路

和我写的代码一样，用的还是前缀和的思想。

我的代码

import java.util.Scanner;
import java.lang.Math.*;public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int n = scanner.nextInt();int m = scanner.nextInt();int[] h = new int[n];int[] c = new int[m];int[][] p = new int[n][m];int sum = 0;int SUM = 0;for (int i=0; i<n; i++) {sum = 0;for (int j=0; j<m; j++) {p[i][j] = scanner.nextInt();sum += p[i][j];SUM += p[i][j];}if (i != 0) {h[i] = h[i-1] + sum;} else {h[i] = sum;}}for (int j=0; j<m; j++) {sum = 0;for (int i=0; i<n; i++) {sum += p[i][j];}if (j != 0) {c[j] = c[j-1] + sum;} else {c[j] = sum;}}for (int i=0; i<n-1; i++) {if (Math.abs(h[n-1]-2*h[i]) < SUM) {SUM = Math.abs(h[n-1]-2*h[i]);}}for (int j=0; j<m-1; j++) {if (Math.abs(c[m-1]-2*c[j]) < SUM) {SUM = Math.abs(c[m-1]-2*c[j]);}}System.out.println(SUM);}
}

总结