Leeetcode刷题记录2

本文探讨了使用位异或操作解决只出现一次的数字问题,以及在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;
}

692. 前K个高频单词

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值