双指针法
一、移除元素
思路
快慢指针,用快指针寻找新数组的元素,用慢指针更新新数组下标的位置
代码实现
class Solution {
public:
int removeElement(vector<int>& nums, int val) {
int slow = 0;
for(int fast = 0; fast < nums.size(); fast ++) {
if(nums[fast] != val) {
nums[slow] = nums[fast];
slow++;
}
}
return slow;
}
};
二、反转字符串
思路
定义两个指针,一个从字符串前面,一个从字符串后面,两个指针同时向中间移动,并交换元素
代码实现
class Solution {
public:
void reverseString(vector<char>& s) {
for (int i = 0, j = s.size() - 1; i < s.size()/2; i++,j--) {
swap(s[i],s[j]);
}
}
};
三、替换空格
思路
数组进行扩容,从后向前替换空格,避免从前向后替换要大量移动元素。
i指向新长度的末尾,j指向旧长度的末尾,先统计空格数量,要将2个空格替换为%20,需要增加空格数量*2个空间.如果j指向的不是空格,将j处的字符复制到i所指的位置,i和j同时向前移动;如果j指向空格,从i所指的位置依次向前填充,并将i移动到填充之后的位置,然后i和j同时向前移动
代码实现
class Solution {
public:
string replaceSpace(string s) {
int count = 0;
int sOldSize = s.size();
for(int i = 0; i < s.size(); i++) {
if(s[i] == ' ') {
count++;
}
}
s.resize(s.size() + count*2);
int sNewSize =s.size();
for( int i = sNewSize - 1, j = sOldSize - 1; j < i ; i--,j--) {
if(s[j] != ' ') {
s[i] = s[j];
} else {
s[i] = '0';
s[i - 1] = '2';
s[i - 2] = '%';
i -= 2;
}
}
return s;
}
};
四、反转字符串里的单词
思路
1.移除多余空格:与移除元素思想一样,通过使用快指针寻找目标字符串(没有空格的字符串),使用慢指针更新目标字符串的位置,如果快指针指向的不是空格,并且慢指针指向的不是起始位置,需要在单词前手动添加空格,慢指针后移,将快指针指向的字符复制到慢指针所指向的位置,快慢指针一起向后移动。
2.将整个字符反转,将每个单词反转
代码实现
class Solution {
public:
void reverse(string& s, int start, int end) { // 翻转区间:左闭右闭
for(int i = start, j = end; i < j; i++,j--) {
swap(s[i],s[j]);
}
}
void removeExtraSpaces(string& s) {
int slow = 0;
for(int fast = 0; fast < s.size(); ++fast) {
if(s[fast] != ' ') {
if(slow != 0) s[slow++] = ' ' ; //给单词之间添加空格
while(fast < s.size() && s[fast] != ' ') { // 遇到空格说明单词结束
s[slow++] = s[fast++];
}
}
}
s.resize(slow); // slow的大小即为去除多余空格后的大小
}
string reverseWords(string s) {
removeExtraSpaces(s); // 去除多余空格,保证单词之间只有一个空格
reverse(s,0,s.size() - 1);
int start = 0; // removeExtreaSpace后保证第一个单词的开始下标一定是0
for(int fast = 0; fast <= s.size(); ++fast) {
if(fast == s.size() || s[fast] == ' ') {
reverse(s, start, fast - 1);
start = fast + 1;
}
}
return s;
}
};
五、反转链表
思路
通过改变链表的next指针的指向,直接将链表反转。
定义一个cur指针,指向头结点,再定义一个pre指针,初始化为NULL,使用临时指针保存下一个cur的位置,并改变方向(cur->next=pre),先更新pre(pre=cur),再更新cur(cur=temp),当cur指针指向了NULL,循环结束,链表反转完毕,pre指针指向了新的头结点,返回头结点即可。
代码实现
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* temp;
ListNode* cur = head;
ListNode* pre = NULL;
while(cur) {
temp = cur->next;
cur->next = pre;
pre = cur;
cur = temp;
}
return pre;
}
};
六、删除链表的倒数第N个结点
思路
定义fast指针和slow指针,初始值为虚拟头结点,fast向前移动n步之后,fast和slow同时移动,当fast指向NULL时,slow就指向了倒数第n个结点,但是为了方便做删除,要找到被删除结点的上一个结点,因此,fast需要走n+1 步。
代码实现
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode* dummyHead = new ListNode(0);
dummyHead ->next = head;
ListNode* fast = dummyHead;
ListNode* slow = dummyHead;
while(n-- && fast != NULL) {
fast = fast->next;
}
fast = fast->next;
while(fast != NULL) {
fast = fast->next;
slow = slow->next;
}
slow->next = slow->next->next;
return dummyHead->next;
}
};
七、链表相交
思路
链表相交,交点是指针相同
求出两个链表的长度,并求出两个链表长度的差值,然后让curA移动到和curB末尾对齐的位置,比较curA和curB是否相同,如果不相同,同时向后移动curA和curB,如果curA==curB,则找到交点
代码实现
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
ListNode* curA = headA;
ListNode* curB = headB;
int lenA = 0,lenB = 0;
while(curA != NULL) { // 求链表A的长度
lenA++;
curA = curA->next;
}
while(curB != NULL) { // 求链表B的长度
lenB++;
curB = curB->next;
}
curA = headA;
curB = headB;
// 让curA为最长链表长度,lenA为其长度
if(lenB > lenA) {
swap(lenA, lenB);
swap(curA, curB);
}
// 求长度差
int gap = lenA - lenB;
// 让curA和curB在同一起点(末位位置对齐)
while(gap--) {
curA = curA->next;
}
// 遍历curA和curB,遇到相同则直接返回
while(curA != NULL) {
if(curA == curB) {
return curA;
}
curA = curA->next;
curB = curB->next;
}
return NULL;
}
};
八、环形链表
思路
定义fast和slow指针,从头结点出发,fast指针每次移动两个结点,slow指针每次移动一个结点,如果途中相遇,说明该链表有环。从头结点发出一个指针,从相遇结点发出一个指针,这两个指针每次只走一个结点,那么当这两个指针相遇的时候就是环形入口的结点。
代码实现
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode* fast = head;
ListNode* slow = head;
while(fast != NULL && fast->next != NULL) {//fast走在前面并且走两步
slow = slow->next;
fast = fast->next->next;
// 快慢指针相遇,从head和相遇点同时查找直至相遇
if(slow == fast) {
ListNode* index1 = fast;
ListNode* index2 = head;
while(index1 != index2) {
index1 = index1->next;
index2 = index2->next;
}
return index2; // 返回环的入口
}
}
return NULL;
}
};
九、三数之和
思路
将数组进行排序,然后有一层for循环,i从下标0的位置开始,定义下标left在i+1的位置上,定义right在数组结尾的位置上,如果三数相加大于零,right–,相加小于零,left++,等于零的话存入result数组
代码实现
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> result;
sort(nums.begin(), nums.end());
for(int i = 0; i < nums.size(); i++) {
if(nums[i] > 0) { // 排序之后,第一个大于0,必然没有满足条件的三元组
return result;
}
if(i > 0 && nums[i] == nums[i - 1]) {
continue;
}
int left = i + 1;
int right = nums.size() - 1;
while(right > left) {
if(nums[i] + nums[left] + nums[right] > 0) right--;
else if(nums[i] + nums[left] + nums[right] < 0) left++;
else {
result.push_back(vector<int>{nums[i], nums[left],nums[right]});
// 去重逻辑应该放在找到一个三元组之后,对b和c去重
while(right > left && nums[right] == nums[right - 1]) right --;
while(right > left && nums[left] == nums[left + 1]) left ++;
right--;
left++;
}
}
}
return result;
}
};
十、四数之和
思路
两层for循环nums[k] + nums[i]为确定值,依然是循环内有left和right下标作为双指针,找出nums[k] + nums[i] + nums[left] + nums[right] == target的情况
代码实现
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
vector<vector<int>> result;
sort(nums.begin(),nums.end());
for(int k = 0; k < nums.size(); k++) {
//剪枝处理
if(nums[k] > target && nums[k] >= 0) {
break;
}
// 对nums[k]进行去重
if(k > 0 && nums[k] == nums[k - 1]) {
continue;
}
for (int i = k + 1; i < nums.size() ;i++) {
if(nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
break;
}
//对nums[i]去重
if(i > k + 1 && nums[i] == nums[i - 1]) {
continue;
}
int left = i + 1;
int right = nums.size() - 1;
while(right > left) {
if((long) nums[k] + nums[i] + nums[left] +nums[right] > target) {
right--;
}
else if((long) nums[k] + nums[i] + nums[left] +nums[right] <target)
{ left++; }
else{
result.push_back(vector<int>{nums[k],nums[i],nums[left],nums[right]});
// 对nums[left]和nums[right]去重
while(right > left && nums[right] == nums[right - 1]) right--;
while(right > left && nums[left] == nums[left + 1]) left++;
//找到答案时,双指针同时收缩
right--;
left++;
}
}
}
}
return result;
}
};