数组部分总结
目录
-
-
-
- 二分查找：
- 快慢指针：
- 滑动窗口：
- 螺旋矩阵：
- N数之和：
-
- 两数之和：
- 三数之和：
- 四数之和：
- 四数相加II：
-
-
二分查找：
在返回结果时，有可能不等于target注意判断是返回>=，还是<=的结果。
704.二分查找
34.在排序数组中查找元素的第一个和最后一个位置
69.x 的平方根
704.二分查找
二分查找主要用于有序数组，且无重复元素
边界问题：
左闭右闭：
left可以等于right， 此时循环的条件为left <= right;
判断当mid 不等于target时，此时left = mid + 1或者right = mid-1;
左闭右开：
left不能等于right， 此时循环的条件为left < right;
判断当mid 不等于target时，此时left = mid + 1或者right = mid;
左闭右开写法：
class Solution {
public int search(int[] nums, int target) {
int left = 0;
int right = nums.length;
while(left < right){
int mid = (right - left) / 2 + left; //防止（left+rigt）溢出
if(nums[mid] < target){
left = mid+1;
}else if(nums[mid] > target){
right = mid;
}else{
return mid;
}
}
return -1;
}
}
69.x 的平方根
用二分法求平方根且要求只取整数， a 2 < = x a^2 <= x a2<=x，所以用二分时，如果最后跳出循环后应该取小的一个；
class Solution {
public int mySqrt(long x) {
long left = 0;
long right = x;
while(left <= right){
long mid = (right - left)/2 + left;
long temp = mid * mid;
if(temp < x){
left = mid + 1;
}else if(temp > x){
right = mid - 1;
}else{
return (int)mid;
}
}
return left;
}
}
其他：可以用牛顿迭代法，二次收敛，比二分查找更快
快慢指针：
27.移除元素
844.比较含退格的字符串
快指针遍历数组，慢指针填补相应的元素。
- 移除元素
class Solution {
public int removeElement(int[] nums, int val) {
// 快慢指针
int fastIndex = 0;
int slowIndex;
for (slowIndex = 0; fastIndex < nums.length; fastIndex++) {
if (nums[fastIndex] != val) {
nums[slowIndex] = nums[fastIndex];
slowIndex++;
}
}
return slowIndex;
}
}
844.比较含退格的字符串
方法一、由于先进后出的特征，考虑用栈；这里用StringBuffer代替stack更方便。
class Solution {
public boolean backspaceCompare(String s, String t) {
String a = build(s);
String b = build(t);
return a.equals(b);
}
public String build(String s){
StringBuffer s1 = new StringBuffer("");
for (int i = 0; i < s.length(); i++) {
if(s.charAt(i) == '#' && s1.length() > 0){
s1.delete(s1.length()-1, s1.length());
}else if(s.charAt(i) != '#'){
s1.append(s.charAt(i));
}
}
return s1.toString();
}
}
方法二、用双指针
滑动窗口：
核心思想：扩展右边界，缩短左边界，并适时更新数据。
209.长度最小的子数组
904.水果成篮
76.最小覆盖子串
209.长度最小的子数组
- 窗口内是什么？
- 窗口就是 满足其和 ≥ s 的长度最小的连续子数组。
- 如何移动窗口的起始位置？
- 窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。
- 如何移动窗口的结束位置？
- 窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针。
for (int right = 0; right < nums.length; right++) {
sum += nums[right];
while (sum >= s) {
result = Math.min(result, right - left + 1);
sum -= nums[left++];
}
}
- 水果成篮
1, 使用map保存窗口中数字出现的次数，因为数字不是很大。可以使用数组模拟hash。
2，右指针移动时，如果发现是一个没有出现过的数字，就把cnt++
3，如果cnt个数超过了设定的窗口大小则开始收缩窗口
4，直到窗口中数字被减少到0. 此时将cnt–，退出收缩流程
5, 更新水果的 最大数目结果应该在right扩张的时候，在窗口缩小时不考虑。
public int totalFruit(int[] fruits) {
if(fruits.length <= 2) return fruits.length;
int ans = 0, left = 0;
HashMap<Integer, Integer> window = new HashMap<Integer, Integer>();
for (int right = 0; right < fruits.length; right++) {
window.put(fruits[right], window.getOrDefault(fruits[right], 0) + 1);
while (window.size() > 2){
window.put(fruits[left], window.getOrDefault(fruits[left], 0) - 1);
if(window.get(fruits[left]) == 0) window.remove(fruits[left]);
left++;
}
ans = Math.max(ans, right - left + 1);
}
return ans;
}
其他：
Java Map:
entrySet()的返回值也是返回一个Set集合，此集合的类型为Map.Entry。
Map.Entry是Map声明的一个内部接口，此接口为泛型，定义为Entry
由以上可以得出，遍历Map的常用方法：
Map map = new HashMap();
Iterator iterator = map.entrySet().iterator();
while(iterator.hasNext()) {
Map.Entry entry = iterator.next();
Object key = entry.getKey();
}
螺旋矩阵：
螺旋矩阵II
N数之和：
两数之和
三数之和
四数之和
- 四数之和II
两数之和：
题目：
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的两个整数，并返回他们的数组下标。
分析：
这道题主要是快速查找，因此使用Hash map，保存 -nums[i]和下标。时间复杂度 O ( n ) O(n) O(n)
由于返回的是下标，所以不能用快慢指针
class Solution {
public int[] twoSum(int[] nums, int target) {
HashMap<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++){
if(map.containsKey(target - nums[i])){
int j = map.get(target - nums[i]);
return new int[]{i, j};
}else{
map.put(nums[i], i);
}
}
return new int[]{-1, -1};
}
}
三数之和：
题目：
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意： 答案中不可以包含重复的三元组。
分析：
由于要找的是不重复的数组，哈希表很难去重，所以考虑用快慢指针。
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> re = new ArrayList<>();
Arrays.sort(nums);
for (int i = 0; i < nums.length; i++) {
int target = -nums[i];
//去重，必须用nums[i] == nums[i-1]
if(i > 0 && nums[i] == nums[i-1]) i++;
int left = i+1, right = nums.length-1;
while(left < right){
if(nums[left] + nums[right] < target){
left++;
}else if(nums[left] + nums[right] > target){
right--;
}else{
List<Integer> temp = Arrays.asList(nums[i], nums[left], nums[right]);
re.add(temp);
//必须先添加后去重
while (left < right && nums[left] == nums[left+1]) left++;
while (left < right && nums[right] == nums[right-1]) right--;
left++;
right--;
}
}
}
return re;
}
}
四数之和：
题目：
给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d = target相等？找出所有满足条件且不重复的四元组。
分析：
由于要找的是不重复的数组，哈希表很难去重，所以考虑用快慢指针。
四数之和，相比三叔之和多加了一重循环，多一次判断去重，此次去重必须是j > i+1
class Solution {
public List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>> res = new ArrayList<>();
List<Integer> temp = new ArrayList<Integer>();
Arrays.sort(nums);
for (int i = 0; i < nums.length; i++) {
//去重，必须用nums[i] == nums[i-1]
//如果用nums[i] == nums[i+1]， 会忽略当target = 0，[0，0，0，0]类似这种情况[a,a,b,c]
if(i > 0 && nums[i] == nums[i-1]) continue;
for (int j = i+1; j < nums.length; j++) {
//必须时j > i+1，注意不要写成j > 0, 当target = 0，[0，0，0，0]时，同样会直接跳过
if(j > i+1 && nums[j] == nums[j-1]) continue;
//if (nums[i] + nums[j] >= target) continue;
//上述这种对于当target = 0， [0，0，0，0]时，是有问题的，所以不能加
int left = j+1, right = nums.length - 1;
while(left < right){
if(nums[i] + nums[j] + nums[left] + nums[right] > target){
right--;
}else if(nums[i] + nums[j] + nums[left] + nums[right] < target){
left++;
}else{
temp = Arrays.asList(nums[i], nums[j], nums[left], nums[right]);
res.add(temp);
//必须先添加后去重
while(left < right && nums[left] == nums[left+1]) left++;
while(left < right && nums[right] == nums[right-1]) right--;
left++;
right--;
}
}
}
}
return res;
}
}
// 这种剪枝是错误的，这道题目target 是任意值
// if (nums[k] > target) {
// return result;
// }
四数相加II：
题目：
给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
分析：
这道题由于是从4个四个数组中分别取一个元素判断nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0，所以不用考虑重复情况。根据两数之和，可以使用hash表能够尽快匹配。
- 先计算
temp = nums1[i] + nums2[j]，存入hash表，时间复杂度为 O ( n 2 ) O(n^2) O(n2) - 然后在将
nums3[k] + nums4[l]之和与hash表匹配，计算是否等于0。 - 用res记录符合条件的结果
res += A.get(temp);
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
HashMap<Integer, Integer> A = new HashMap<>();
for (int i = 0; i < nums1.length; i++) {
for (int j = 0; j < nums2.length; j++) {
int temp = nums1[i] + nums2[j];
A.put(temp, A.getOrDefault(temp, 0) + 1);
}
}
int res = 0;
for (int i = 0; i < nums3.length; i++) {
for (int j = 0; j < nums4.length; j++) {
int temp = -1 * (nums3[i] + nums4[j]);
if(A.containsKey(temp)){
res += A.get(temp);
}
}
}
return res;
}
}