【刷题记录1】算法|数据结构|C/C++

今天是2022年2月13号，发现自己刷了多少题就忘了多少（？

于是开个楼记录下（从今天起）写过的题目！同时也是为了督促自己~ 

1~50题https://blog.csdn.net/Sui_Chris/article/details/122908486?spm=1001.2014.3001.5502

51~100题 https://blog.csdn.net/Sui_Chris/article/details/123187418

1.leetcode-704. 二分查找

📅 ：22/2/13

📌：二分

int search(int* nums, int numsSize, int target){
    int left=0,right=numsSize-1;
    while (left<=right)
    {
        int mid=left+(right-left)/2;
        if(nums[mid]>target)
        {
            right=mid-1;
        }
        else if(nums[mid]<target)
        {
            left=mid+1;
        }
        else return mid;
    }
    return -1;
}

第一次写二分查找哈哈，刚开始只用中间值写，结果return -1的条件怎么写也写不对😂

2.leetcode-278. 第一个错误的版本

📅 ：22/2/13

📌：二分

// The API isBadVersion is defined for you.
// bool isBadVersion(int version);

int firstBadVersion(int n) {
    int left=1,right=n;
    while (left<right)
    {
        int mid=left+(right-left)/2;
        if(isBadVersion(mid))
        {
            if(!isBadVersion(mid-1))
            {
                return mid;
            }
            else
            {
                right=mid-1;
            }
        }
        else
        {
            left=mid+1;
        }
    }
    return left;
}

好家伙嘿嘿😊

3.leetcode-35. 搜索插入位置

📅 ：22/2/13

📌：二分

int searchInsert(int* nums, int numsSize, int target){
    int left=0,right=numsSize-1;
    while(left<right)
    {
        int mid=left+(right-left)/2;
        if(nums[mid]>target)
        {
            right=mid-1;
        }
        else if(nums[mid]<target)
        {
            left=mid+1;
        }
        else return mid;
    }
    if(nums[left]<target)
    {
        return left+1;
    }
    else //这里包含两种情况，一种是nums[left]==target和nums[left]>target
    {
        return left;
    }
}

第三道二分~熟练了已经（确信😋

4.leetcode-26. 删除有序数组中的重复项✅

📅 ：22/2/13

📌：数组|双指针

int removeDuplicates(int* nums, int numsSize){
    int f=0,s=1;//两个指针
    while (s<numsSize)
    {
        if(nums[s]==nums[f])s++;
        else
        {
            f++;
            nums[f]=nums[s];
            s++;
        }
    }
    return f+1;
}

5.leetcode-733. 图像渲染❌

📅 ：22/2/13

📌：图论|dfs

int n, m;
int** floodFill(int** image, int imageSize, int* imageColSize, int sr, int sc, int newColor, int* returnSize, int** returnColumnSizes){
    n = imageSize, m = imageColSize[0];
    *returnSize = n;
    returnColumnSizes = (int*)malloc(sizeof(int)*(n+5));
    for (int i = 0; i < n; i++) {
        returnColumnSizes[i] = m;
    }
    if(newColor!=image[sr][sc]){
        dfs(image,sr,sc,newColor,image[sr][sc]);
    }
    return image;
}
void dfs(int** image,int sr, int sc, int newColor,int color)
{
    if(sr<0 || sr>=n || sc<0 || sc>=m)
    {
        return;
    }
    if(image[sr][sc]==color)
    {
        image[sr][sc]=newColor;
        dfs(image,sr+1,sc,newColor,color);
        dfs(image,sr,sc+1,newColor,color);
        dfs(image,sr-1,sc,newColor,color);
        dfs(image,sr,sc-1,newColor,color);
    }
    return;
}

备注：（骂骂咧咧）一直过不了leetcode，每次都是访问溢出，我都malloc了还访问溢出，甚至吧官方的c的答案贴上去也是错的😢算了我dfs已经写出来了，就这样吧

6.leetcode-53. 最大子数组和

📅 ：22/2/13

📌：动态规划

int maxSubArray(int* nums, int numsSize) {
    int *dp,max=nums[0];
    dp=(int*)malloc(sizeof(int)*numsSize);
    dp[0]=nums[0];
    for(int i=1;i<numsSize;i++)
    {
        if(dp[i-1]<=0)
        {
            dp[i]=nums[i];
        }
        else
        {
            dp[i]=nums[i]+dp[i-1];
        }
        dp[i]>max?max=dp[i]:max;
    }
    return max;
}

磨了一下午！终于看懂评论区大神写的动态规划是啥意思了🧐

7.leetcode-977. 有序数组的平方

📅 ：22/2/14🌸

📌：双指针|数组

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* sortedSquares(int* nums, int numsSize, int* returnSize){
    int i,a,b,min=abs(nums[0]),imin=0;
    for(i=0;i<numsSize;i++)
    {
        if(abs(nums[i])<min)
        {
            min=abs(nums[i]);
            imin=i;
        }
    }
    a=imin-1;
    b=imin+1;
    int *re=(int*)malloc(sizeof(int)*numsSize);
    *returnSize=numsSize;
    re[0]=pow(min,2);
    for(i=1;a>=0 && b<numsSize;i++)
    {
        int af=pow(nums[a],2),bf=pow(nums[b],2);
        if(af>bf || a<0)
        {
            re[i]=bf;
            b++;
        }
        else
        {
            re[i]=af;
            a--;
        }
    }
    if(a<0 && b<numsSize)
    {
        for(;i<numsSize;i++,b++)
        {
            int bf=pow(nums[b],2);
            re[i]=bf;
        }
    }
    else if(a>=0 && b>=numsSize)
    {
        for(;i<numsSize;i++,a--)
        {
            int af=pow(nums[a],2);
            re[i]=af;
        }
    }
    return re;
}

感觉写的这个好复杂，看了官方的第二个双指针答案，还可以从0和n-1定双指针，这样就不用考虑一个指针走到边边的情况了。

写了下第二版双指针~😂

int* sortedSquares(int* nums, int numsSize, int* returnSize){
    int a=0,b=numsSize-1,*re,i=numsSize-1;
    re=(int*)malloc(sizeof(int)*numsSize);
    *returnSize=numsSize;
    for(;a<=b;i--)
    {
        int af=pow(nums[a],2),bf=pow(nums[b],2);
        if(af>bf)
        {
            re[i]=af;
            a++;
        }
        else
        {
            re[i]=bf;
            b--;
        }
    }
    return re;
}

8.leetcode-977. 有序数组的平方

📅 ：22/2/14🌸

📌：快排|数组

void quicksort(int *a,int left