三数之和 四数之和 反转字符串 反转字符串||

1.给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
#include
using namespace std;
vector> ThreeSum(vector& num)
{
    vector> result;
    sort(num.begin(),num.end());
    for(int i=0;i     {
        if(num[i]>0)
        return result;
        if(i>0&&num[i]==num[i-1])
        {
            continue;
        }
        int left=i+1;
        int right=num.size()-1;
        while(left         {
            if(num[i]+num[left]+num[right]<0)
            {
                left++;
            }
            else if(num[i]+num[left]+num[right]>0)
            {
                right--;
            }
            else
            {
                result.push_back(vector{num[i],num[left],num[right]});
            }
            while(right>left&&num[right]==num[right-1])
            {
                right--;
            }
            while(right>left&&num[left]==num[left+1])
            {
                left++;
            }
            right--;
            left++;
        }
        
        
    }
    
    return result；
    
 } 
 int main()
 {
     vector nums={-1, 0, 1, 2, -1, -4};
     vector> temp=ThreeSum(nums);
     for(const auto& three:temp)
     {
         for(int n:three)
         {
             cout<          }
         cout<      }
     return 0;
 }

思路：用的是双指针的思想，效率比用哈希法好一些。

首先，根据问题我们要找三个数满足和为0，先遍历所给数组，i从0开始遍历，我们不妨假设sum[i]就是我们所要找的a，然后根据a的值去寻找符合的b和c，其实b和c分别就是sum[left]和sum[right]，left指向i+1的位置，right指向数组末尾，只要一开始i=0时sum[i]!=0，就可以往后去寻找合适的left,right。寻找过程中无非出现三种情况，1.num[i]+num[left]+num[right]>0，2.num[i]+num[left]+num[right]<0，3.num[i]+num[left]+num[right]=0。

当出现情况1时，需要进行right--的操作，即尽可能让和减小以至于接近0。当出现情况2时，需要进行left++的操作，即尽可能让和增加以至于接近0。当出现情况3时正好满足条件，将其放置result数组中。

对于a的去重操作，无外乎我们会在2个选项中感到疑惑，即sum[i]==sum[i+1]和sum[i]==sum[i-1]。对于sum[i]==sum[i+1]，它针对的其实是三元组中出现重复的元素，比如{-1，-1，2}，明显这是符合要求的三元组，但是sum[i]==sum[i+1]操作会将其去掉，这样就出现问题了。反观sum[i]==sum[i-1]，当i指向第一个-1时，会发现这是一个满足条件的三元组，会将其放置到result中，而当i继续指向第二个-1时，就会将其continue，因为此时i=-1，如果在此基础上去寻找left和right满足和为0的三元组，结果也必定只能是{-1，-1，2}，但是这是不可能找到的，因为往后的值只会越来越大，因此不必再进行无用的遍历。所以我们选择sum[i]==sum[i-1]作为a去重的条件。

对于left和right的去重，其逻辑应该放在找到一个三元组之后

 

2.题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

#include
using namespace std;
vector> fourSum(vector& num,int target)
{
    vector> result;
    sort(num.begin(),num.end());
    
    
    for(int k=0;k  {
        if(num[k]>target&&num[k]>=0)
        {
            break;
        }
        
        if(k>0&&num[k]==num[k-1])
        {
            continue;
        }
        
    
    
    for(int i=k+1;i     {
        if(num[i]+num[k]>target&&num[i]+num[k]>=0)
        {
            break;
        }
        if(i>k+1&&num[i]==num[i-1])
        {
            continue;
        }
    
    int left=i+1;
    int right=num.size()-1;
    while(right>left)
    {
        if((long) num[k]+num[i]+num[left]+num[right]>target)
        {
            right--;
        }
        else if((long) num[k]+num[i]+num[left]+num[right]         {
            left++;
        }
        else
        {
            result.push_back(vector{num[k],num[i],num[left],num[right]});
            while(right>left&&num[right]==num[right-1])
            {
                right--;
            }
            while(right>left&&num[left]==num[left+1])
            {
                left++;
                
            }
            right--;
        left++;
        }
     }
        
    }
 }
    return result;
    
    
}

int main()
{
    vector nums={1, 0, -1, 0, -2, 2};
    int t=0;
    vector> temp=fourSum(nums,t);
    for(const auto& four:temp)
    {
        for(int n:four)
        {
            cout<         }
        cout<     }
    return 0;
}
思路：这道题其实可以看作沿用了三数之和的思想，就是多了一层外循环，同时和变成了变量，可能为负数。首先，先循环遍历定a的值，先进行剪枝操作，对于三数之和的剪枝操作只需要满足大于0，因为它的target本身就是0，而四数之和不是，它的target可能等于负数，所以条件要求大于等于0。另外就是对a的去重操作，num[k]==num[k-1]，与三数之和类似。这是第一层循环，接着是确定b的值，也算是确定（a+b）的值，仍是进行剪枝和去重的操作。

这里同时也用到了双指针法，即left和right，left在k的后面，right仍在末尾。其余操作类似。

3.编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

#include
using namespace std;
void reverseString(vector& s)
{
    int len=s.size();
    for(int i=0,j=len-1;i     {
        swap(s[i],s[j]);
    }
    
}
 int main()
 {
     vector str={'a','b','c','d'};
     reverseString(str);
     for(char c:str)
     {
         cout<      }
     return 0;
 }
 思路:使用双指针法，i指向字符串头，j指向字符串末尾，两者相互交换，每移动一位交换一次。

 4.给定一个字符串 s 和一个整数 k，从字符串开头算起, 每计数至 2k 个字符，就反转这 2k 个字符中的前 k 个字符。

#include
using namespace std;
string reverseString(string s,int k)
{
    for(int i=0;i     {
        if(i+k<=s.size())
        {
            reverse(s.begin()+i,s.begin()+i+k);
        }
        else
        {
            reverse(s.begin()+i,s.end());
        }
    }
    return s;
    
}
int main()
{
    string str="asdfgh";
    str=reverseString(str,2);
    for(char n:str)
    {
        cout<     }
    return 0; 
}

 思路：首先遍历字符串的时候，不是i++而是i+=2*k，因为题目要求每2k个字符内才进行反转。同时还要考虑在末尾处剩余的字符数量与2k的比较，如果大于k而小于2k，就要反转前k个字符，所以判断条件为i+k<=s.size()。如果是小于k，就要全部反转。