【小菜鸡刷题记】----双指针篇
- 剑指 Offer 18. 删除链表的节点
- 剑指 Offer 22. 链表中倒数第k个节点
- 剑指 Offer 25. 合并两个排序的链表
- 剑指 Offer 52. 两个链表的第一个公共节点
- 剑指 Offer 21. 调整数组顺序使奇数位于偶数前面
- 剑指 Offer 57. 和为s的两个数字
- 剑指 Offer 57 - II. 和为s的连续正数序列
特此声明：本期题目皆来自于力扣
剑指 Offer 18. 删除链表的节点
【题目链接】
给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。返回删除后的链表的头节点
示例 1:
输入: head = [4,5,1,9], val = 5 输出: [4,1,9]
解释: 给定你链表中值为 5的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:输入: head = [4,5,1,9], val = 1 输出: [4,5,9]
解释: 给定你链表中值为 1的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
class Solution {
public:
ListNode* deleteNode(ListNode* head, int val) {
if(head->val==val)
return head->next;
ListNode* cur=head->next;
ListNode* pre=head;//注意要加一个前驱，避免删除节点后断开连接
//遍历删除指定节点
while(cur)
{
if(cur->val==val)
{
pre->next=cur->next;
break;
}
else
{
pre=cur;
cur=cur->next;
}
}
// while(cur != nullptr && cur->val != val) {
// pre = cur;
// cur = cur->next;
// }
// if(cur != nullptr)
// pre->next = cur->next;
return head;
}
};
剑指 Offer 22. 链表中倒数第k个节点
【题目链接】
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。
例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
class Solution {
public:
//快慢指针法：快指针先走k-1步
//然后和慢指针一起走，当快指针走到结尾，慢指针的位置就是倒数第k个节点
ListNode* getKthFromEnd(ListNode* head, int k) {
if(head==nullptr||k==0) return nullptr;
ListNode* cur=head;
ListNode* fast=head;
for(int i=0;i<k-1;i++)
{
if(fast->next)
{
fast=fast->next;
}
else
return nullptr;
}
while(fast->next)
{
cur=cur->next;
fast=fast->next;
}
return cur;
}
};
剑指 Offer 25. 合并两个排序的链表
【题目链接】
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。
示例1：
输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode* head=new ListNode(-1);
ListNode* tail=head;
ListNode* cur1=l1;
ListNode* cur2=l2;
//双指针遍历，找出节点值小的那个尾插到头结点后面，循环直到其中一个链表全部插入完
while(cur1 && cur2)
{
if(cur1->val < cur2->val)
{
tail->next=cur1;
cur1=cur1->next;
}
else
{
tail->next=cur2;
cur2=cur2->next;
}
tail=tail->next;
}
//合并后 l1 和 l2 最多只有一个还未被合并完，
//我们直接将链表末尾指向未合并完的链表即可
if(cur1)
{
tail->next=cur1;
}
if(cur2)
{
tail->next=cur2;
}
ListNode* rhead=head->next;
delete head;
return rhead;
}
};
剑指 Offer 52. 两个链表的第一个公共节点
【题目链接】
输入两个链表，找出它们的第一个公共节点。
class Solution {
public:
//获取链表长度
int len(ListNode* head)
{
int len=0;
ListNode* cur=head;
while(cur)
{
len++;
cur=cur->next;
}
return len;
}
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
int lenA=len(headA);
int lenB=len(headB);
int num=abs(lenA-lenB);
//假设A长B短
ListNode* longhead=headA;
ListNode* shorthead=headB;
if(lenA<lenB)
{
longhead=headB;
shorthead=headA;
}
//长链表先走差值步数
for(int i=0;i<num;++i)
{
longhead=longhead->next;
}
//同时走
while(longhead!=shorthead)
{
longhead=longhead->next;
shorthead=shorthead->next;
}
//处理特殊情况，没有公共交点
if(longhead==nullptr&&shorthead==nullptr)
{
return nullptr;
}
ListNode* node=longhead;
return node;
}
};
剑指 Offer 21. 调整数组顺序使奇数位于偶数前面
【题目链接】
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数在数组的前半部分，所有偶数在数组的后半部分。
输入：nums = [1,2,3,4]
输出：[1,3,2,4]
注：[3,1,2,4] 也是正确的答案之一。
快排思想：左边从左往右不断找偶数，右边从右往往左找奇数，然后交换
class Solution {
public:
vector<int> exchange(vector<int>& nums) {
if(nums.size()<2)
{
return nums;
}
int begin=0;
int end=nums.size()-1;
while(begin<end)
{
while(begin<end && (nums[begin]&1)==1)//从左往右找偶数
{
begin++;
}
while(begin<end && (nums[end]&1)==0)//从右往左找奇数
{
end--;
}
if(begin<end)
{
swap(nums[begin],nums[end]);
}
}
return nums;
}
};
剑指 Offer 57. 和为s的两个数字
【题目链接】
输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[2,7] 或者 [7,2]
示例 2：输入：nums = [10,26,30,31,47,60], target = 40
输出：[10,30] 或者 [30,10]
思路：定义两个指针，从头和尾一起遍历，如果尾部大于给定值，尾部往前移动；如果头部的值+尾部的值比给定值大，尾部指针前移；如果比给定值大，头部指针后移；直到找到两个值之和与给定值相等
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
vector<int> v(2);
if(nums.size()<2)
{
return v;
}
int begin=0;
int end=nums.size()-1;
while(begin<end)
{
while(nums[end]>target && begin<end)
end--;
int sum=nums[begin]+nums[end];
if(sum>target) end--;
else if(sum<target) begin++;
else
{
v[0]=nums[begin];
v[1]=nums[end];
break;
}
}
return v;
}
};
使用STL容器，减少代码长度，但是增加了空间复杂度
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
vector<int> v;
unordered_set<int> set(nums.begin(),nums.end());
for(auto& e:nums)
{
if(set.count(target-e))
{
return {e,target-e};
}
}
return v;
}
};
剑指 Offer 57 - II. 和为s的连续正数序列
【题目链接】
输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。
序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。
示例 1：
输入：target = 9
输出：[[2,3,4],[4,5]]
示例 2：输入：target = 15
输出：[[1,2,3,4,5],[4,5,6],[7,8]]
**解题思路：**这道题目我也是借助双指针，一个代表最小值，一个代表最大值，如果当前序列和小于s,就增大最大值，如果当前序列和大于s，就减去最小值，直到找到和为s的序列；找到的数据是一个序列，我有设计一个Result函数用来取出数据存放进vector内，并将结果返回，添加到二维数组中
class Solution {
public:
//每次结果
vector<int> Result(int begin,int end)
{
vector<int> v;
for(int i=begin;i<=end;++i)
{
v.push_back(i);
}
return v;
}
vector<vector<int>> findContinuousSequence(int target) {
int begin=1;
int end=2;
int mid=(target+1)/2;
int sum=begin+end;
vector<vector<int>> vv;
//递增数组，如果起始位置是中间值，还没有找到合为s的连续序列，那就没有这种序列
while(begin<mid)
{
if(sum==target)
{
vv.push_back(Result(begin,end));
}
//太大，减去最小值
while(begin<mid && sum>target)
{
sum-=begin;
begin++;
if(sum==target)
{
vv.push_back(Result(begin,end));
}
}
//sum<target 增大最大值
++end;
sum+=end;
}
return vv;
}
};
