注：本文中只是作为自己的一篇学习笔记，记录自己刷代码随想录的过程，所以文中很多解题思想都是来自代码随想录以及leetcode上的一些题解。如果大家刷完了代码随想录的题单，也可以继续刷灵神的题单，生命不息，刷题不止。
二分查找思想
二分算法最容易出错的就是在while的循环的条件
-- 找到其中的循环不变量：根据区间的定义，比如左闭右闭，那进入循环的条件就是
while left <= right ; 因为当left==right 时相当于同时指向一个元素，还可以进行比较；此时注意left，right的更新，只要保证更新后的区间是不含mid这个已经比较失败的元素即可
如果是左闭右开[ left , right ) 那进入循环的条件就应该是 left < right ; 因为left == right 对于区间来说不存在元素；而且这种情况下，更新mid时如果是右边元素大了，那应该是把 right 更新为mid；说明mid这个元素不可取。【left，right的更新只要保证更新后的区间是不含mid这个已经比较失败的元素即可】
其实主要就是对区间的定义没有理解清楚，在循环中没有始终坚持根据查找区间的定义来做边界处理。
区间的定义就是不变量，那么在循环中坚持根据查找区间的定义来做边界处理，就是循环不变量规则。
1. 二分查找 - 查找一个元素是否存在
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例 1:
输入:nums= [-1,0,3,5,9,12],target= 9 输出: 4
C++写法
class Solution {
public:
int search(vector<int>& nums, int target) {
// 使用左闭右闭写法 [left, right]
int left = 0, right = nums.size() - 1;
int mid = 0;
while(left <= right) {
mid = left + ((right - left) >> 1);
if(nums[mid] == target) return mid;
if(nums[mid] > target) {
right = mid - 1;
}
if(nums[mid] < target) {
left = mid + 1;
}
}
return -1;
}
};java 写法
class Solution {
public int search(int[] nums, int target) {
// 使用左闭右开写法
if(nums.length == 0) return -1;
int left = 0,right = nums.length;
int mid = 0;
while(left < right) {
mid = left + (right - left)/2;
if(nums[mid] == target ) return mid;
if(nums[mid] > target) { // 右边大了
right = mid;
}
if(nums[mid] < target) { // 左边小了，目标在右边
left = mid + 1;
}
}
return -1;
}
}2. 搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
我们知道O(n)的算法是顺序遍历一次，而如果想要得到O(logn)的算法，就需要每次都丢掉一半的元素。
class Solution {
public int searchInsert(int[] nums, int target) {
/**
先确定使用哪一种方式：这里使用左闭右闭
二分查找，找到最后的位置 mid;
如果mid位置元素大于 target 则返回mid;
如果mid位置元素小于 target 则返回mid+1
*/
int left = 0, right = nums.length - 1;
int mid = 0;
while(left <= right) {
mid = left + ((right - left) >> 1); // 右移一位相当于除以2
if(nums[mid] == target) {
return mid;
}
if(nums[mid] > target) {
right = mid - 1;
} else {
left = mid + 1;
}
}
return nums[mid] > target ? mid : mid + 1;
}
}3. 在排序数组中查找元素的第一个和最后一个位置
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。
你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。
4. 有序数组中的单一元素【利用一些特性】
给你一个仅由整数组成的有序数组，其中每个元素都会出现两次，唯有一个数只会出现一次。
请你找出并返回只出现一次的那个数。
你设计的解决方案必须满足 O(log n) 时间复杂度和 O(1) 空间复杂度。
示例 1:
输入: nums = [1,1,2,3,3,4,4,8,8] 输出: 2
参考题解：. - 力扣（LeetCode）
class Solution {
public int singleNonDuplicate(int[] nums) {
/**
O(1) 就不可以使用map了
// 双指针思想：一个后移，一个前移；这样只要移动 n/2 还是O(n);
有序利用一下；二分查找
因此如果不考虑“特殊”的单一元素的话，我们有结论：成对元素中的第一个所对应的下标必然是偶数，成对元素中的第二个所对应的下标必然是奇数。
// 只出现依次的那个元素，一定位于偶数的下标上
如果没有这个1个元素，那正常的2个相同元素出现的位置应该是，第一个元素下标为偶数，第二个为奇数。
当出现这个元素后，这个元素之后的顺序就会改变了，第一个出现的元素下标会变成奇数
*/
int n = nums.length;
// 用什么写法：左闭右闭
int left = 0;
int right = n - 1;
while(left < right) {
int mid = (left + right) >>> 1;
if(mid % 2 == 0) { // mid为偶数
if(mid + 1 < n && nums[mid] == nums[mid + 1]){ // 说明左边以及当前元素没有问题
left = mid + 1;
}else {
right = mid; // 右边有问题
}
} else {
if(mid - 1 >= 0 && nums[mid - 1] == nums[mid]) {
left = mid + 1;
}else {
right = mid;
}
}
}
return nums[right];
}
}2. 二分查找
双指针思想
1. 移除元素
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。
假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：
- 更改
nums数组，使nums的前k个元素包含不等于val的元素。nums的其余元素和nums的大小并不重要。 - 返回
k。
class Solution {
public int removeElement(int[] nums, int val) {
/**
idea & steps:
1. 从左往右遍历数组nums，，
2. 如果与val相同，则与数组最后一个元素交换，
3. 数组长度 --
4. 注：如果相同了则继续遍历当前元素；（因为当前元素是末尾交换过来的元素，不一定不等于val）
5. 结束的条件：当前判断的位置与更改后的数组位置相同
*/
int cur = 0; // 起始指针
int rear = nums.length - 1; // 终止指针
while(cur <= rear) {
if(nums[cur] == val) {
nums[cur] = nums[rear];
rear --;
}else {
cur ++;
}
}
return cur;
}
}- 26.删除排序数组中的重复项(opens new window)
- 283.移动零(opens new window)
- 844.比较含退格的字符串(opens new window)
- 977.有序数组的平方(opens new window)
滑动窗口思想
在这里只写了3个题目，具体的滑动窗口刷题放到了另一篇文章中
1. 长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其总和大于等于 target 的长度最小的
子数组
[numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
class Solution {
public int minSubArrayLen(int target, int[] nums) {
// 求最短
// 不定长的滑动窗口： 用一个left来控制最左边的窗口值
int left = 0;
int ans = nums.length + 1;
int sum = 0; // 记录当前子数组的和
for(int i=0; i<nums.length; i++) {
sum += nums[i]; // 入
while(sum >= target) { // 当开始满足条件时窗口向右收缩，看看能不能用更短的数组来满足
// 更新
ans = Math.min(ans, i-left+1);
// 出
sum -= nums[left];
left ++;
}
}
// 如果最后ans 没有改变，说明不存在符合条件的子数组
return ans == nums.length+1 ? 0 : ans;
}
}复杂度分析： 时间复杂度 O(n); 空间复杂度 O(1)
2. 水果成篮
你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。
你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：
- 你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
- 你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
- 一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。
给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。
class Solution {
public int totalFruit(int[] fruits) {
// 一排果树
// 果树上有很多种类的水果，其中种类数目就是fruit[i]
// 可以选择任意一棵树进行采摘，然后向右移动；
// 每棵树上摘一个苹果；
// 解析题意：
// 就是要求数组的最长连续子数组，这个子数组需要满足的条件为：只能含两个不同的元素
// 最后结果为返回该子数组的长度
// 思路：
// 求最长子数组问题，使用不定长的滑动窗口
// 使用一个map来维护种类数：当遍历到某个节点时，种类数超过了2；就开始移动左边的元素，直至种类数小于2再更新
if(fruits.length == 1) return 1;
int ans = 0;
int left = 0;
var map = new HashMap<Integer,Integer>();
for(int i=0; i < fruits.length; i++) {
// 判断该元素是不是在map中; 不在则加入map,在则map内的值+1
// 入
map.merge(fruits[i],1,(oldValue, newValue) -> oldValue + newValue); //
// 判断是不是只有两个key
while(map.size() > 2) { // 加入后含两种以上元素了
if(map.merge(fruits[left],-1,(oldValue,newValue) -> oldValue + newValue) == 0) {
map.remove(fruits[left]);
}
left ++;
}
// 更新最大值
ans = Math.max(ans,i-left+1);
}
return ans;
}
}- 3. 最小覆盖子串
-- 本质上还是一个动态的滑动窗口
给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。
注意：
- 对于
t中重复字符，我们寻找的子字符串中该字符数量必须不少于t中该字符数量。 - 如果
s中存在这样的子串，我们保证它是唯一的答案。
示例 1：
输入：s = "ADOBECODEBANC", t = "ABC" 输出："BANC" 解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。
class Solution {
public String minWindow(String s, String t) {
/**
找到 s中涵盖 t的所有字符的最小子串
要求：
如果t中有多个相同字符，那么在s中的子串也应该全部包含进入
可以不用关注顺序
求最短，使用不定长的滑动窗口
如何记录s,t 中出现元素的数目：使用哈希表，本题中因为仅有26个字母，
所以可以使用数组来作为这个hash表
大写字母的 ASCII 码范围是 65（A）到 90（Z）。
小写字母的 ASCII 码范围是 97（a）到 122（z）。
操作：
枚举s子串的右端点 right ; 如果子串涵盖t,就不断移动左端点 left 直到不涵盖为止
在移动过程中更新最短子串的左右端点
*/
char[] chs = s.toCharArray();
int m = s.length();
// 这里因为最后要返回的是子串，所以不可以只使用一个ans; ans这种情况适合求返回的是长度的情况
int ansLeft = -1;
int ansRight = m; // 表示最右边
int[] cntS = new int[128]; // s子串字母的出现次数
int[] cntT= new int[128]; // t中字母的出现次数
for(char c : t.toCharArray()) {
cntT[c] ++; // 统计t中字符case
}
int left = 0;
for(int right = 0; right < m; right ++) { // 移动右端点
cntS[chs[right]] ++; // 每次移动端点都移入子串
// 复杂度分析：
// 这里每执行一次都会去调用一个比较函数（52字符的时间），即left增加一次就调用一次，
// 而left最多会增加m次； 所以时间复杂度为 O(m*52)
while(isCovered(cntS, cntT)) { // 当满足条件的时候就移动左边字符，看看能不能找到更短的
// 更新
if(right - left < ansRight - ansLeft) { // 找到更短的子串
ansLeft = left;
ansRight = right;
}
// 出
cntS[chs[left]]--; // 左边元素移出
left ++;
}
}
return ansLeft < 0 ? "" : s.substring(ansLeft,ansRight + 1);
}
// 这个函数每一个都会比较52个字符的时间
private boolean isCovered(int[] cntS, int[] cntT) {
for(int i='A'; i<= 'Z'; i++) {
if(cntS[i] < cntT[i]) {
return false; // 当前子串中的S字符大写字母无法包含子串
}
}
for(int i='a'; i<= 'z'; i++) {
if(cntS[i] < cntT[i]) {
return false; // 当前子串中的S字符小写字母无法包含子串
}
}
return true;
}
}复杂度分析
时间复杂度：O(∣Σ∣m+n)，其中 m 为 s 的长度，n 为 t 的长度，∣Σ∣ 为字符集合的大小，本题字符均为英文字母，所以 ∣Σ∣=52。注意 left 只会增加不会减少，left 每增加一次，我们就花费 O(∣Σ∣) 的时间。因为 left 至多增加 m 次，所以二重循环的时间复杂度为 O(∣Σ∣m)，再算上统计 t 字母出现次数的时间 O(n)，总的时间复杂度为 O(∣Σ∣m+n)。
空间复杂度：O(∣Σ∣)。如果创建了大小为 128 的数组，则 ∣Σ∣=128。
Q: 可不可以将判断涵盖的时间复杂度优化到O（1）
二刷时参考灵神题解：
前缀和思想
58. 区间和（第九期模拟笔试）
58. 区间和（第九期模拟笔试） (kamacoder.com)
题目描述
给定一个整数数组 Array，请计算该数组在每个指定区间内元素的总和。
输入描述
第一行输入为整数数组 Array 的长度 n，接下来 n 行，每行一个整数，表示数组的元素。随后的输入为需要计算总和的区间下标：a，b （b > = a），直至文件结束。
输出描述
输出每个指定区间内元素的总和。
C++版本
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n,a,b;
cin >> n;
vector<int> arr(n);
vector<int> sum(n); // 记录前缀和
for(int i=0; i<n ; i++) {
cin >> arr[i];
if(i == 0) sum[i] = arr[0];
else sum[i] += sum[i-1] + arr[i]; // 记录前缀和
}
while(cin >> a >> b) { // 输入a,b直至文件结束
if(a == 0) {
cout << sum[b]<< endl;
}else {
cout << sum[b] - sum[a-1] << endl;
}
}
return 0;
}java版本
import java.util.Scanner;
public class Main {
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;
if (a == 0) {
sum = p[b];
} else {
sum = p[b] - p[a - 1];
}
System.out.println(sum);
}
scanner.close();
}
}
数组补充题目部分
1. 有多少小于当前数字的数字
-- 哈希表，数组，排序
--Q: 如何解决相同元素的问题
--常用思想：对未排序的数组考虑可不可以先排序
给你一个数组 nums，对于其中每个元素 nums[i]，请你统计数组中比它小的所有数字的数目。
换而言之，对于每个 nums[i] 你必须计算出有效的 j 的数量，其中 j 满足 j != i 且 nums[j] < nums[i] 。
以数组形式返回答案。
示例 1：
输入：nums = [8,1,2,2,3] 输出：[4,0,1,1,3] 解释： 对于 nums[0]=8 存在四个比它小的数字：（1，2，2 和 3）。 对于 nums[1]=1 不存在比它小的数字。 对于 nums[2]=2 存在一个比它小的数字：（1）。 对于 nums[3]=2 存在一个比它小的数字：（1）。 对于 nums[4]=3 存在三个比它小的数字：（1，2 和 2）。
// class Solution {
// public int[] smallerNumbersThanCurrent(int[] nums) {
// /**
// 是不是可以对数组进行排序，排序之后的元素下标即为比其小的元素，注意相同元素的情况
// 用一个hash表记录排序完之后的下标
// 如何解决元素重复导致的问题：排完序后从左往右遍历数组，并存入hash,这样存入的就是相同元素
// 最小的下标；
// */
// int[] sortedNums = Arrays.copyOf(nums, nums.length);
// Arrays.sort(sortedNums);
// var map = new HashMap<Integer, Integer>();
// for(int i=0; i< sortedNums.length; i++) {
// if(!map.containsKey(sortedNums[i]))
// map.put(sortedNums[i],i);
// }
// // 此时map存的就是每个元素比其小的元素
// for(int i=0; i<nums.length; i++) {
// nums[i] = map.get(nums[i]);
// }
// return nums;
// }
// }
// 计数思想
// class Solution {
// public int[] smallerNumbersThanCurrent(int[] nums) {
// int [] t = new int[102];
// for (int i = 0; i < nums.length; i++) {
// t[nums[i]+1]++;
// }
// for (int i = 1; i <= 101; i++) {
// t[i] += t[i-1];
// }
// for (int i = 0; i < nums.length; i++) {
// nums[i] = t[nums[i]];
// }
// return nums;
// }
// }
扫一扫
1267
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
