算法学习——引导（排序）

第一题 按奇偶排序

class Solution {
public:

  
    vector<int> sortArrayByParity(vector<int>& nums) {
        if(nums.size() <= 1)
            return nums;
    //     //暴力 O(n) 
    //     vector<int> v1;
    //     vector<int> v2;
    //     for(const int & num : nums)
    //     {
    //         if(num % 2 == 0)
    //         {
    //             v1.push_back(num);
    //         }
    //         else
    //         {
    //             v2.push_back(num);
    //         }
    //     }
    //     copy(v2.begin(), v2.end(), back_inserter(v1));
    //     return v1;

    //排序加lamada表达式    O(nlogn)
    // sort(nums.begin(), nums.end(),[](int a, int b){return ((a % 2) - (b % 2)) < 0;});
    // return nums;
    
    // //双指针
    // vector<int> res(nums.size());
    // int left = 0;
    // int right = nums.size() - 1;
    // for(const int & num : nums)
    // {
    //     if(num % 2 == 0)
    //     {
    //         res[left++] = num;
    //     }
    //     else
    //     {
    //         res[right--] = num;
    //     }
    // }
    // return res;

    //原地交换 双指针+swap
    int left = 0;
    int right = nums.size() - 1;
    while(left < right)
    {
        while(left < right && nums[left] % 2 == 0)
        {
            left++;
        }
        while(left < right && nums[right] % 2 == 1)
        {
            right--;
        }
        if(left < right)
        {
            swap(nums[left++], nums[right--]);
        }
    }
    return nums;
    }
};

第二题 最小时间差

class Solution {
       
public:

    int findMinDifference(vector<string>& timePoints) {
        if(timePoints.size() < 2)
            return 0;
        int h = 0;
        int m = 0;
        char c;
        vector<int> ret(timePoints.size());
        for(int i = 0; i < timePoints.size(); i++)
        {
            // sscanf(timePoints[i], "%d:%d", &h, &m);//C++中没有sscanf 因为不安全
            istringstream iss(timePoints[i]);  
            iss >> h >> c >> m;  
            ret[i] = h * 60 + m;
        }
        sort(ret.begin(), ret.end(), less<int>());
        int ans = INT_MAX;//32位整数最大值
        for(int i = 1; i < timePoints.size(); i++)
        {
           ans = min(ans, ret[i] - ret[i - 1]);
            // if(ret[i] - ret[i - 1] < ans)
            // {
            //     ans = ret[i] - ret[i - 1];
            // }
        }
        ans = min(ans, (ret[0] + 1440 - ret[timePoints.size() - 1]));
        return ans;

        
    }
};

istringstream是一个比较有用的c++的输入输出控制类。

C++引入了ostringstream、istringstream、stringstream这三个类，要使用他们创建对象就必须包含<sstream>这个头文件。
istringstream类用于执行C++风格的串流的输入操作。
ostringstream类用于执行C风格的串流的输出操作。
strstream类同时可以支持C风格的串流的输入输出操作。


istringstream的构造函数原形如下：
istringstream::istringstream(string str);
它的作用是从string对象str中读取字符。


#include<iostream>  
#include<sstream>        //istringstream 必须包含这个头文件
#include<string>  
using namespace std;  
int main()  
{  
    string str="i an a boy";  
    istringstream is(str);  
    string s;  
    while(is>>s)  
    {  
        cout<<s<<endl;  
    }  
      
} 
输出是:
i
am
a
boy
————————————————
版权声明：本文为CSDN博主「longzaitianya1989」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/longzaitianya1989/article/details/52909786

第三题 最大间距

应该用桶排序？时间复杂度不符合要求

class Solution {
public:
    int maximumGap(vector<int>& nums) {
    //     时间复杂度 O(nlog n)  空间复杂度O（1）
    //     if(nums.size() < 2)
    //         return 0;
    //     sort(nums.begin(), nums.end());
    //     int difference = 0;
    //     for(int i = 1; i < nums.size(); i++)
    //     {
    //         if (nums[i] - nums[i - 1] > difference)
    //         {
    //             difference = nums[i] - nums[i - 1];
    //         }
    //     }
    //     return difference;
    
    

    }
};

第四题 多数元素

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        //排序取中
        // sort(nums.begin(),nums.end());
        // return nums[nums.size() / 2];

        //哈希表
        // unordered_map<int, int> counts;
        // int majority = 0;
        // int cnt = 0;
        // for(const int & num : nums)
        // {
        //     counts[num]++;
        //     if(counts[num] > cnt)
        //     {
        //         majority = num;
        //         cnt = counts[num];
        //     }
        // }
        // return majority;

        //分治
        


    }
};

第五题 排序数组

后续要补充学习其他排序，冒泡、快排、归并等

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        //直接库函数
        // sort(nums.begin(), nums.end(), less<int>());
        // return nums;
        //
    }
};