【力扣】【双指针】力扣刷题之经典双指针问题
文章目录
-
-
- 977.有序数组的平方
- 189.轮转数组
- 283.移动零
- 167.两数之和 II - 输入有序数组
- 344.反转字符串
- 557.反转字符串中的单词 III
- 876.链表的中间结点
- 19.删除链表的倒数第 N 个结点
-
977.有序数组的平方
题目链接：https://leetcode-cn.com/problems/squares-of-a-sorted-array/
给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。
示例 1：
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
示例 2：
输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]
提示：
1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按非递减顺序排序
解题思路
直接对所有元素平方，然后排序，如果想降低时间复杂度可以考虑用双指针，也就是利用有序数组这一性质。
class Solution
{
public:
vector<int> sortedSquares(vector<int>& nums)
{
vector<int> ans;
for (int num: nums)
{
ans.push_back(num * num);
}
sort(ans.begin(), ans.end());
return ans;
}
};
189.轮转数组
题目链接：https://leetcode-cn.com/problems/rotate-array/
给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
示例 1:
输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]
示例 2:
输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释:
向右轮转 1 步: [99,-1,-100,3]
向右轮转 2 步: [3,99,-1,-100]
提示：
1 <= nums.length <= 105
-231 <= nums[i] <= 231 - 1
0 <= k <= 105
解题思路
reverse函数可以实现数组的翻转，在形参里面指定翻转的开始和结束即可。
class Solution {
public:
void rotate(vector<int>& nums, int k)
{
reverse(nums.begin() , nums.end() - k % nums.size());
reverse(nums.end() - k % nums.size() , nums.end());
reverse(nums.begin() , nums.end());
}
};
283.移动零
题目链接：https://leetcode-cn.com/problems/move-zeroes/
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:
必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。
解题思路
用两个指针left和right，刚开始都指向数组的第一个元素，之后left指向待处理序列的前一个元素，right指向待处理序列的第一个元素，然后right右移，遇到零元素就与非零元素交换。
class Solution
{
public:
void moveZeroes(vector<int>& nums)
{
int n = nums.size(), left = 0, right = 0;
while (right < n)
{
if (nums[right])
{
swap(nums[left], nums[right]);
left++;
}
right++;
}
}
};
167.两数之和 II - 输入有序数组
题目链接：https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted/
给定一个已按照 非递减顺序排列 的整数数组 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
仅存在一个有效答案
解题思路
二分查找，首先固定一个数，然后在这个数的右侧利用二分法查找与之相符的数字，使他们和为target。
class Solution
{
public:
vector<int> twoSum(vector<int>& numbers, int target)
{
for (int i = 0; i < numbers.size(); ++i)
{
int left = i + 1, right = numbers.size() - 1;
while (left <= right)
{
int mid = (right - left) / 2 + left;
if (numbers[mid] == target - numbers[i]) return {i + 1, mid + 1};
else if (numbers[mid] > target - numbers[i]) right = mid - 1;
else left = mid + 1;
}
}
return {-1, -1};
}
};
344.反转字符串
题目链接：https://leetcode-cn.com/problems/reverse-string/
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
示例 1：
输入：s = ["h","e","l","l","o"]
输出：["o","l","l","e","h"]
示例 2：
输入：s = ["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]
提示：
1 <= s.length <= 105
s[i] 都是 ASCII 码表中的可打印字符
解题思路
双指针，利用首尾指针进行字符交换。
class Solution
{
public:
void reverseString(vector<char>& s)
{
int n = s.size();
for (int left = 0, right = n - 1; left < right; ++left, --right)
{
swap(s[left], s[right]);
}
}
};
557.反转字符串中的单词 III
题目链接：https://leetcode-cn.com/problems/reverse-words-in-a-string-iii/
给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。
示例：
输入："Let's take LeetCode contest"
输出："s'teL ekat edoCteeL tsetnoc"
提示：
在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。
解题思路
首先遍历字符串，通过空格分隔识别出每个单词，每个单词用双指针实现反转。
class Solution
{
public:
string reverseWords(string s)
{
int length = s.length();
int i = 0;
while (i < length)
{
int start = i;
while (i < length && s[i] != ' ')
{
i++;
}
int left = start, right = i - 1;
while (left < right)
{
swap(s[left], s[right]);
left++;
right--;
}
while (i < length && s[i] == ' ')
{
i++;
}
}
return s;
}
};
876.链表的中间结点
题目链接：https://leetcode-cn.com/problems/middle-of-the-linked-list/
给定一个头结点为 head 的非空单链表，返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。
示例 1：
输入：[1,2,3,4,5]
输出：此列表中的结点 3 (序列化形式：[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意，我们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.
示例 2：
输入：[1,2,3,4,5,6]
输出：此列表中的结点 4 (序列化形式：[4,5,6])
由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。
提示：
给定链表的结点数介于 1 和 100 之间。
解题思路
定义两个指针first和second，刚开始初始化为表头结点，first一次走一步，second一次走两步，当second走到表尾时，first指向的就是中间结点。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution
{
public:
ListNode* middleNode(ListNode* head)
{
ListNode* first = head;
ListNode* second = head;
while (second != NULL && second->next != NULL)
{
first = first->next;
second = second->next->next;
}
return first;
}
};
19.删除链表的倒数第 N 个结点
题目链接：https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1
输出：[]
示例 3：
输入：head = [1,2], n = 1
输出：[1]
提示：
链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz
解题思路
定义两个指针first和second，刚开始让first先走n步，然后first和second一起走，当first走到表尾时，second指向的就是倒数第n个结点，删除即可。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution
{
public:
ListNode* removeNthFromEnd(ListNode* head, int n)
{
ListNode* ljw = new ListNode(0, head);
ListNode* first = head;
ListNode* second = ljw;
for (int i = 0; i < n; ++i)
{
first = first->next;
}
while (first)
{
first = first->next;
second = second->next;
}
second->next = second->next->next;
ListNode* ret = ljw->next;
delete ljw;
return ret;
}
};