双指针总结

目录

3. 无重复字符的最长子串

11. 盛最多水的容器    中等

15. 三数之和    中等

16. 最接近的三数之和    中等

19. 删除链表的倒数第N个节点

75. 颜色分类

80. 删除排序数组中的重复项 II

142. 环形链表 II

3. 无重复字符的最长子串

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

示例 1:

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

示例 2:

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

示例 3:

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

1. public int lengthOfLongestSubstring(String s) {
2. //用于判断窗口中是否有重复的元素
3. Set<Character> set = new HashSet<>();
4. int n = s.length();
5. int ans = 0, r = 0;
6. for (int l = 0; l < n; l++) {
7. if (l != 0) {
8. //左指针后移一位,也即删除窗口中的第一个元素
9. set.remove(s.charAt(l - 1));
10. }
11. //当r<n并且新增元素不在窗口中,则窗口中添加一个元素,窗口右移
12. while (r < n && !set.contains(s.charAt(r))) {
13. set.add(s.charAt(r));
14. r++;
15. }
16. ans = Math.max(ans, r - l);
17. }
18. return ans;
19. }

解析:使用set集合作为窗口

用左指针l作为窗口的左边界,右指针r作为窗口的右边界

每次左边界向右移动一个元素,并检查此时窗口中是否可以添加元素

当右边界r<n并且窗口中不包含需要添加的元素时,便不断的向窗口中添加元素,窗口右移

当无法向窗口中添加元素的时候,更新窗口的大小

返回窗口的最大值ans

11. 盛最多水的容器    中等

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

说明：你不能倾斜容器，且 n 的值至少为 2。

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

示例：

1. 输入：[1,8,6,2,5,4,8,3,7]
2. 输出：49

1. public int maxArea(int[] height) {
2. int ans = 0;
3. if (height == null || height.length < 2) {
4. return ans;
5. }
6. int n = height.length;
7. int left = 0, right = n - 1;
8. while (left < right) {
9. int maxArea = (right - left) * Math.min(height[left], height[right]);
10. ans = Math.max(ans, maxArea);
11. if (height[left] <= height[right]) {
12. left++;
13. } else {
14. right--;
15. }
16. }
17. return ans;
18. }

解析：设置左右指针left和right

left的初始值指向容器的最左边

right的初始值指向容器的最右边

哪边的高度低,哪边就向中间移动

15. 三数之和    中等

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例：

1. 给定数组 nums = [-1, 0, 1, 2, -1, -4]，
3. 满足要求的三元组集合为：
4. [
5. [-1, 0, 1],
6. [-1, -1, 2]
7. ]

1. public List<List<Integer>> threeSum(int[] nums) {
2. List<List<Integer>> ans = new ArrayList<>();
3. if (nums == null || nums.length < 3) {
4. return ans;
5. }
6. int n = nums.length;
7. Arrays.sort(nums);
8. //固定第一个数
9. for (int first = 0; first < n; first++) {
10. if (first > 0 && nums[first] == nums[first - 1]) {
11. continue;
12. }
13. int third = n - 1;
14. int target = -nums[first];
15. for (int second = first + 1; second < n; second++) {
16. if (second > first + 1 && nums[second] == nums[second - 1]) {
17. continue;
18. }
19. while (second < third && nums[second] + nums[third] > target) {
20. third--;
21. }
22. if (second >= third) {
23. break;
24. }
25. if (nums[second] + nums[third] == target) {
26. List<Integer> list = new ArrayList<>();
27. list.add(nums[first]);
28. list.add(nums[second]);
29. list.add(nums[third]);
30. ans.add(list);
31. }
32. }
33. }
34. return ans;
35. }

解析：先判断nums数组中元素是否大于或等于三个,不是直接返回

排序

固定第一个点,移动第二和第三个点

第二个点的初始值为first+1

第三个点的初始值为n-1

将满足条件的数据加入集合中

16. 最接近的三数之和    中等

给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

示例：

1. 输入：nums = [-1,2,1,-4], target = 1
2. 输出：2
3. 解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

提示：

• 3 <= nums.length <= 10^3
• -10^3 <= nums[i] <= 10^3
• -10^4 <= target <= 10^4

1. public int threeSumClosest(int[] nums, int target) {
2. Arrays.sort(nums);
3. int n = nums.length;
4. int ans = 10000000;
5. for (int i = 0; i < n; i++) {
6. if (i > 0 && nums[i] == nums[i - 1]) {
7. continue;
8. }
9. int j = i + 1;
10. int k = n - 1;
11. while (j < k) {
12. int num = nums[i] + nums[j] + nums[k];
13. if (num == target) {
14. return target;
15. }
16. if (Math.abs(num - target) < Math.abs(ans - target)) {
17. ans = num;
18. }
19. if (num < target) {
20. j = j + 1;
21. while (j < k && nums[j] == nums[j - 1]) {
22. j++;
23. }
24. } else {
25. k = k - 1;
26. while (j < k && nums[k] == nums[k + 1]) {
27. k--;
28. }
29. }
30. }
31. }
32. return ans;
33. }

解析:先对数组进行排序,方便去重

枚举左节点i

设置一个指针j指向i+1的位置,设置一个指针k指向n-1的位置

j指针和k指针不断的向中间移动,直到j>-k的时候退出循环

19. 删除链表的倒数第N个节点

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后，链表变为 1->2->3->5.

说明：

给定的 n 保证是有效的。

进阶：

你能尝试使用一趟扫描实现吗？

1. public ListNode removeNthFromEnd(ListNode head, int n) {
2. ListNode dummy = new ListNode(0);
3. dummy.next = head;
4. ListNode fast = dummy;
5. ListNode slow = dummy;
6. for (int i = 0; i < n; i++) {
7. fast = fast.next;
8. }
9. while (fast.next != null) {
10. fast = fast.next;
11. slow = slow.next;
12. }
13. slow.next = slow.next.next;
14. return dummy.next;
15. }

解析:创建哨兵节点dummy,哨兵节点dummy初始化next指针指向head节点

创建快慢指针fast和slow初始化指向head

将快指针fast向后移动n个位置

当快指针fast的next指针所指向的节点不为null,快慢指针同时向后移动,直到快指针fast为最后一个节点停止

此时慢指针slow的下一个指针即为需要删除的节点

删除节点,返回头结点

75. 颜色分类

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

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

注意:

不能使用代码库中的排序函数来解决这道题。

示例:

1. 输入: [2,0,2,1,1,0]
2. 输出: [0,0,1,1,2,2]

进阶：

• 一个直观的解决方案是使用计数排序的两趟扫描算法。

首先，迭代计算出0、1 和 2 元素的个数，然后按照0、1、2的排序，重写当前数组。

• 你能想出一个仅使用常数空间的一趟扫描算法吗？

1. public void sortColors(int[] nums) {
2. int p0 = 0, p2 = nums.length - 1;
3. int temp, cur = 0;
4. while (cur <= p2) {
5. if (nums[cur] == 0) {
6. temp = nums[cur];
7. nums[cur] = nums[p0];
8. nums[p0] = temp;
9. p0++;
10. cur++;
11. } else if (nums[cur] == 2) {
12. temp = nums[cur];
13. nums[cur] = nums[p2];
14. nums[p2] = temp;
15. p2--;
16. } else {
17. cur++;
18. }
19. }
20. }

 题解:创建指针p0指向数组第一个元素,创建指针p2指向数组第二个元素

创建当前指针cur,初始值指向数组第一个元素

当当前元素为0的时候,交换当前元素和p0位置的元素,cur指针和p0指针后移一位

当当前元素为2的时候,交换当前元素和p2位置的元素,只将p2指针向前移动一位

当当前元素为1的时候,当前元素后移

80. 删除排序数组中的重复项 II

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素最多出现两次，返回移除后数组的新长度。

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

示例 1:

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

示例 2:

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

说明:

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

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

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

1. // nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
2. int len = removeDuplicates(nums);
4. // 在函数里修改输入数组对于调用者是可见的。
5. // 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
6. for (int i = 0; i < len; i++) {
7.     print(nums[i]);
8. }

1. public int removeDuplicates(int[] nums) {
2. int i = 1, n = nums.length;
3. int count = 1;
4. while (i < n) {
5. if (nums[i] == nums[i - 1]) {
6. count++;
7. if (count > 2) {
8. removeEle(nums, i);
9. n--;
10. i--;
11. }
12. } else {
13. count = 1;
14. }
15. i++;
16. }
17. return n;
18. }
20. private int[] removeEle(int[] nums, int index) {
21. for (int i = index + 1; i < nums.length; i++) {
22. nums[i - 1] = nums[i];
23. }
24. return nums;
25. }

题解:设置指针i指向数组的下标为1的位置,

当前当前元素和前一个元素值相等时,当前元素的数量count加一

  当当前的元素个数大于2个的时候,删除当前元素,且将当前数组长度减一,当前指针i向前移动移动一个位置

当前元素和之前元素值不同的时候,设置当前元素数量count为1

当前元素下标i不断后移

返回新的数组长度n

142. 环形链表 II

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

示例 1：

1. 输入：head = [3,2,0,-4], pos = 1
2. 输出：tail connects to node index 1
3. 解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

1. 输入：head = [1,2], pos = 0
2. 输出：tail connects to node index 0
3. 解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

1. 输入：head = [1], pos = -1
2. 输出：no cycle
3. 解释：链表中没有环。

进阶：

你是否可以不用额外空间解决此题？

1. public ListNode detectCycle(ListNode head) {
2. if (head == null) {
3. return null;
4. }
5. ListNode slow = head;
6. ListNode fast = findNode(head);
7. while (fast != null && fast != slow) {
8. fast = fast.next;
9. slow = slow.next;
10. }
11. return fast;
12. }
13. private ListNode findNode(ListNode head) {
14. ListNode fast = head;
15. ListNode slow = head;
16. while (fast != null && fast.next != null) {
17. fast = fast.next.next;
18. slow = slow.next;
19. if (fast == slow) {
20. return slow;
21. }
22. }
23. return null;
24. }

题解:设置快指针fast和慢指针slow初始指向head节点

每次慢指针slow向后走一步,快指针每次向后走两步

当快慢指针指向同一个节点的时候,说明这个链表有环

回到程序,设置指针fast指向两个节点相遇的位置,指针slow指向head头结点

每次slow和fast同时向后走一步

两个指针再次相遇的位置即为入环节点