有序数组求“两”数之“和”篇：
给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
返回容器可以储存的最大水量。
说明：你不能倾斜容器。
示例 1：
输入：[1,8,6,2,5,4,8,3,7] 输出：49 解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
思路：使用两个指针分别指向最左面和最右面的height，然后逐步地向中心靠拢，每次移动计算面积与面积的目前最大值进行比较与更新。
问题在于：怎么移动，移动哪一个指针呢？为了追求面积的最大化应该移动height较小的指针。
class Solution {
public int maxArea(int[] height) {
int res = 0, len = height.length;
int left = 0, right = len - 1;
while(left<right){
res = Math.max(res, Math.min(height[left], height[right])*(right-left));
if(height[left] < height[right]) ++left;
else --right;
}
return res;
}
}给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列 ，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。
以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。
你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。
你所设计的解决方案必须只使用常量级的额外空间。
示例 1：
输入：numbers = [2,7,11,15], target = 9 输出：[1,2] 解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。
思路：对于前面的两数之和我们使用哈希表解决，这里要求常量级额外空间所以无法使用哈希表。
考虑对有序数组使用双指针，从数组两端向中心靠拢。
class Solution {
public int[] twoSum(int[] numbers, int target) {
int low = 0, high = numbers.length - 1, sum = 0;
while(low<high){
sum = numbers[low] + numbers[high];
if(sum > target) --high;
if(sum < target) ++low;
if(sum == target) break;
}
return new int[]{low + 1, high + 1};
}
}给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例 1：
输入：nums = [-1,0,1,2,-1,-4] 输出：[[-1,-1,2],[-1,0,1]] 解释： nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。 nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。 nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。 不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。 注意，输出的顺序和三元组的顺序并不重要。
思路：先使用一个双指针，分别指向头尾，在头指针后面紧跟一个扫描指针，用于对每一个头尾指针的情形下对中间的元素进行扫描。
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
int len = nums.length;
Arrays.sort(nums);
List<List<Integer>> res = new ArrayList();
for(int left = 0;left < len;++left){
if(left>0 && nums[left] == nums[left-1]) continue;
int right = len - 1;
int target = -nums[left];
for(int middle = left+1;middle<right;++middle){
if(middle>left+1 && nums[middle] == nums[middle-1]) continue;
while(middle<right && nums[right] + nums[middle] > target) --right;
if(middle == right) break;
if(nums[middle] + nums[right] == target){
List<Integer> tri = new ArrayList();
tri.add(nums[left]);
tri.add(nums[middle]);
tri.add(nums[right]);
res.add(tri);
}
}
}
return res;
}
}给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。
返回这三个数的和。
假定每组输入只存在恰好一个解。
示例 1：
输入：nums = [-1,2,1,-4], target = 1 输出：2 解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
思路：与上面的“三数之和”极其类似，只是需要改变一下判断条件而已
class Solution {
public int threeSumClosest(int[] nums, int target) {
Arrays.sort(nums);
int len = nums.length;
int sum = 0, best = -1000000;
for(int left = 0;left<len;++left){
if(left>0 && nums[left] == nums[left-1]) continue;
int right = len - 1, middle = left + 1;
while(middle < right){
sum = nums[left] + nums[middle] + nums[right];
if(sum == target) return target;
if(Math.abs(target - sum) < Math.abs(target - best)){
best = sum;
}
if(sum > target){
while(right>0&&nums[right-1] == nums[right]) --right;
--right;
}else{
while(middle<right-1&&nums[middle]==nums[middle+1]) ++middle;
++middle;
}
}
}
return best;
}
}给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：
0 <= a, b, c, d < na、b、c和d互不相同nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。
示例 1：
输入：nums = [1,0,-1,0,-2,2], target = 0 输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
示例 2：
输入：nums = [2,2,2,2,2], target = 8 输出：[[2,2,2,2]]
思路：在三数之和上多嵌套一层即可
class Solution {
public List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>> res = new ArrayList();
Arrays.sort(nums);
int len = nums.length;
for(int first=0;first<len-3;++first){
if(first > 0&&nums[first] == nums[first - 1]) continue;
for(int second=first+1;second<len-2;++second){
if(second > first+1 && nums[second] == nums[second-1]) continue;
int third = second + 1;
int last = len - 1;
while(third < last){
long sum = (long) nums[first] + nums[second] + nums[third] + nums[last];
if(sum == target){
List<Integer> numList = new ArrayList();
numList.add(nums[first]);
numList.add(nums[second]);
numList.add(nums[third]);
numList.add(nums[last]);
res.add(numList);
while(third<last && nums[third] == nums[third+1]) ++third;
while(third<last && nums[last] == nums[last-1]) --last;
++third;
--last;
}else if(sum>target){
--last;
}else{
++third;
}
}
}
}
return res;
}
}给定一个非负整数 c ，你要判断是否存在两个整数 a 和 b，使得 a2 + b2 = c 。
示例 1：
输入：c = 5 输出：true 解释：1 * 1 + 2 * 2 = 5
class Solution {
public boolean judgeSquareSum(int c) {
long left = 0, right = (long) Math.sqrt(c), ans = 0;
while(left <= right){
ans = left * left + right * right;
if(ans == c) return true;
if(ans > c) --right;
if(ans < c) ++left;
}
return false;
}
}数组移除元素
快慢指针法
难度简单3077收藏分享切换为英文接收动态反馈
给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。
由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。
将最终结果插入 nums 的前 k 个位置后返回 k 。
不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
class Solution {
public int removeDuplicates(int[] nums) {
int n = nums.length;
if (n == 0) {
return 0;
}
int fast = 1, slow = 1;
while (fast < n) {
if (nums[fast] != nums[fast - 1]) {
nums[slow] = nums[fast];
++slow;
}
++fast;
}
return slow;
}
}给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
class Solution {
public int removeElement(int[] nums, int val) {
int n = nums.length;
int left = 0;
for (int right = 0; right < n; right++) {
if (nums[right] != val) {
nums[left] = nums[right];
left++;
}
}
return left;
}
}可以对本题的双指针进行优化(没多大意义)
class Solution {
public int removeElement(int[] nums, int val) {
int left = 0;
int right = nums.length;
while (left < right) {
if (nums[left] == val) {
nums[left] = nums[right - 1];
right--;
} else {
left++;
}
}
return left;
}
}给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
示例 1：
输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3 输出：[1,2,2,3,5,6] 解释：需要合并 [1,2,3] 和 [2,5,6] 。 合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。
示例 2：
输入：nums1 = [1], m = 1, nums2 = [], n = 0 输出：[1] 解释：需要合并 [1] 和 [] 。 合并结果是 [1] 。
思路：逆向双指针
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
int p1 = m-1, p2 = n-1, p = m+n-1;
while(p1>=0 && p2>=0){
if(nums1[p1] <= nums2[p2]) nums1[p--] = nums2[p2--];
else nums1[p--] = nums1[p1--];
}
while(p2>=0) nums1[p--] = nums2[p2--];
}
}链表篇：
在链表中使用两个或者多个指针是极其平凡的。
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：
输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1]
class Solution {
public ListNode reverseList(ListNode head) {
if(head == null || head.next == null) return head;
ListNode prev = null;
ListNode curr = head;
ListNode aftr = head.next;
while(aftr != null){
curr.next = prev;
prev = curr;
curr = aftr;
aftr = aftr.next;
}
curr.next = prev;
return curr;
}
}给你一个链表的头节点 head ，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
如果链表中存在环 ，则返回 true 。 否则，返回 false 。
示例 1：
输入：head = [3,2,0,-4], pos = 1 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。
思路一：照抄1.两数之和的思路使用哈希集合
public class Solution {
public boolean hasCycle(ListNode head) {
Set<ListNode> nodes = new HashSet();
while(head != null){
if(!nodes.add(head)) return true;
head = head.next;
}
return false;
}
}思路二：双指针--快慢指针
在使用快慢指针解题之前，首先需要了解 Floyd算法（龟兔赛跑算法）：
假设在链表的开始节点有一只乌龟一只兔子准备赛跑，兔子的速度比乌龟快所以会一直领先于乌龟，那么：
1. 如果链表中没有环：兔子更早的抵达终点；
2.如果链表中有环：兔子先进入环并跑圈，等到乌龟进入环的时候，兔子还在环中，二者速度不同总会在环内的某一个节点相遇（兔子把乌龟扣圈了），也就是说，我们根本不必介怀于环的入口在哪，只要乌龟兔子相遇了，那么一定是有环的。
public class Solution {
public boolean hasCycle(ListNode head) {
if (head == null || head.next == null) return false;
ListNode slow = head;
ListNode fast = head.next;
while (slow != fast) {
if (fast == null || fast.next == null) {
return false;
}
slow = slow.next;
fast = fast.next.next;
}
return true;
}
}给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表。
思路：考虑上述141.环形链表的两个快慢指针的路程关系:
a：环前路程；b：环路程；f：快指针路程；s：慢指针路程
f = 2s ; f = s + nb => s = nb
又：所有到达环入口的节点路程都应该符合：walk = a + nb => s再走a步就刚好符合，所以只需要让s再走a步。
如何统计s走a步？使用另一个指针从head出发，二者会在环入口节点相遇。
附加：如果存在环，如何判断环的长度呢？方法是，快慢指针相遇后继续移动，直到第二次相遇。两次相遇间的移动次数即为环的长度
public class Solution {
public ListNode detectCycle(ListNode head) {
if(head == null || head.next == null) return null;
ListNode slow = head;
ListNode fast = head;
do{
if(fast == null || fast.next == null) return null;
slow = slow.next;
fast = fast.next.next;
}while(slow != fast);
ListNode tmp = head;
while(tmp != slow){
tmp = tmp.next;
slow = slow.next;
}
return slow;
}
}给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode dummy = new ListNode(0, head);
ListNode first = head;
ListNode second = dummy;
for (int i = 0; i < n; ++i) {
first = first.next;
}
while (first != null) {
first = first.next;
second = second.next;
}
second.next = second.next.next;
ListNode ans = dummy.next;
return ans;
}
}给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。
示例 1：
输入：head = [1,2,3,4,5], left = 2, right = 4 输出：[1,4,3,2,5]
class Solution {
public ListNode reverseBetween(ListNode head, int left, int right) {
ListNode dummy = new ListNode();
dummy.next = head;
ListNode slow = dummy;
ListNode fast = dummy;
int len = 0;
while(len < left - 1){
fast = fast.next;
++len;
}
slow = fast;
while(len < right){
fast = fast.next;
++len;
}
reverseList(slow, slow.next, fast.next);
return dummy.next;
}
public void reverseList(ListNode hair, ListNode head, ListNode tail) {
if(head == tail || head.next == tail) return;
ListNode prev = tail;
ListNode curr = head;
ListNode aftr = head.next;
while(aftr != tail){
curr.next = prev;
prev = curr;
curr = aftr;
aftr = aftr.next;
}
curr.next = prev;
hair.next = curr;
}
}字符串篇：
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
示例 1：
输入：s = ["h","e","l","l","o"] 输出：["o","l","l","e","h"]
class Solution {
public void reverseString(char[] s) {
int left = 0, right = s.length - 1;
char tmp = ' ';
while(left < right){
tmp = s[left];
s[left++] = s[right];
s[right--] = tmp;
}
}
}给你一个字符串 s ，仅反转字符串中的所有元音字母，并返回结果字符串。
元音字母包括 'a'、'e'、'i'、'o'、'u'，且可能以大小写两种形式出现不止一次。
示例 1：
输入：s = "hello" 输出："holle"
class Solution {
public String reverseVowels(String s) {
char[] c = s.toCharArray();
int left = 0;
int right = c.length-1;
char tmp = ' ';
Set<Character> charTable = new HashSet(){{
add('a');add('A');add('e');add('E');
add('i');add('I');add('o');add('O');add('u');add('U');
}};
while(left < right){
while(left<right && !charTable.contains(c[left])) ++left;
while(left<right && !charTable.contains(c[right])) --right;
tmp = c[left];
c[left++] = c[right];
c[right--] = tmp;
}
return String.valueOf(c);
}
}
7798
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
