字符串的最大公因子 /最小的k个数

第一题：

一个性质：如果 str1 和 str2 拼接后等于 str2和 str1 拼接起来的字符串（注意拼接顺序不同），那么一定存在上述条件的字符串 X；
证明过程

还有一个性质：如果X是str1和str2公共因子，那么X的长度就是str1 和str2长度的公约数，证明过程如上链接；

对于求公约数有如下经典算法：
欧几里德算法又称辗转相除法，是指用于计算两个正整数a，b的最大公约数。应用领域有数学和计算机两个方面。计算公式gcd(a,b) = gcd(b,a mod b)。

class Solution {
public:
    string gcdOfStrings(string str1, string str2) {
     if(str1+str2!=str2+str1)return "";
     auto ret= gcd(str1.size(),str2.size());
     return str1.substr(0,ret);   
    }
    int gcd(int a,int b)//求公约数
    {
        if(b==0)return a;
        return gcd(b,a%b);
    }   
};

第二题

方法一：
维护一个K个元素的最大堆，将数组中的元素依次与堆顶元素比较，如果小于就弹出堆顶，并将该数组元素插入堆顶；如果大于就什么也不做；时间复杂度为O(N*logk)，空间复杂度为O(k);
这里用最小堆也可以，但是那样插入元素的次数会增加；

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        if(k<=0)return {};
    vector<int>res; priority_queue<int,vector<int>,less<int>>mink(arr.begin(),arr.begin()+k);
        for(int i=k;i<arr.size();++i)
        {
            if(arr[i]<mink.top())
            { 
                mink.push(arr[i]);
                mink.pop();
            }
        }
        while(!mink.empty())
        {
            res.push_back(mink.top());
            mink.pop();
        }
       return res;
     
    }
};

方法二：
利用快排里的选轴点的思想，如果当前选择的轴点小于k,那么区间可以往右边收缩，否则就往左边收缩（类似于二分法的操作）；时间复杂度是O(N),空间复杂度O(1);

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        int l=0,r=arr.size()-1;
        while(l<r)
        {
            auto ind=setPivot(arr, l, r);
            if(k<ind)
                r=ind-1;
             else if(k>ind)
                l=ind+1; 
             else break;
        }
        return vector<int>(arr.begin(),arr.begin()+k);
    }
    
    size_t setPivot(vector<int>&v,int l,int r)//轴点选择
    {
        int pivot=v[l],index=l;
        while(l<r)
        {
            while(l<r&&v[r]>=pivot)
                --r;
            while(l<r&&v[l]<=pivot)
                ++l;
            swap(v[l],v[r]);
        }
        swap(v[l],v[index]);
        return l;
    }
};

方法三：
利用STL里的nth_element(),这个函数的实现原理就是方法二；

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {

        nth_element(arr.begin(),arr.begin()+k,arr.end());
        return vector(arr.begin(),arr.begin()+k);
    }
};