【20230217】【剑指1】双指针（简单）III

1. 调整数组顺序使奇数位于偶数前面

left从左出发，right从右出发

class Solution {
public:
    vector<int> exchange(vector<int>& nums) {
        int left=0;
        int right=nums.size()-1;
        if(nums.size()==0)  return {};
        while(right>left)
        {
            if(nums[left]%2==0&&nums[right]%2==1)
            {
                swap(nums[left],nums[right]);
                left++;
                right--;
            }   
            else if(nums[left]%2==0&&nums[right]%2==0)   right--;
            else if(nums[left]%2==1&&nums[right]%2==1)   left++;
            else    
            {
                left++;
                right--;
            }
        }
        return nums;
    }
};

2. 和为s的两个数字

用哈希表去做，但是效果不好

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> result;
        unordered_map<int,int> map;
        for(int i=0;i<nums.size();i++)
        {
            map[nums[i]]++;
            if(target-nums[i]==nums[i])
            {
                if(map[nums[i]]==2)
                {
                    result.push_back(nums[i]);
                    result.push_back(nums[i]);
                    return result;
                }
            }
            else
            {
                if(map[target-nums[i]]!=0)
                {
                    result.push_back(nums[i]);
                    result.push_back(target-nums[i]);
                    return  result;
                }
            }
        }
        return {};
    }
};

但是利用本身数组为有序数组的特性

双指针性能就好很多

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int left=0,right=nums.size()-1;
        while(right>left)
        {
            if(nums[left]+nums[right]==target)  return vector<int>{nums[left],nums[right]};
            if(nums[left]+nums[right]>target)   right--;
            if(nums[left]+nums[right]<target)   left++;
        }
        return {};
    }
};

3. 翻转单词顺序

1.首先得去除多余空格，双指针法，快慢指针，类似于数组中的移除元素，当快指针不为空格时就存到slow上，并且在fast找到字母时判断此时slow是不是在句首，不然的话，要加个空格；当fast比size小，并且一直为字母时，就一直赋给slow；resize改变原字符串大小，resize(slow)

2.写个反转字符串的函数

3.先反转整个字符串

4.用i去遍历，当找到一个空格时，就反转一个，或者就只有一个单词（i==s.size()）

class Solution {
public:
    void uniqueSpace(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);
    }
    void reverse(string& s,int left,int right){       
        for(int i=left,j=right;i<j;i++,j--)
        {
            swap(s[i],s[j]);
        }
    }
    string reverseWords(string s) {
        uniqueSpace(s);
        reverse(s,0,s.size()-1);
        int start=0;
        for(int i=0;i<=s.size();i++)
        {
            if(s[i]==' '||i==s.size()) 
            {
                reverse(s,start,i-1);
                start=i+1;
            }  
        }
        return s;
    }
};