目录
前言
本博客专注于分享和剖析各式各样的算法题目，内容涵盖范围广泛，不设固定模式，随机挑选题目，旨在为读者提供丰富多元的算法思维训练，助力提升解题技巧。这是一个系列博客，每篇都会精心挑选 10 道算法题。在题目的解析上，我努力确保关键思路与核心步骤清晰呈现，让读者能够轻松理解，如果哪逻辑有问题，欢迎在评论区指点。
移动零
解题思路为快排思想，定义两个变量，一个快指针，一个慢指针，快指针fast先走一步，初始化为0，慢指针初始化为-1.
int slow= -1,fast= 0;慢指针指向的都是不为0的数，他的下一个永远都是为0的数（所以才会初始化成-1，如果初始化为0，可能nums[0]为0）。
接下来遍历整个数组,通过fast指针寻找不为0的数，找到和slow的下一个交换，上述已经说明，slow的下一个永远都是为0数，这里有个小优化，如果fast找到了不为0的数，但是slow+1的数和fast是一样的就不必进行交换。
代码如下：
int slow = -1,fast = 0;
while(fast < nums.length){
if (nums[fast] != 0 && ++slow != fast ){
int tmp = nums[fast];
nums[fast] = nums[slow];
nums[slow] = tmp;
}
fast++; //fast要进行自增
}复写零
解法一：采用上题移动零的思想，定义两个指针和一个数组，cur遍历整个数组，如果为非零则拷贝到新数组中，如果为0则拷贝两次；
注意如果在移动时候新数组已经越界就直接break跳出循环，不要忘了拷贝回原数组
class Solution {
public void duplicateZeros(int[] arr) {
int len = arr.length;
int[] tmp = new int[len];
int cur = 0, dest = 0;
while(cur < len && dest < len ){
if(arr[cur] == 0){
tmp[dest++] = 0; //要进行自增
if(dest >= len) break; //注意越界问题
tmp[dest++] = 0;
} else {
tmp[dest++] = arr[cur];
}
cur++;
}
//拷贝回原数组
for(int i = 0; i < len; i++ ){
arr[i] = tmp[i];
}
}
}解法二：
采用一个数组实现复写，首先还是定义两个指针，接下来尝试从前往后进行复写就会发现，复写时如果复写0就会把后面值全都写成0，所以只能从后往前复写。
从后往前复写cur不能从最后一个下标开始，他要从最后复写的元素的下标开始，通过给出的示例1
arr = [1,0,2,3,0,4,5,0]手动画图模拟从前往后复写就发现最后一个为元素4所在的下标，代码实现为：
while(cur < length){
if(arr[cur] == 0){
dest += 2;
}else {
dest++;
}
//如果dest到最后一个元素就可以跳出循环
if(dest >= length -1) break;
cur++;
}注意测试用例
[1,0,2,3,0,4]经过寻找最后需要复写元素下标的代码时，该测试用例，best会越界，如果直接复写会报越界异常所以要修正，修正很简单，就是从循环的上一层开始复写
if(dest >= length){
arr[length-1] = 0;
cur--;
dest -= 2;
}接下来就从后往前复写，完整代码如下：
class Solution { public void duplicateZeros(int[] arr) { int cur = 0,dest = -1; int length = arr.length; while(cur < length){ if(arr[cur] == 0){ dest += 2; }else { dest++; } if(dest >= length -1) break; cur++; } if(dest >= length){ arr[length-1] = 0; cur--; dest -= 2; } while(cur >= 0){ if(arr[cur] == 0){ arr[dest--] = 0; arr[dest--] = 0; } else { arr[dest--] = arr[cur]; } cur--; } } }
长度最小的子数组
可以直接暴力枚举出所有的可能，但是会超时；
class Solution {
public int minSubArrayLen(int target, int[] nums) {
int count = Integer.MAX_VALUE;
for(int i = 0; i < nums.length; i++){
int sum = 0;
int len = 0;
//注意是从i开始，从0开始就当与一直都是在计算同一组数
//因为在sum>=target的时候会直接跳出循环
for(int j = i; j < nums.length; j++){
sum += nums[j];
len++;
if(sum >= target){
count = count > len ? len : count;
break;
}
}
}
return count == Integer.MAX_VALUE ? 0 : count;
}
}解法二：
滑动窗口，该题本质上就是求一段连续的区间，因此就可以采用滑动窗口解决；
以目标值target = 7, nums = [2,3,1,2,4,3]为测试用例
因为该题都为正整数所以当
right走到这里时候，已经没必要往后走了，本身就已经和大于等于目标值，再加上一个整数也必然是大于目标值的。
而根据暴力解法接下来判断完之后left加一，right是要回到left继续往后遍历，但是在这里其实没必要回去，因为我们已经计算出来和sum，只需要拿sum减去left下标出的值，left再进行加一，就计算出left+1到right区间的和，继续用这个和判断是否大于目标值。
在这里right向左移动就是进窗口，判断条件在出窗口之前判断，如果在出窗口之后判断，就会判断到错误的值，出窗口为left向右移动并且sum-nums[left]的值。
代码如下：
class Solution {
public int minSubArrayLen(int target, int[] nums) {
int left = 0, right = 0,sum = 0, length = Integer.MAX_VALUE;
while(right < nums.length){
//进入窗口
sum += nums[right++];
//判断条件
while(sum >= target){
//取到原值和目前区间内的最小值
length = Math.min(length, right - left);
//出窗口
sum-=nums[left++];
}
}
return length == Integer.MAX_VALUE ? 0 : length;
}
}二分查找
经典的采用二分查找算法，定义两个指针，一个指向0下标，一个指向最后元素下标，定义一个中间下标
int left = 0, right = nums.length-1, mid = 0;接下来就进入循环，特别注意循环条件要<=，如果left<right有些测试用例是过不去的，因为可能刚好要查找的元素在循环的最后一个元素，解题代码如下：
class Solution {
public int search(int[] nums, int target) {
int left = 0, right = nums.length-1, mid = 0;
while(left <= right){
mid = left + (right - left) / 2;
if(nums[mid] < target){
left = mid + 1;
} else if(nums[mid] > target){
right = mid - 1;
} else {
return mid;
}
}
return -1;
}
}[模版]前缀和
解法一：暴力解法会超时
先接收两个参数n和q，定义一个数组，大小为n，初始化数组，然后就开始正式接收参数，如果是从1-2那就循环从0到1（因为他这里是第一个元素下标是1，而数组是从0开始所以要-1）源码：
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
int n = in.nextInt();
int q = in.nextInt();
int[] arr = new int[n];
for(int i = 0; i < n; i++){
arr[i] = in.nextInt();
}
for(int i = 0; i < q; i++){
int l = in.nextInt();
int r = in.nextInt();
int sum = 0;
for(int j = l-1; j < r; j++){
sum += arr[j];
}
System.out.println(sum);
}
}
}解法二:使用前缀和思想，前缀和就是用来快速求一段区间内的数据和的问题，正好符合这道题。
暴力解法是new一个数组，但是前缀和需要new两个数组，一个数组作用是用来存放输入的值，另一个数组是用来存放某一个下标+之前所有下标中的元素的和。
这里下标要从1开始，如果从0开始就需要处理边界情况，前缀和数组必须是long，如果是int就会溢出，代码如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
//读入数据
int n = in.nextInt();
int q = in.nextInt();
//计算时候下标从1开始，为了防止溢出 如果从0开始就需要处理边界情况
int[] arr = new int[n+1];
//long类型
long[] dp = new long[n+1];
for(int i = 1; i <= n; i++){
arr[i] = in.nextInt();
//预处理一个前缀和数组 当下标从0开始第一次循环dp[i-1]越界
dp[i] = arr[i] + dp[i-1];
}
for(int i = 0; i < q; i++){
int l = in.nextInt();
int r = in.nextInt();
System.out.println(dp[r] - dp[l - 1]);
}
}
}dp[i] = arr[i] + dp[i-1]，dp[i]表示[1,i]所有区间的和 ，而arr[i]则表示当前元素的和，加起来就是[1,i]之间所有的元素和了。
如果要想知道2,6区间的和，只需要拿6下标处的值(表示[1,6]中的所有元素和)减去2之前元素的和也就是[1,2-1]得到的就是该区间的元素和了；
判定字符是否唯一
面试题 01.01. 判定字符是否唯一 - 力扣（LeetCode）
解法很多，比如可以直接暴力遍历，如果有重复的直接返回false，遍历完没有返回true，或者哈希表
//暴力解法
class Solution {
public boolean isUnique(String astr) {
for(int i = 0; i<astr.length(); i++){
char s = astr.charAt(i);
for(int j = i+1; j<astr.length();j++){
if(s == astr.charAt(j)){
return false;
}
}
}
return true;
}
}
//哈希表
class Solution {
public boolean isUnique(String astr) {
Map<Character,Integer> map = new HashMap<>();
for(int i=0; i<astr.length();i++){
char s = astr.charAt(i);
if(map.get(s) != null){
return false;
}
map.put(s,1);
}
return true;
}
}优解：可以采用位图的思想，不需要真的去new一个hash表，因为一共只有26个值，所以可以使用一个int变量就可以完成本题.
下面表示int中的比特位，a表示第一位，b表示第二位以此类推
每个字符如果出现过就把对应的二进制位改为1，每次进去循环都先查看某字符二进制位是否为1，如果为1就存在改返回false，遍历完说明没有重复的直接return true;
class Solution {
public boolean isUnique(String astr) {
//一共只有26位字母，如果超过26则一定有重复的
if(astr.length() > 26){
return false;
}
int bit = 0;
for(int i = 0; i < astr.length(); i++){
int a = astr.charAt(i) - 'a';
//判断该bit位是否为1如果为1，说明之前添加过了，直接返回false
if(((bit >> a) & 1) == 1){
return false;
}
//将特定bit位改为1
bit |= 1<< a;
}
return true;
}
}替换所有问号
直接暴力解决，但是要注意边界，如果‘？’在0下标或最后一个下标是只需要判断0下标之后或size-1下标之前的元素的；
这里要主要处理边界时候，括号里的位置不能换，如果i == 0 || arr[i-1] 换成了arr[i-1] || i == 0就会发生越界，因为如果i==0了条件为真就对短路不会判断后面的i-1了，如果换了就会先判断i-1，访问-1下标；
class Solution {
public String modifyString(String s) {
//处理边界
char[] arr = s.toCharArray();
int size = arr.length;
for(int i = 0; i < size; i++){
if(arr[i] == '?'){
for(char ch = 'a'; ch <= 'z'; ch++){
//处理边界情况
if((i == 0 || arr[i-1] != ch) && (i == size -1 || arr[i+1] != ch)){
arr[i] = ch;
}
}
}
}
//题目要求返回string，所以要转换一下
return String.valueOf(arr);
}
}颜色划分
采用快排解决该题就可以，把找一个基准，把数组分成三块，左边都是小于基准值的元素，右边都是大于基准值的元素；
快排其实也就是双指针和移动零的思想差不多，选一个left表示小于基准的元素区间，cur扫描整个数组，发现小于基准的数，就left下一个交换就好(因为left的下一个永远都是大于基准的)
class Solution {
public void sortColors(int[] nums) {
mySort(0,nums.length-1,nums);
}
public void mySort(int left, int right, int[] nums){
if(left >= right) return;
int key = left;
int cur = left + 1;
while(cur <= right){
if(nums[cur] < nums[key] && ++left != cur){
swap(nums,left,cur);
}
cur++;
}
swap(nums,key,left);
mySort(left+1,right,nums);
mySort(key,left-1,nums);
}
public void swap(int[] nums,int left,int right){
int tmp = nums[left];
nums[left] = nums[right];
nums[right] = tmp;
}
}空间复杂度比较高
第二种解法：不进行递归，把定义三个指针，把数组分成四段，[0,left]全都是0，[left+1,i-1]全都是1，[i,right-1]全都是未扫描的元素，[right,n-1]全都是2
int left=0, right = nums.length,i=0;让i扫描整个数组，如果扫描到0则和left+1进行交换，因为交换的是扫描完的元素，所以i++，left++指向最后0的位置，如果扫描到1，i++，扫描到2和right-1进行换行，right--，注意这里因为交换的是没有扫描的元素所以i不能++，源码如下：
class Solution {
public void sortColors(int[] nums) {
int left=-1, right = nums.length,i=0;
while(i<right){
if(nums[i] == 0 && ++left!=i){
swap(nums,left,i++);
} else if(nums[i] == 2 && --right != i){
//当等于2时候，i不能进行+1操作
swap(nums,right,i);
} else {
i++;
}
}
}
//交换数组
public void swap(int[] nums,int left,int right){
int tmp = nums[left];
nums[left] = nums[right];
nums[right] = tmp;
}
}
排序数组
采用归并排序，归并排序的思想就是分而治之，先找到一个mid中间值，然后根据中间值分成两部分，如果[left,mid]和[mid+1,right]同时有序则只需要把两个数组合到一起，所以只需要递归到每个区间只有一个元素，自然而然就是有序数组了，然后向上依次归并；
class Solution {
public int[] sortArray(int[] nums) {
//临时存放元素数组
int[] tmp = new int[nums.length];
MergeSort(0,nums.length-1,nums,tmp);
return nums;
}
private void MergeSort(int left,int right, int[] nums, int[] tmp){
if(left>=right) return ;
//找到中间值，以中间值为基准分成两部分
int mid = left + (right - left) / 2;
//分别对中间值的两边进行排序 [left,mid] [mid+1,right]
MergeSort(left,mid,nums,tmp);
MergeSort(mid+1,right,nums,tmp);
int begin1 = left, begin2 = mid+1;
int index = left;
//归并数组
while(begin1 <= mid && begin2 <= right){
tmp[index++] = nums[begin1]<nums[begin2] ? nums[begin1++] : nums[begin2++];
}
while(begin1 <= mid) tmp[index++] = nums[begin1++];
while(begin2 <=right) tmp[index++] = nums[begin2++];
for(int i = left; i<=right;i++) nums[i] = tmp[i];
}
}需要注意的是，一定要有临时数组，不然会把原数组中的值进行覆盖，临时数组不要new到递归函数里面，开销比较大，递归MergeSort(left,mid,nums,tmp)不能写成 MergeSort(left,mid-1,nums,tmp)； MergeSort(mid,right,nums,tmp),当left等于0，right=1时，mid等于0，MergeSort(mid,right,nums,tmp),下一次递归还是left=0，right=1会无限递归下去
链表两数相加
该题由于给出的本身就是逆序(根据示例1，原数342，链表为243)，所以可以直接相加，整体就和算术相加是一样的，相加时，创建一个记录进位的变量，而为了方便记录结果创建一个虚拟头结点，方便添加操作创建一个尾指针
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
//创建虚拟头节点，方便记录结果
ListNode head = new ListNode();
//尾指针
ListNode tail = head;
//记录进位
int t = 0;
while(l1!= null || l2 != null || t != 0){
ListNode node = new ListNode();
if(l1!=null){
t += l1.val;
l1 = l1.next;
}
if(l2!=null){
t += l2.val;
l2 = l2.next;
}
//根据题目只记录一位数字
node.val = t % 10;
//将记录数字抹去，下一次如果t不为0就直接加上1，相当于进行效果
t /= 10;
tail.next = node;
tail = tail.next;
}
return head.next;
}
}注意这里循环条件不能遗漏了t！=0，在算最后一位时，如果发生了进位，而两个链表都已经为空，链表就会少一个结点(少一位数字)，如果不加该条件就需要在循环之后再进行修正,返回时返回头结点的下一个结点，不能直接返回head；
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
