力扣Leetcode刷题笔记

一、排序

1. 冒泡排序法

class Solution {
public:
    void sortColors(vector<int>& nums) {
        bubbleSort(nums);
    }
    void bubbleSort(vector<int>& array){
        int size=array.size();
        for(int i=0;i<size-1;i++){
            for(int j=0;j<size-i-1;j++){
                if(array[j]>array[j+1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
    }
};

二、哈希表

1. 单值哈希   添加哈希值

 

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> result;          //定义长度不确定的数组
        unordered_set<int> s1,s2;       //定义单值哈希
        for(int x:nums1){
            s1.insert(x);     //添加哈希值
        }
        for(int y:nums2){
            s2.insert(y);
        }
        for(int y:s2){
            if(s1.count(y)){
                result.push_back(y);      //添加数组的值
            }
        }
        return result;
    }
};

2. 双值哈希  记录哈希值个数   遍历哈希

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int> result;               //定义长度不确定的数组
        unordered_map<int,int> s1,s2;      //定义双值哈希表
        for(int x:nums1){
            ++s1[x];               //记录哈希值个数
        }
        for(int y:nums2){
            ++s2[y];
        }
        for(auto &z:s2){            //遍历哈希
            if(s1.count(z.first)){         //z.first  z.second  ...
                for(int i=0;i<(s1[z.first]<s2[z.first]?s1[z.first]:s2[z.first]);i++)
                result.push_back(z.first);    //添加数组
            }
        }
        return result;
    }
};

3. 双值哈希  值键类型不同  emplace_back加入  遍历哈希

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        vector<vector<string>> result;
        unordered_map<string,vector<string>> hash;    //值键不同哈希表
        for(string str:strs){
            string temp=str;
            sort(temp.begin(),temp.end());
            hash[temp].emplace_back(str);      //hash[值].emplace_back(键) 加入哈希表
        }
        for(auto &has:hash){                //遍历哈希
            result.emplace_back(has.second);
        }
        return result;
    }
};

三、数组

1. 动态数组  push_back添加数组

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> result;          //定义长度不确定的数组
        unordered_set<int> s1,s2;       //定义单值哈希
        for(int x:nums1){
            s1.insert(x);     //添加哈希值
        }
        for(int y:nums2){
            s2.insert(y);
        }
        for(int y:s2){
            if(s1.count(y)){
                result.push_back(y);      //添加数组的值
            }
        }
        return result;
    }
};

2. 动态数组   .back()返回数组最后一个元素

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        if (intervals.size() == 0) {
            return {};
        }
        sort(intervals.begin(), intervals.end());
        vector<vector<int>> merged;
        for (int i = 0; i < intervals.size(); ++i) {
            int L = intervals[i][0], R = intervals[i][1];
            if (!merged.size() || merged.back()[1] < L) {   //.back()返回数组最后一个元素
                merged.push_back({L, R});
            }
            else {
                merged.back()[1] = max(merged.back()[1], R);
            }
        }
        return merged;
    }
};

四、字符串

1. 截取字符串substr（当前索引，截取长度）

• 小技巧

1. 找不同 两数组分别求总数  总数相减

class Solution {
public:
    char findTheDifference(string s, string t) {
        int sTotal=0,tTotal=0;
        for(int i=0;i<s.length();i++){
            sTotal+=s[i];
        }
        for(int j=0;j<t.length();j++){
            tTotal+=t[j];
        }
        return tTotal-sTotal;

    }
};

2. &&左边的条件匹配才会执行右边的  sort从大到小排序

class Solution {
public:
    int thirdMax(vector<int>& nums) {
        int size=nums.size();
        
        sort(nums.begin(),nums.end(),greater());   //sort从大到小排序
        int index=size-1;
        int count=0;
        for(int i=1,diff=1;i<size;i++){
            if(nums[i]!=nums[i-1]&&++diff==3){
                return nums[i];
            }
        }
        
        return nums[0];
    }
};

3. 贪心算法   遇到不合适跳出两重循环

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());
        int gSize=g.size();
        int sSize=s.size();
        int count=0;
        for(int i=0,j=0;i<gSize&&j<sSize;i++,j++){
            while(j<sSize&&g[i]>s[j]){
                j++;     //在这里
            }
            if(j<sSize){
                count++;
            }
        }
        return count;
    }
};

4. 二分查找

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

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int n=nums.size();
        if(n==0){
            return {-1,-1};
        }
        int left=0,right=n-1;
        int l,r;
        while(left<right){        //找开头
            int mid1=left+(right-left)/2;
            if(nums[mid1]<target) left=mid1+1;
            else right=mid1;
        }
        if(nums[left]==target) l=left;
        else return {-1,-1};

        right=n-1;
        while(left<right){       //找结尾
            int mid2=left+(right-left+1)/2;
            if(nums[mid2]<=target) left=mid2;
            else right=mid2-1;
        }
        r=left;
        return {l,r};
    }
};

参考文献：C++算法——二分法查找_二分查找c++-CSDN博客