leetcode刷题笔记

排序

两个数组的交集

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> nums1_set(nums1.begin(),nums1.end());
        unordered_set<int> ans;
        for(int i:nums2){
            if(nums1_set.count(i)==1){
                ans.insert(i);
            }
        }
        return vector<int>(ans.begin(),ans.end());
    }
};

两个数组的交集 II

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        sort(nums1.begin(),nums1.end());
        sort(nums2.begin(),nums2.end());
        vector<int> ans;
        int i=0,j=0;
        while(i<nums1.size()&&j<nums2.size()){
            if(nums1[i]<nums2[j]) i++;
            else if(nums1[i]>nums2[j]) j++;
            else {
                ans.push_back(nums1[i]);
                i++,j++;
            }
        }
        return ans;
    }
};

排序加双指针

按奇偶排序数组 II

class Solution {
public:
    vector<int> sortArrayByParityII(vector<int>& A) {
        int i=0,j=1;
        // 对偶数索引进行排序，当发现偶数索引出现奇数时，在奇数索引上寻找第一个偶数进行交换，当偶数满足条件时，奇数也满足条件了
        for(i=0;i<A.size();i+=2){
            if(A[i]%2!=0){
                while(A[j]%2==1){
                    j+=2;
                }
                int temp=A[i];
                A[i]=A[j];
                A[j]=temp;
            }
        }

        return A;
    }
};

对偶数索引进行排序，当发现偶数索引出现奇数时，在奇数索引上寻找第一个偶数进行交换，当偶数满足条件时，奇数也满足条件了

三角形的最大周长

class Solution {
public:
    int largestPerimeter(vector<int>& A) {
       sort(A.begin(),A.end());
        for(int i=A.size()-1;i>=2;i--){
            int a=A[i];
            int b=A[i-1];
            int c=A[i-2];
            if(b+c>a){
                //当前最大的三个数可以组成三角形
                return a+b+c;
            }
        }

        return 0;
    }
};

排序后开始从最大可能的数字开始判断

[数组的相对排序](https://leetcode-cn.com/problems/relative-sort-array/

)

class Solution {
public:
    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
        int tmp=0;
        for(int i=0;i<arr2.size();i++){
            for(int j=0;j<arr1.size();j++){
                if(arr1[j]==arr2[i]){
                    swap(arr1[tmp],arr1[j]);
                    tmp++;
                }
            }
        }
        sort(arr1.begin()+tmp,arr1.end());
        return arr1;
    }
};

暴力解决，利用双循环将数组1的数字依次与数组二相比较，相同则与前面元素交换位置
数组1中剩余元素利用sort函数进行排序即可

非递增顺序的最小子序列

class Solution {
public:
    vector<int> minSubsequence(vector<int>& nums) {
        vector<int> ans;
        sort(nums.begin(),nums.end());
        int target=0;
        for(int i=0;i<nums.size();i++){
            target+=nums[i];
        }
        target/=2;
        int sum=0;
        int index=nums.size()-1;
        while(index>=0){
        sum+=nums[index];
        ans.push_back(nums[index]);
        if(sum>target){
            return ans;
        }
        index--;
        }

        return ans;
    }
};

可以排序，然后从后往前找，找到最短的、和大于整个数组和一半的、子数组即可

重新排列字符串

class Solution {
public:
    string restoreString(string s, vector<int>& indices) {
        int len=s.length();
        string ans(len,0);
        for(int i=0;i<len;i++){
            ans[indices[i]]=s[i];
        }
        return ans;
    }
};