C语言leetcode刷题笔记2

已于 2024-05-13 12:57:53 修改
阅读量578 收藏 11
点赞数 12
文章标签： c语言 leetcode 笔记
于 2024-05-09 22:06:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35429166/article/details/138633957
版权

C语言leetcode刷题笔记2

第4题：283.移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。
示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

互换

void moveZeroes(int* nums, int numsSize) {
    int i,j,temp;
    int count=0;
    while(true){
        count=0;
        for(i=0;i<numsSize-1;i++)
         {
            if(nums[i]==0&&nums[i+1]!=0)
            {
                count++;
                temp =nums[i];
                nums[i]=nums[i+1];
                nums[i+1]=temp;
                

            }

         }
         if(count==0)break;

    }
    
    
}

在这里插入图片描述

void moveZeroes(int* nums, int numsSize) {
    int i,j,temp;
    for(j=1;j<numsSize;j++)
    {
        for(i=0;i<numsSize-1;i++)
         {
            if(nums[i]==0&&nums[i+1]!=0)
            {
                temp =nums[i];
                nums[i]=nums[i+1];
                nums[i+1]=temp;

            }

         }

    }
    
    
}

在这里插入图片描述

直接移动

//建立新数组，把不是0的先放进去，剩下的都是0，再赋值回去
//优化：直接在原来数组上操作
void moveZeroes(int* nums, int numsSize) {
    int count=0;
    for(int i=0;i<numsSize;i++)
    {
        if(nums[i]!=0){
            nums[count++]=nums[i];
            
        }
    }
    for(int i=count;i<numsSize;i++)
    {
        nums[count++]=0;

    }
    
}

第5题：122.买卖股票的最佳时机‖

一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。
在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。
返回 你能获得的 最大 利润 。

示例 1：

输入：prices = [7,1,5,3,6,4]
输出：7
解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。
总利润为 4 + 3 = 7 。

递归（超时）

int maxProfit(int* prices, int pricesSize) {
    int res=0;
    int profit=0;
    if(pricesSize==1)return 0;
//[7,1,5,3,6,4]
    //假设最后一天不卖
    profit=maxProfit(prices, pricesSize-1);
    res=profit>res?profit:res;

    //假设最后一天卖
    //maxProfit([7,1,5,3,6])+4-4
    //maxProfit([7,1,5,3])+4-6
    //...
    //maxProfit([7])+4-1
    for(int i=1;i<pricesSize;i++)
    {
        profit=maxProfit(prices, i)+prices[pricesSize-1]-prices[i-1];
        res=profit>res?profit:res;

    }
    return res;
    
}

在这里插入图片描述
递归次数过多导致超时，建立数组存储数据

动态规划

int maxProfit(int* prices, int pricesSize) {
    if(pricesSize==1)return 0;
    int profits[pricesSize+1];//profits[i]=maxProfit(prices,i);
    profits[1]=0;
    for(int k=2;k<=pricesSize;k++)
    {
        int res=0;
        int profit=0;
        
    //[7,1,5,3,6,4]
        //假设最后一天不卖
        profit=profits[k-1];//maxProfit(prices, pricesSize-1);
        res=profit>res?profit:res;

        //假设最后一天卖
        //maxProfit([7,1,5,3,6])+4-4
        //maxProfit([7,1,5,3])+4-6
        //...
        //maxProfit([7])+4-1
        for(int i=1;i<k;i++)
        {
            profit=profits[i]+prices[k-1]-prices[i-1];
            res=profit>res?profit:res;

        }
        profits[k]=res;
    }
    return profits[pricesSize];
    
}

在这里插入图片描述

贪心算法

//贪心算法 只要涨了就卖
int maxProfit(int* prices, int pricesSize) {
    int to=0;
    for(int i=1;i<pricesSize;i++)
    {
        if(prices[i]>prices[i-1])to+=prices[i]-prices[i-1];

    }
    return to;
    
}

第6题：49.字母异位词分组

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的所有字母得到的一个新单词。

示例 1:

输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]
输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
 struct pair{
    char * s1;
    char * s1_qsort;
 };
 typedef struct pair Pair;
 int cmp(void *a,void *b)
 {
    return (*(char *)a -  *(char *)b);
    //return ( *(int*)a - *(int*)b );
 }
 int paircmp(void *a,void *b)
 {
    Pair * Pa=(Pair*)a;
    Pair * Pb=(Pair*)b;
    return strcmp(Pa->s1_qsort,Pb->s1_qsort);
 }
char*** groupAnagrams(char** strs, int strsSize, int* returnSize, int** returnColumnSizes) {
    *returnSize=0;
    * returnColumnSizes=NULL;
    char***res=NULL;
    Pair * pairs=(Pair *)malloc(sizeof(Pair)*strsSize);

    for(int i=0;i<strsSize;i++)
    {
        pairs[i].s1=strs[i];
        pairs[i].s1_qsort=(char*)malloc(sizeof(char)*(strlen(strs[i])+1));
        strcpy(pairs[i].s1_qsort,pairs[i].s1);
        qsort(pairs[i].s1_qsort,strlen(strs[i]),sizeof(char),cmp);
        
    }
    qsort(pairs,strsSize,sizeof(Pair),paircmp);
    int group=0;//记录最后组坐标
    int index=0;//记录组内坐标
    for(int i=0;i<strsSize;i++)
    {
        if(i==0)
        {
            group=0;
            index=0;
            *returnSize=group+1;//1zu
     
            *returnColumnSizes=(int*)malloc(sizeof(int)*1);
            (*returnColumnSizes)[group]=index+1;
            res=(char***)malloc(sizeof(char**)*(*returnSize));
            res[group]=(char**)malloc(sizeof(char*)*((*returnColumnSizes)[group]));
            res[group][index]=(char*)malloc(sizeof(char)*(strlen(pairs[i].s1)+1));
            strcpy(res[group][index],pairs[i].s1);
            

        }
        else
        {
            if(strcmp(pairs[i-1].s1_qsort,pairs[i].s1_qsort)!=0)//no equal
            {
                group++;
                index=0;
                *returnSize=group+1;//group++
        
                *returnColumnSizes=(int*)realloc(*returnColumnSizes,sizeof(int)*(group+1));
                (*returnColumnSizes)[group]=index+1;
                res=(char***)realloc(res,sizeof(char**)*(group+1));
                res[group]=(char**)malloc(sizeof(char*)*(index+1));
                res[group][index]=(char*)malloc(sizeof(char)*(strlen(pairs[i].s1)+1));
                

            }
            else//equal
            {
                index++;
                (*returnColumnSizes)[group]=index+1;
                res[group]=(char**)realloc(res[group],sizeof(char*)*(index+1));
                res[group][index]=(char*)malloc(sizeof(char)*(strlen(pairs[i].s1)+1));              

            }
            strcpy(res[group][index],pairs[i].s1);

        }
        
        
        
    }


    return res;
}

优化

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
 struct pair{
    char * s1;
    char * s1_qsort;
 };
 typedef struct pair Pair;
 int cmp(void *a,void *b)
 {
    return (*(char *)a -  *(char *)b);
    //return ( *(int*)a - *(int*)b );
 }
 int paircmp(void *a,void *b)
 {
    Pair * Pa=(Pair*)a;
    Pair * Pb=(Pair*)b;
    return strcmp(Pa->s1_qsort,Pb->s1_qsort);
 }
char*** groupAnagrams(char** strs, int strsSize, int* returnSize, int** returnColumnSizes) {
    int NofG[10000]={0};//记录每组总个数
    int Gs=0,Gc=0;
    *returnSize=0;
    * returnColumnSizes=NULL;
    char***res=NULL;
    Pair * pairs=(Pair *)malloc(sizeof(Pair)*strsSize);

    for(int i=0;i<strsSize;i++)
    {
        pairs[i].s1=strs[i];
        pairs[i].s1_qsort=(char*)malloc(sizeof(char)*(strlen(strs[i])+1));
        strcpy(pairs[i].s1_qsort,pairs[i].s1);
        qsort(pairs[i].s1_qsort,strlen(strs[i]),sizeof(char),cmp);
        
    }
    qsort(pairs,strsSize,sizeof(Pair),paircmp);
    for(int i=0;i<strsSize;i++)
    {
        
        if(i==0)//no equal
        {
            Gc=1;
            
        }
        else
        {
            if(strcmp(pairs[i-1].s1_qsort,pairs[i].s1_qsort)!=0)//no equal
            {
                
                NofG[Gs]=Gc;
                //printf("%d NofG[Gs]=%d\n",i,NofG[Gs]);
                Gc=1;
                Gs++;

            }
            else
            {
                Gc++;

            }
            
            
        }


    }
    NofG[Gs++]=Gc;
    res=(char***)malloc(sizeof(char**)*Gs);
    *returnColumnSizes=(int*)malloc(sizeof(int)*(Gs));
    *returnSize=Gs;
    for(int i=0;i<Gs;i++)
    {
        res[i]=(char**)malloc(sizeof(char*)*(NofG[i]));
        (*returnColumnSizes)[i]=NofG[i];

    }
    
    int group=-1;//记录最后组坐标
    int index=0;//记录组内坐标

    for(int i=0;i<strsSize;i++)
    {
        
            if(i==0||strcmp(pairs[i-1].s1_qsort,pairs[i].s1_qsort)!=0)//no equal
            {
                group++;
                index=0;
            }
            else//equal
            {
                index++;
              
            }
             res[group][index]=(char*)malloc(sizeof(char)*(strlen(pairs[i].s1)+1));  
            strcpy(res[group][index],pairs[i].s1);               
    }
    return res;
}
cyz24
关注
  • 12
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LeetCode刷题笔记.rar
07-05
《LeetCode刷题笔记》是针对LeetCode这个在线编程挑战平台的个人学习心得与总结，主要涵盖数据结构和算法两大核心领域。LeetCode是一个全球知名的编程训练网站，它提供了丰富的编程题目，帮助开发者提升编程技能，...
LeetCode 刷题笔记 with Java.zip
11-23
《LeetCode刷题笔记withJava》是一份专为Java开发者准备的算法实战指南，涵盖了LeetCode网站上前一百道编程挑战题目。这份资料旨在帮助程序员提升算法能力，掌握数据结构和问题解决技巧，对于准备面试或者想要提升...
leetcode刷题笔记（c语言）
q13099138865的博客
10-10 160
4.函数要返回一个线性表作为结果，在函数中要用malloc申请这个线性表内存，不能直接申请数组，因为函数结束这个数组会被销毁。2.接上一条，如果不在输出数组末尾写上'\0'，则会报地址错误，可以用msmset，或者结束了加'\0'1.力扣如果要返回数组指针，该数组首元素不能是空，否则系统认为数组内全是空。10.malloc申请的内存就算不返回用也要在末尾加'\0'，不然报错。6.int型变量如果使用负值，就报错，类似地址溢出的错误。11.a[10]是定义了有十个元素的数组，元素为从0~9。
LeetCode刷题笔记 --- python
纸短情长的博客
01-21 2180
Leecode刷题笔记
Leetcode刷题笔记——哈希表篇
qq_42898642的博客
02-09 1054
本文给大家介绍了哈希表在面试中的高频考题以及哈希表和其他算法结合的考察形式，可以看到哈希表再结合其他知识点的应用中还是稍稍有点难的，比较考察大家对于数据结构的基础知识（尤其是LRU和设计哈希集合这两道题），祝大家面试顺利，面试碰到原题，找到心仪的offer，冲冲冲~
Leetcode 刷题笔记：字符串篇
qq_27673853的博客
01-16 327
Leetcode刷题笔记：字符串篇
C语言leetcode刷题笔记3
qq_35429166的博客
05-13 681
给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true。设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。给你单链表的头结点 head ，请你找出并返回链表的中间结点。--> 返回 -3.void push(int val) 将元素val推入堆栈。int getMin() 获取堆栈中的最小元素。输入：head = [1,2,3,4,5]void pop() 删除堆栈顶部的元素。int top() 获取堆栈顶部的元素。
【力扣】C语言刷题笔记
m0_55477386的博客
02-20 348
用while（1）循环，在需要退出的地方写break。%x, %X 无符号以十六进制表示的整数。写定义一个变量，也可以在输出的时候直接写在。%0 无符号以八进制表示的整数。在%d前加数字可以表示输出的字符位数，表示为 左对齐的8位字符的整数。%d 十进制有符号整数。%u 十进制无符号整数。%e 指数形式的浮点数。%g 自动选择合适的表示法。表示为右对齐的8位字符整数。判断a与b哪个值大输出哪个。三目运算，可以直接用。
leetcode刷题笔记
shaun2001的博客
03-19 393
leetcode刷题笔记
leetcode刷题指南c语言版,leetcode剑指指南刷题笔记
weixin_42196279的博客
05-22 487
这里是剑指offer的一些笔记，有几道困难题没做，以后会不上，题解是按照做题序号来的。数组中重复的数字新建一个标记数组记录每个数字出现的次数。暴力搜索class Solution:def findRepeatNumber(self, nums: List[int]) -> int:flags = [0]* len(nums)for i in range(len(nums)):flags[nu...
C语言leetcode刷题笔记_1（哈希表练习）
qq_40311533的博客
04-14 871
c语言使用哈希表练习 1、指针变量定义 （1）int *a = 0;(错：此时在定义地址值) （2）int* returnSize; *returnSize = 0; （报错，只能初始化一个地址？） （3）正确定义1 int target = 3; int* returnSize; returnSize = &target; （4）正确定义2 int target = 3; int* returnSize = &target; 2、malloc C语言：
谷歌高畅Leetcode刷题笔记.pdf
08-04
谷歌高畅leetcode刷题笔记
LeetCode刷题笔记
05-29
LeetCode全栈攻略：高效刷题笔记分享 从零开始到技术大牛的必经之路，提升算法能力与编程技巧。 内容概要： 欢迎来到这个全面解析LeetCode刷题心得的世界！这里汇集了我数月来的点滴努力和收获，旨在帮助你在...
【Leetcode刷题笔记】栈
12-22
2. **常规解法**： - 初始化一个空栈S。 - 遍历输入字符串s的每个字符，如果是开括号（'('，'{'，'['），则将其压入栈S中。 - 如果遇到闭括号，检查栈顶元素是否为其匹配的开括号。如果是，则弹出栈顶元素；否则...
C语言 ——— 学习、使用memcpy函数 并模拟实现
weixin_55341642的博客
08-07 244
源头数据，源头数据不用改变，使用加上const修饰，且同样不知道是什么类型的数据，所以使用void*指针接收。拷贝结束后，会返回目标空间的起始地址，因为并不知道目标空间的类型，所以是返回void*的指针。memcpy函数是内存拷贝函数，用于把任意类型的数据的内存拷贝到另一个同类型的数据上。目的地数据，需要被拷贝的数据，因为是任意类型，所以使用void*指针接收。需要从源头数据拷贝到目的地数据多少个字节。
顺序表各种接口的实现(C)
最新发布
CoderZzz6310的博客
08-10 587
数据结构中顺序表的增删查改的实现
C语言 软件设计的七大原则，及其应用案例
qq_19343801的博客
08-08 432
一个模块或函数应当只有一个引起变化的原因。
【C总集篇】第一章 认识C语言
铁匠匠匠的博客
08-08 281
【代码】【C总集篇】第一章 认识C语言。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值