学习日志（一）-CSDN博客

本文链接：https://blog.csdn.net/2301_79433391/article/details/134088606

板块一：将数字反转两次后是否还是同一个数

解法一

解法二：不超时的解法，但时间和空间层面上可能不同

板块一：将数字反转两次后是否还是同一个数

题目链接：https://leetcode.cn/problems/a-number-after-a-double-reversal/description/

解法一：

bool isSameAfterReversals(int num){
    if(num%10==0&&num!=0)
    {
        return false;
    }
    return true;
}

解法二：

bool isSameAfterReversals(int num){
    return !num||num%10;
}

板块二：斐波那契额数列（初级版）

题目链接：https://leetcode.cn/problems/fibonacci-number/submissions/477849964/

int fib(int n){
    int f[60]={0,1};
    for(int i=2;i<=n;i++)
    {
        f[i]=f[i-1]+f[i-2];
    }
    return f[n];
}

板块三：删除中间节点（链表）

题目链接：https://leetcode.cn/problems/delete-middle-node-lcci/

void deleteNode(struct ListNode* node) {
    node->val=node->next->val,node->next=node->next->next;
}

板块四：缺失的第一个正数（键值对）

题目链接：https://leetcode.cn/problems/first-missing-positive/description/

解法一：简单粗暴但超时

C语言版

int firstMissingPositive(int* nums, int numsSize){
    for(int i=1;i<=10000000;i++)
    {
        int summ=1;
        for(int j=0;j<numsSize;j++)
        {
            if(i==nums[j])
            {
                summ=0;
            }
        }
        if(summ==1)
        {
            return i;
        }
    }
    return 0;
}

python版

class Solution(object):
    def firstMissingPositive(self, nums):
        for i in range(1,10000000):
            if i not in nums:
                return i

解法二：不超时的解法，但时间和空间层面上可能不同

C语言版：

利用C语言中的一个排序API——qsort进行递增排序（后面会对这个排序进行解释）

int compare(const void*a,const void*b)//(1)
{
    int cmpa=*(int*)a;
    int cmpb=*(int*)b;
    return cmpa>cmpb?1:-1;
}

int * sort(int *nums,int numsSize)//(2)
{
    qsort(nums,numsSize,sizeof(int),compare);
    return nums;
}

int firstMissingPositive(int* nums, int numsSize){
    int *p;
    sort(nums,numsSize);
    int num=1;
    for(int i=0;i<numsSize;i++)
    {
        if(num<nums[i])
        {
            return num;
        }
        if(num==nums[i])
        {
            num++;
        }
    }
    return num;
}

（1）为比较函数

（2）为排序函数

python版

1、其一：用sorted排序

class Solution(object):
    def firstMissingPositive(self, nums):
        nums=sorted(nums)
        now=1
        for num in nums:
            if num>now:
                return now
            if num=now:
                now+=1
        return now

2、其二：用哈希

class Solution(object):
    def firstMissingPositive(self, nums):
      hash = {}
      for num in nums:
        hash[num] = 1
      for x in range(1,1000000):
        if x not in hash:
          return x

3、目前我能找到的最优的算法

class Solution(object):
    def firstMissingPositive(self, nums):
      return min(set(range(1,len(nums)+2))-set(nums))

板块五：两数之和

题目链接：https://leetcode.cn/problems/two-sum/

暴力求解：

int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    for(int i=0;i<numsSize;i++)
    {
        for(int j=0;j<numsSize;j++)//可以写成int j=i+1
        {
            if(nums[i]+nums[j]==target&&i!=j)
            {
                int *ret =malloc(sizeof(int)*2);
                ret[0]=i,ret[1]=j;
                *returnSize=2;
                return ret;
            }
        }
    }
    *returnSize=0;
    return NULL;
}

很麻烦的解法：

class Solution {

    bool binFind(vector<int>&copy,int l,int r,int val)//二分查找函数
    {
        while(l<=r)
        {
            int mid=(l+r)>>1;
            if(val==copy[mid])
            {
                return true;
            }
            else if(val>copy[mid])
            {
                l=mid+1;
            }
            else
            {
                r=mid-1;
            }
        }
        return false;
    }

    int linearFind(vector<int>&nums,int l,int r,int val)//线性查找
    {
        for(int i=l;i<=r;i++)
        {
            if(nums[i]==val)
            {
                return i;
            }
        }
        return -1;
    }


public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector <int> copy(nums);//拷贝一份数组
        sort(copy.begin(),copy.end());//将数组强行排序
        int n=nums.size();
        int x;
        for(int i=0;i<n;i++)
        {
            x=copy[i];
            if(binFind(copy,i+1,n-1,target-x))//二分查找
            {
                break;
            }
        }
        int a=linearFind(nums,0,n-1,x);
        int b=linearFind(nums,a+1,n-1,target-x);
        if(b==-1)
        {
            b=linearFind(nums,0,a-1,target-x);
        }
        return { a, b };
    }
};

这是我目前能找到的最优算法：

//map是红黑树，underde_map就变成了使用哈希
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        underde_map<int,int>has;
        int n = nums.size();
        for(int i=n-1;i>=0;i++)
        {
            if(has.find(target - nums[i])!=has.end())
            {
                return {has[target-nums[i]],i};//返回下标
            }
            has[nums[i]]=i;
        }
        return {};
    }
};