Leeetcode刷题记录2

最新推荐文章于 2024-10-31 16:16:13 发布

早日退休我的梦

最新推荐文章于 2024-10-31 16:16:13 发布

阅读量145

点赞数

分类专栏：刷啦啦文章标签： leetcode 算法哈希算法 Powered by 金山文档

本文链接：https://blog.csdn.net/qq_45776901/article/details/128943635

版权

刷啦啦专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本文探讨了使用位异或操作解决只出现一次的数字问题，以及在C语言中如何处理多数元素。此外，还分析了通过排序和双指针优化三数之和问题的算法，以及利用哈希表高效解决两数之和问题。所有方法都关注了时间与空间复杂度的优化。

摘要由CSDN通过智能技术生成

136.只出现一次的数字

按位异或^

时间：O(n)

空间: O(1)

int singleNumber(int* nums, int numsSize){
    //异或
    int i,value=nums[0];
    for(i=1;i<numsSize;i++){
            value=value^nums[i];
    }
    return value;
}

哈希表排除，不符合题意时间空间都是O(n)

169.多数元素

返回元素肯定只有一个，因为大于【2/n】，求counts中的max即可

哈希表创建解题不适合C语言

时间：O(n)

空间: O(n)

int majorityElement(int* nums, int numsSize){
    // int arr[numsSize]={0};
    // int arr[numsSize中最大的数]={0};无法确认？开销异常大×错误
    C创建hash表，代码庞大
    ...

    int Min=0;
    for(int i=0;i<numsSize;i++){
        arr[i]+=1
        if(arr[i]>Min){
            Min=arr[i];
            lable=i;
    }
    }
    return i;

}

python利用collections实现哈希表，max（counts）返回最大数

class Solution(object):
    def majorityElement(self, nums):
        counts = collections.Counter(nums)
        print(counts)
        return max(counts.keys(), key=counts.get)

排序：c++里的sort函数

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

//降序返回a【0】只通过部分
class Solution {
public:
    int majorityElement(vector<int>& nums) {
            sort(nums.begin(),nums.end(),greater<int>());
            return nums[0];
    }
};

15.三数之和

暴力枚举，时间复杂度O（n^3）

首先将数组进行排序第一层循环不管，0 与 “第一层与第二层之和”的差，会随着第二层属的增大越来越小，即第二层数增大的同时第三层的数在缩小。同时性使得时间复杂度由O(n^3)变为O(n^2)，这个“同时性”、“一边地址增大一边地址缩小”的特性可以运用双指针解决问题。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int n=nums.size();
        sort(nums.begin(),nums.end());//默认升序less<T>()
        vector<vector<int>> retu;
        for(int i=0;i<n;i++){
            if(i>0 && nums[i]==nums[i-1]){
                continue;
                }//跳出本次循环
            int k=n-1;
            int minus= -nums[i];
            for(int j=i+1;j<n;j++){
                if(j>i+1&&nums[j]==nums[j-1]){
                    continue;
                    }
                while(j<k && nums[j]+nums[k] > minus){
                    k--;
                    }
                if(k==j){
                    break;
                    }
                if(nums[j]+nums[k]== minus)
                   {retu.push_back({nums[i], nums[j], nums[k]});
                   } 
            }           
        } return retu;
    }   
};

出现错误：i,j,k写错；[i+1]写成[i]+1

1.两数之和

//暴力遍历
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    for(int i=0;i<numsSize;i++){
        for(int j=i+1;j<numsSize;j++){
            int shu=nums[i]+nums[j];
            if(target==shu){
                
                nums[0]=i;
                nums[1]=j;
            }
        }
    }
    *returnSize=2;
    return nums;
}

struct HashTable
    {  //数，地址 
        int key;
        int value;
        UT_hash_handle hh;
    };

    // 创建哈希表
struct HashTable* hashtable;


struct HashTable* find(int i){
    struct HashTable* tmp;
    HASH_FIND_INT(hashtable,&i,tmp);
    return tmp;

}

void insert(int a,int b ){
    struct HashTable* tmp=find(a);
    if(tmp==NULL){
        struct HashTable* tmp1=malloc(sizeof(struct HashTable));
        tmp1->key=a,tmp1->value=b;
        HASH_ADD_INT(hashtable,key,tmp1);
    }
    else{ 
        tmp->value=b;
    }
}


int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    hashtable=NULL;//初始化
    for(int i=0;i<numsSize;i++){
        struct HashTable* it=find(target-nums[i]);
        if(it!=NULL){//非空
            int* re=malloc(sizeof(int)*2);
            re[0]=it->value,re[1]=i;
            *returnSize=2;
            return re;
        }
        insert(nums[i],i);
    }
    *returnSize=0;
    return NULL;
}