leetcode——数组、双指针、滑动窗口

最新推荐文章于 2022-11-24 19:31:07 发布
最新推荐文章于 2022-11-24 19:31:07 发布
阅读量174 收藏
点赞数
分类专栏： LeetCode 文章标签： java leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43952736/article/details/118354585
版权

1.如何写出正确的算法：明确变量的定义。

public int binarySearch(int[] a){
    int l = 0, r = n - 1; // 在[l...r]的范围里寻找target
    while( l <= r){       // 方 l == r 时，区间[l...r]依然是有效的
        int mid = l + (r - l) / 2;
        if(a[mid] == target){
            return mid;
        }
        if(target > a[mid])
            l = mid + 1;  // target在[mid+1...r]中
        else
            r = mid - 1;  // target在[l...mid-1]中
    }
}

public int binarySearch(int[] a){
    int l = 0, r = n; // 在[l...r)的范围里寻找target
    while( l < r){       // 方 l == r 时，区间[l...r)无效的
        int mid = l + (r - l) / 2;
        if(a[mid] == target){
            return mid;
        }
        if(target > a[mid])
            l = mid + 1;  // target在[mid+1...r)中
        else
            r = mid;  // target在[l...mid)中
    }
}
283. 移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

示例:

输入: [0,1,0,3,12]
输出: [1,3,12,0,0]

说明:

  1. 必须在原数组上操作，不能拷贝额外的数组。
  2. 尽量减少操作次数。

题解：
定义[0,k)表示nums数组中非0的元素，k初始化为0；
遍历整个数组，如果是非0的元素，则添加到第k个位置，然后k++；
最后把k~nums.length的元素填为0即可。

class Solution {
    public void moveZeroes(int[] nums) {
        int k = 0;//[0,k)表示nums中的非0元素
        for(int i = 0; i < nums.length; i++){
            if(nums[i] != 0){
                nums[k++] = nums[i];
            }
        }
        for(int i = k; i < nums.length; i++){
            nums[i] = 0;
        }
        
    }
}
26. 删除有序数组中的重复项

给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1：

输入：nums = [1,1,2]
输出：2, nums = [1,2]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例 2：

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

提示：

  • 0 <= nums.length <= 3 * 104
  • -104 <= nums[i] <= 104
  • nums 已按升序排列

题解：
定义[0,i)表示nums数组中非重复的元素，k初始化为0；
遍历整个数组，如果是当前元素（num[j]）与第i个元素，则添加到i+1的位置，并且i更新为i+1。

class Solution {
    public int removeDuplicates(int[] nums) {
        int i = 0;
        for(int j = 1; j < nums.length; j++){
            if(nums[j] != nums[i]){
                i++;
                nums[i] = nums[j];
            }
        }
        return i + 1;
    }
}
80. 删除有序数组中的重复项 II

给你一个有序数组 nums ，请你** 原地** 删除重复出现的元素，使每个元素 最多出现两次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

说明：

为什么返回数值是整数，但输出的答案是数组呢？

请注意，输入数组是以**「引用」**方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1：

输入：nums = [1,1,1,2,2,3]
输出：5, nums = [1,1,2,2,3]
解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。 不需要考虑数组中超出新长度后面的元素。

示例 2：

输入：nums = [0,0,1,1,1,1,2,3,3]
输出：7, nums = [0,0,1,1,2,3,3]
解释：函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。 不需要考虑数组中超出新长度后面的元素。

提示：

  • 1 <= nums.length <= 3 * 104
  • -104 <= nums[i] <= 104
  • nums 已按升序排列

题解：
前两个元素不管一不一样都先算入满足题意；对应i < 2
接着每个元素与前两个比较，如果大于则算入结果中。（例如：001111只会保留0011）。

class Solution {
    public int removeDuplicates(int[] nums) {
            int i = 0;
		for(int n : nums) {
			if(i < 2 || n > nums[i - 2]) {
				nums[i++] = n;
			}
		}
		return i;
    }
}
75. 颜色分类

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

示例 1：

输入：nums = [2,0,2,1,1,0]
输出：[0,0,1,1,2,2]

示例 2：

输入：nums = [2,0,1]
输出：[0,1,2]

示例 3：

输入：nums = [0]
输出：[0]

示例 4：

输入：nums = [1]
输出：[1]

提示：

  • n == nums.length
  • 1 <= n <= 300
  • nums[i] 为 0、1 或 2

进阶：

  • 你可以不使用代码库中的排序函数来解决这道题吗？
  • 你能想出一个仅使用常数空间的一趟扫描算法吗？

题解：
nums[0,zero] == 0;
nums[two, n - 1] == 2;
中间的都是1。那么对于这个设定，zero初始化为-1，two初始化为n，表明这两个范围一开始都没有元素。
在这里插入图片描述

class Solution {
    public void sortColors(int[] nums) {
         int zero = -1;             //nums[0,zero] == 0;
		 int two = nums.length;		//nums[two,n - 1] == 2;
		 for(int i = 0; i < two;) {
			 if(nums[i] == 0) {
				 zero++;
				 int temp = nums[zero];
				 nums[zero] = nums[i];
				 nums[i] = temp;
				 i++;
			 }else if(nums[i] == 2) {
				 two--;
				 int temp = nums[two];
				 nums[two] = nums[i];
				 nums[i] = temp;
			 }else
				 i++;
		 }
    }
}
215. 数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

示例 1:

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5

示例 2:

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

说明:

你可以假设 k 总是有效的，且 1 ≤ k ≤ 数组的长度。

题解：
就是一个快排，找第nums.length - k个元素。

class Solution {
   Random random = new Random();
	
	public int findKthLargest(int[] nums, int k) {
		int left = 0;
		int right = nums.length - 1;
		int target = nums.length - k;
		while(true) {
			int index = partition(nums, left, right);
			if(index < target) {
				left = index + 1;
			}else if(index > target) {
				right = index - 1;
			}else {
				return nums[index];
			}
		}	
    }
	
	public int partition(int nums[], int left, int right) {
		if(right > left) {
			int randomIndex = left + random.nextInt(right - left + 1);
			swap(nums, left, randomIndex);
		}
		
		int pivot = nums[left];
		int j = left;
		//[0,j] < pivot;
		for(int i = left + 1; i <= right; i++) {
			if(nums[i] < pivot) {
				j++;
				swap(nums, j, i);
			}
		}
		swap(nums, j, left);
		return j;
	}
	
	public void swap(int nums[], int a, int b) {
		int temp = nums[a];
		nums[a] = nums[b];
		nums[b] = temp;
	}
}
167. 两数之和 II - 输入有序数组

给定一个已按照 升序排列 的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。

函数应该以长度为 2 的整数数组的形式返回这两个数的下标值*。*numbers 的下标 从 1 开始计数 ，所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。

你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。

示例 1：

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。

示例 2：

输入：numbers = [2,3,4], target = 6
输出：[1,3]

示例 3：

输入：numbers = [-1,0], target = -1
输出：[1,2]

提示：

  • 2 <= numbers.length <= 3 * 104
  • -1000 <= numbers[i] <= 1000
  • numbers 按 递增顺序 排列
  • -1000 <= target <= 1000
  • 仅存在一个有效答案

题解：
因为数组有序，所以只需要用双指针往中间移动搜索即可。

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int left = 0;
		int right = numbers.length - 1;
		while(left < right) {
			int sum = numbers[left] + numbers[right];
			if(sum < target) {
				left++;
			}else if(sum > target) {
				right--;
			}else {
				return new int[] {left + 1, right + 1};
			}
		}
		return new int[] {0, 0};
    }
}
125. 验证回文串

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

**说明：**本题中，我们将空字符串定义为有效的回文串。

示例 1:

输入: "A man, a plan, a canal: Panama"
输出: true

示例 2:

输入: "race a car"
输出: false

双指针遍历，遇到非数字字母即跳过。

class Solution {
    public boolean isPalindrome(String s) {
        int left = 0;
        int right = s.length() - 1;
        while(left < right) {
        	while(left < right && !Character.isLetterOrDigit(s.charAt(left)))
        		++left;
        	while(left < right && !Character.isLetterOrDigit(s.charAt(right)))
        		--right;
        	if(left < right) {
        		if(Character.toLowerCase(s.charAt(left)) != Character.toLowerCase(s.charAt(right)))
        			return false;
        		++left;
        		--right;
        	}
        }
        return true;
    }
}
345. 反转字符串中的元音字母

编写一个函数，以字符串作为输入，反转该字符串中的元音字母。

示例 1：

输入："hello"
输出："holle"

示例 2：

输入："leetcode"
输出："leotcede"

提示：

  • 元音字母不包含字母 “y” 。

同双指针

class Solution {
    public String reverseVowels(String s) {
        List list = new ArrayList();
		list.add('a');
		list.add('e');
		list.add('i');
		list.add('o');
		list.add('u');
		list.add('A');
		list.add('E');
		list.add('I');
		list.add('O');
		list.add('U');
		StringBuilder str = new StringBuilder(s);
		int left = 0;
		int right = str.length() - 1;
		while(left < right) {
			while(left < right && !list.contains(str.charAt(left))) 
				 left++;
			while(left < right && !list.contains(str.charAt(right))) 
				 right--;
			if(left < right) {
				char c = str.charAt(left);
				str.setCharAt(left, str.charAt(right));
				str.setCharAt(right, c);
				left++;
				right--;
			}
		}
        return str.toString();
    }
}
11. 盛最多水的容器

给你 n 个非负整数 a1，a2，...，a``n，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

**说明：**你不能倾斜容器。

示例 1：

img

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：

输入：height = [1,1]
输出：1

示例 3：

输入：height = [4,3,2,1,4]
输出：16

示例 4：

输入：height = [1,2,1]
输出：2

提示：

  • n = height.length
  • 2 <= n <= 3 * 104
  • 0 <= height[i] <= 3 * 104

题解：
双指针，算当前面积，比较sum；
指针移动的问题：因为指针往里移，底的长会变小，所以我们只有要把较矮的直线往里移动，试图找一条更高的，这样面积才有可能变大。

class Solution {
    public int maxArea(int[] height) {
        int left = 0;
		int right = height.length - 1;
		int sum = 0;
		while(left < right) {
			int temp = Math.min(height[left], height[right]) * (right - left);
			if(temp > sum)
				sum = temp;
			if(height[left] < height[right]) {
				left++;
			}else {
				right--;
			}
		}
		return sum;
    }
}
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

提示：

  • 1 <= target <= 109
  • 1 <= nums.length <= 105
  • 1 <= nums[i] <= 105

进阶：

  • 如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。

题解：
利用滑动窗口解题，定义left和right维持一个和 >= target的窗口。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        // 定义一个滑动窗口
        int left = 0;
        int right = 0;
        int n = nums.length;
        int sum = 0;
        int len = 100001;
        while(right < n){
            sum += nums[right];
            right++;
            while(sum >= target){
                if(right - left < len){
                    len = right - left;
                }
                sum -= nums[left];
                left ++;
            }
        }
        if(len == 100001)
            return 0;
        return len;
    }
}
3. 无重复字符的最长子串

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

示例 4:

输入: s = ""
输出: 0

提示：

  • 0 <= s.length <= 5 * 104
  • s 由英文字母、数字、符号和空格组成
class Solution {
    public int lengthOfLongestSubstring(String s) {
        int sLen = s.length();
        if(sLen == 0)
            return 0;
        Map<Character, Integer> cur = new HashMap<>();
        // 定义滑动窗口
        int left = 0;
        int right = 0;
        int len = -1;
        while(right < sLen){
            char c = s.charAt(right);
            if(cur.containsKey(c)){
            	// 特殊情况：如abba
                left = Math.max(left, cur.get(c) + 1);
            }
            cur.put(c, right);
            len = Math.max(len, right - left + 1);
            right ++;
        }        
        return len;
    }
}
438. 找到字符串中所有字母异位词

给定一个字符串 s 和一个非空字符串 p，找到 s 中所有是 p 的字母异位词的子串，返回这些子串的起始索引。

字符串只包含小写英文字母，并且字符串 s 和 p 的长度都不超过 20100。

说明：

  • 字母异位词指字母相同，但排列不同的字符串。
  • 不考虑答案输出的顺序。

示例 1:

输入:
s: "cbaebabacd" p: "abc"

输出:
[0, 6]

解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的字母异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的字母异位词。

示例 2:

输入:
s: "abab" p: "ab"

输出:
[0, 1, 2]

解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的字母异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的字母异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的字母异位词。

题解： 这道题与下面一道题的解法一致。

  1. 这道题的思想是滑动窗口，因为我们要判断某个元素数量是否满足要求，可以用map来存储，那么如何判断我们要的元素是否都齐了呢？可以用一个int变量来记录。
  2. 窗口两个指针，当窗口内的元素满足需要的时候，移动左指针，将窗口左边的第一个相关元素移除。然后继续移动右指针，试图寻找一个最小的包含所有元素的窗口。
class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        Map<Character,Integer> need = new HashMap<>();
        Map<Character,Integer> windows = new HashMap<>();
        List<Integer> list = new ArrayList<>();

        if(s.length() < p.length())
            return new ArrayList<>();
        for(int i = 0; i < p.length(); i++){
            char c = p.charAt(i);
            need.put(c, need.getOrDefault(c,0)+ 1);
        }

        int left = 0; //[0,0)
        int right = 0;
        int valid = 0;
        while(right < s.length()){
            char c = s.charAt(right);
            right++;
            if(need.containsKey(c)){
                windows.put(c, windows.getOrDefault(c, 0) + 1);
                if(need.get(c).intValue() == windows.get(c).intValue())
                    valid ++;
            }
            while(right - left == p.length()){
                if(valid == need.size()) {
                    list.add(left);
                }

                char cc = s.charAt(left);
                left ++;
                if(need.containsKey(cc)){
                    if(need.get(cc).intValue() == windows.get(cc).intValue())
                        valid --;
                    windows.put(cc, windows.get(cc) - 1);
                }
            }
        }
        return list;
    }
}
76. 最小覆盖子串

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

**注意：**如果 s 中存在这样的子串，我们保证它是唯一的答案。

示例 1：

输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"

示例 2：

输入：s = "a", t = "a"
输出："a"

提示：

  • 1 <= s.length, t.length <= 105
  • s 和 t 由英文字母组成

题解：

  1. 这道题的思想是滑动窗口，因为我们要判断某个元素数量是否满足要求，可以用map来存储，那么如何判断我们要的元素是否都齐了呢？可以用一个int变量来记录。
  2. 窗口两个指针，当窗口内的元素满足需要的时候，移动左指针，将窗口左边的第一个相关元素移除。然后继续移动右指针，试图寻找一个最小的包含所有元素的窗口。
class Solution {
    public String minWindow(String s, String t) {
        Map<Character, Integer> need = new HashMap<>();
        Map<Character, Integer> windows = new HashMap<>();
        int tLen = t.length();
        int sLen = s.length();
        if(tLen == 0 || sLen == 0)
            return "";
        for(int i = 0; i < tLen; i++){
            char c = t.charAt(i);
            need.put(c, need.getOrDefault(c, 0) + 1);
        }
        // 定义窗口左右指针
        int left = 0; 
        int right = 0;
        int len = Integer.MAX_VALUE;
        // 如何判断我们要的元素都有了，用一个变量来记录
        int valid = 0;
        // 要截取一段出来，用一个变量记录起始位置
        int start = 0;
        while(right < sLen){
            char c = s.charAt(right);
            right ++;
            if(need.containsKey(c)){
                windows.put(c, windows.getOrDefault(c, 0) + 1);
                if(windows.get(c).intValue() == need.get(c).intValue()){
                    valid ++;
                }
            }
            while(valid == need.size()){
                if(right - left < len){
                    start = left;
                    len = right - left;
                }
                char cc = s.charAt(left);
                left++;
                if(need.containsKey(cc)){
                    if(need.get(cc).intValue() == windows.get(cc).intValue()){
                        valid --;
                    }
                    windows.put(cc, windows.get(cc) - 1);
                }
            }
        }
        return len == Integer.MAX_VALUE ? "" : s.substring(start, start + len);
    }
}
呓语dd
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
（leetcode）数组问题-----------双指针
qq_36736330的博客
07-27 171
题目一 给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。 不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。 示例1: 给定数组 nums = [1,1,2], 函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。 你不需要考虑数组中超出新长度后面的元素。 题目二 给你一个数组 nums和一个值 val，你需要 原地 移除所有数值等于val...
leetcode刷题——数组双指针
qq_48637067的博客
04-15 221
题目1描述： 给你一个有序数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次 ，返回删除后数组的新长度。 不要使用额外的数组空间，你必须在原地修改输入数组 并在使用 O(1) 额外空间的条件下完成。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 解题： class Solution {
LeetCode刷题记录（数组和双指针）
你今天真好看呀
09-18 458
文章目录数组专题88. 合并两个有序数组90. 子集 II105. 从前序与中序遍历序列构造二叉树106. 从中序与后序遍历序列构造二叉树118. 杨辉三角 (no)119. 杨辉三角 II120. 三角形最小路径和 (no)121. 买卖股票的最佳时机122. 买卖股票的最佳时机 II123. 买卖股票的最佳时机 III152. 乘积最大子数组(no)153. 寻找旋转排序数组中的最小值169. 多数元素189. 旋转数组209. 长度最小的子数组216. 组合总和 III0. 有赞笔试217. 存在重复
LeetCode——双指针
努力努力再努力L
11-22 294
双指针 双指针主要用来遍历数组，两个指针指向不同的元素，从而协同完成任务。 目录 有序数组的 Two Sum 两数平方和 反转字符串中的元音字符 回文字符串 归并两个有序数组 判断链表是否存在环 最长子序列 1. 有序数组的 Two Sum 题目描述：在有序数组中找出两个数，使它们的和为 target。 使用双指针，一个指针指向值较小的元素，一个指针指向值较大的元素。指向较小元素的指针从...
【leetcode】数组专场，循序渐进，双指针技巧
一个写湿的程序猿
04-11 354
【leetcode】数组专场，循序渐进，双指针技巧一、快慢指针技巧26.删除有序数组中的重复项27.移除元素283.移动零二、左右指针技巧167.两数之和 II344.反转数组5.最长回文子串 在处理数组和链表相关问题时，双指针技巧是经常用到的，双指针技巧主要分为两类：左右指针和快慢指针。 左右指针：就是两个指针相向而行 或 相背而行 快慢指针：就是两个指针同向而行，一快一慢 一、快慢指针技巧 26.删除有序数组中的重复项 数组问题中比较常见且难度不高的的快慢指针技巧，就是原地修改数组。 什么
js-leetcode题解之验证子序列-题解.zip
05-09
本题解将聚焦于一个特定的LeetCode问题——“验证子序列”。通过这个问题，我们将深入探讨JavaScript中的数组操作、递归算法以及字符串处理技术。 题目描述： 给定两个字符串`s`和`t`，判断`t`是否是`s`的子序列。...
python-leetcode面试题解之第76题最小覆盖子串-题解.zip
04-11
4. **双指针**：滑动窗口的实现通常涉及到双指针，一个指针指向子串的起始位置，另一个指针向后移动，更新子串的结束位置。当子串满足条件时，更新答案并记录当前子串的长度。 5. **优化策略**：为了减少不必要的...
leetcode分类-leetcode:leetcode刷题
06-30
《LeetCode刷题指南——深度剖析数组与字符串题目》 LeetCode，作为全球知名的在线编程挑战平台，为程序员提供了一系列的算法题目，旨在提升编程技能和解决实际问题的能力。本指南将聚焦于LeetCode中的两个核心数据...
java-leetcode题解之第86题分隔链表.zip
最新发布
06-05
在Java LeetCode题解之第86题分隔链表中，我们学习了如何利用链表的特性以及滑动窗口思想来解决复杂的问题。通过对链表的遍历和节点操作，可以高效地将链表分成指定数量的连续子链表。掌握这种问题解决策略对于提高...
leetcode-solutions:我对LeetCode问题的个人解决方案
03-21
字符串处理问题可能涉及到双指针技术或滑动窗口等。 在阅读和学习这些解决方案时，我们应重点关注以下几个方面： 1. **问题分析**：理解题目要求，明确输入和输出格式，分析问题的复杂性。 2. **算法选择**：根据...
【Leetcode刷题】双指针
m0_51976564的博客
07-07 328
【LeetCode刷题】——双指针 头尾指针 同向双指针 分段双指针 快慢指针 滑动窗口
【算法思维--双指针技巧】LeetCode数组类题目等
少年初心的博客
11-20 537
刷题的过程关键是通过 语言刷算法解题的思维过程。 只要把题目搞清晰，会做coding好了、这一类都会了，目的就达到了。 当然， C++一方面很多书籍在用其表达；另一方面自己之前也学过相关的数据结构，灵活运用在算法方面的能力很强。 其它，大项目可以用别的语言。<工具 暂不是大问题。> 15题 三数之和解题思路 思路： 标签：数组遍历 首先对数组进行排序，排序后固定一个数 nums[i]，再使用左右指针指向 nums[i]后面的两端，数字分别为 nums[L]和 nums[R]，计算三个数的和.
基于双指针的滑动窗口方法在数组问题中的应用
xucr1111的博客
11-11 209
LeetCode中有道题：取一个字符串中不含重复字符的最长子串的长度。原题是：Longest Substring Without Repeating Characters Given a string, find the length of the longest substring without repeating characters.  最直接的想法是暴力法穷举所有的子串，取其中不...
leetcode_数组相关问题
coding
03-18 456
283.零移动 给定一个数组nums，编写一个函数将所有0移动到数组的末尾，同时保持非零元素的相对顺序。 示例: 输入: [0,1,0,3,12] 输出: [1,3,12,0,0] 说明: 必须在原数组上操作，不能拷贝额外的数组。 尽量减少操作次数。 思路一：保证非零元素的相对顺序，冒泡排序法，时间复杂度为O(n^2),空间复杂度为O(1) class Solu...
双指针与滑动窗口的简单理解，与例题分析
BlackMonkeyHH的博客
11-24 1023
对于双指针和滑窗的基本理解和例题分析
算法（滑动数组）
Kerryliuyue的博客
08-23 1176
给定一个大小为n≤10^6的数组。 有一个大小为k的滑动窗口，它从数组的最左边移动到最右边。 您只能在窗口中看到k个数字。 每次滑动窗口向右移动一个位置。 以下是一个例子： 该数组为[1 3 -1 -3 5 3 6 7]，k为3。 您的任务是确定滑动窗口位于每个位置时，窗口中的最大值和最小值。 输入格式 输入包含两行。 第一行包含两个整数n和k，分别代表数组长度和滑动窗口的长度。 第二行有n个整数，代表数组的具体数值。 同行数据之间用空格隔开。 输出格式 输出包含两个。 第一行输出，从左至右，每个位置滑动
滑动窗口算法思想
2021wuwei
03-05 3212
目录说明例子连续子数组的最大和和为target的连续正整数序列长度最小的子数组水果成篮最长不重复子串的长度字符串的排列最小覆盖子串滑动窗口最大值 说明 滑动窗口算法思想是非常重要的一种思想，可以用来解决数组，字符串的子元素问题。它可以将嵌套循环的问题，转换为单层循环问题，降低时间复杂度，提高效率。 滑动窗口的思想非常简单，它将子数组（子字符串）理解成一个滑动的窗口，然后将这个窗口在数组上滑动，在窗口滑动的过程中，左边会出一个元素，右边会进一个元素，然后只需要计算当前窗口内的元素值即可。 可用滑动窗口思想解决
LeetCode：数组双指针法
猪猪
10-06 959
题目：长度最小的子数组 给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组。如果不存在符合条件的连续子数组，返回 0。 示例:  输入: s = 7, nums = [2,3,1,2,4,3] 输出: 2 解释: 子数组 [4,3] 是该条件下的长度最小的连续子数组。 进阶: 如果你已经完成了O(n) 时间复杂度的解法, 请尝试 O...
滑动窗口（单调队列）
Mr_Kingk的博客
02-12 546
给定一个大小为n≤106的数组。 有一个大小为k的滑动窗口，它从数组的最左边移动到最右边。 您只能在窗口中看到k个数字。 每次滑动窗口向右移动一个位置。 以下是一个例子： 该数组为[1 3 -1 -3 5 3 6 7]，k为3。 窗口位置 最小值 最大值 [1 3 -1] -3 5 3 6 7 -1 3 1 [3 -1 -3] 5 3 6 7 -3...
Java解题心得：双指针法解决LeetCode排序数组问题
"LeetCode刷题题解-Java版本，主要涵盖了双指针技术在解决数组问题中的应用，包括寻找有序数组中两数之和以及判断平方和的问题。" 在LeetCode刷题中，Java版本的解题策略经常涉及到算法和数据结构的应用，特别是双...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值