【力扣】【双指针】力扣刷题之经典双指针问题

最新推荐文章于 2023-07-26 22:49:00 发布

小天才才

最新推荐文章于 2023-07-26 22:49:00 发布

阅读量608

点赞数 4

分类专栏： # 力扣文章标签： leetcode 算法双指针

本文链接：https://blog.csdn.net/qq_44528283/article/details/122653150

版权

力扣专栏收录该内容

15 篇文章 4 订阅

订阅专栏

文章目录

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 <= 10⁴
-10⁴ <= nums[i] <= 10⁴
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 <= 10⁵
-2³¹ <= nums[i] <= 2³¹ - 1
0 <= k <= 10⁵

解题思路

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 * 10⁴
-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 <= 10⁵
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;
    }
};

小天才才

关注

4
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
【力扣】【双指针】力扣刷题之经典双指针问题

文章目录977.有序数组的平方189.轮转数组283.移动零167.两数之和 II - 输入有序数组344.反转字符串557.反转字符串中的单词 III876.链表的中间结点19.删除链表的倒数第 N 个结点977.有序数组的平方题目链接：https://leetcode-cn.com/problems/squares-of-a-sorted-array/给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。示例 1：输入：nums = [-4,-1
复制链接

扫一扫