LeetCode刷题笔记【数组】

已于 2022-09-26 13:13:57 修改
阅读量801 收藏 1
点赞数
文章标签： leetcode 算法 职场和发展
于 2022-09-13 16:50:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47039902/article/details/126835500
版权

《考研向》leetcode数据结构与程序设计刷题(数组篇，含思路解答）

485最大连续1的个数

在这里插入图片描述

算法思想：
1.设置两个变量max,curmax。其中max代表最大连续1的个数，curmax代表当前最大连续1的个数。
2.遍历数组，如果当前变量为1，则curmax++，并且比较当前curmax和max的大小，如果curmax更大则替换。
3.如果当前变量为0，则把curmax置为0。

int findMaxConsecutiveOnes(int* nums, int numsSize){
     int max=0,curmax=0;
     for(int i=0;i<numsSize;i++)
     {
         if(nums[i]==1)
         {
            curmax++;
             if(curmax>max)
                 max=curmax;
         }
         if(nums[i]==0)
            curmax=0;             
         }
     return max;
}

495 提莫攻击

在这里插入图片描述

动态转移方程为 sum += min(nums[i] - nums[i - 1], duration)
1.设置变量sum用来存储输出的数据。
2.遍历数组
如果前后两个元素之差小于duration，则sum+两元素之差；如果前后两个元素之差大于duration，则sum+duration。

int findPoisonedDuration(int* timeSeries, int timeSeriesSize, int duration){
        int sum=0;
        for(int i=1;i<timeSeriesSize;i++)
        {
            if(timeSeries[i]-timeSeries[i-1]>duration)
            sum+=duration;
            else
            sum+=timeSeries[i]-timeSeries[i-1];
        }
        sum+=duration;
        return sum;
}

414 第三大的数

在这里插入图片描述

1.设置一个数组max[3],用来存放数组中前三大的数。这里注意C语言数组赋值
/// int max[3]={333} max[0]=333,max[1]=0,max[2]=0;
/// 该方法仅可将数组元素初始化为0，若初始化为其他数字，仅有首元素可被初始化为该数字，其余元素自动初始化为0。
2.遍历数组，并且比较值，根据不同的大小依次修改数组max
3.最后返回max[3]，若不存在则返回max[0]

int thirdMax(int* nums, int numsSize){
    long int max[3]={-1e10,-1e10,-1e10};
    for(int i=0;i<numsSize;i++)
    {
        printf("%d %d %d\n",max[0],max[1],max[2]);
        if(nums[i]>max[0])
        {
            max[2]=max[1];
            max[1]=max[0];
            max[0]=nums[i];
        }
        else if(nums[i]<max[0]&&nums[i]>max[1])
        {
            max[2]=max[1];
            max[1]=nums[i];
        }
        else if(nums[i]<max[1]&&nums[i]>max[2])
        {
            max[2]=nums[i];
        }
    }
    if(max[2]!=-1e10)
        return max[2];
    return max[0];
}

628 三个数的最大乘积

在这里插入图片描述

冒泡排序会超时，无语。
1.三个数的最大乘积有两种情况（1）三个最大的数相乘（2）最大的数和最小的两个数相乘
方法1：先对数组进行排序，选出这五个数
方法2：借鉴【414】，找到相应的数字

//方法一
int maximumProduct(int* nums, int numsSize){
    long int max[3]={-1e10,-1e10,-1e10};
    long int min[2]={1e10,1e10};
    for(int i=0;i<numsSize;i++)
    {
        if(nums[i]>max[0])
        {
            max[2]=max[1];
            max[1]=max[0];
            max[0]=nums[i];
        }
        else if(nums[i]<=max[0]&&nums[i]>max[1])
        {
            max[2]=max[1];
            max[1]=nums[i];
        }
        else if(nums[i]<=max[1]&&nums[i]>max[2])
        {
            max[2]=nums[i];
        }
        if(nums[i]<min[1])
        {
            min[0]=min[1];
            min[1]=nums[i];
        }else if(nums[i]>=min[1]&&nums[i]<min[0])
        {
            min[0]=nums[i];
        }
    }
    int max1,max2;
    max1=max[0]*max[1]*max[2];
    max2=max[0]*min[0]*min[1];
    if(max1>max2)
    return max1;
    else
    return max2;
}

//方法二
int cmp(const void *a,const void *b)
{
    return (*(int*)a-*(int*)b);
}

int maximumProduct(int* nums, int numsSize){
    qsort(nums,numsSize,sizeof(int),cmp);
    int max1=nums[0]*nums[1]*nums[numsSize-1];
    int max2=nums[numsSize-3]*nums[numsSize-2]*nums[numsSize-1];
    if(max1>max2)
    return max1;
    else
    return max2;
}

C语言函数qsort()

	功能： 使用**快速排序**例程进行排序
	头文件：stdlib.h
　　用法：  void qsort(void* base,size_t num,size_t width,int(__cdecl*compare)(const void*,const void*)); 
　　参数： 1 待排序数组，排序之后的结果仍放在这个数组中
　　　　　 2 数组中待排序元素数量
　　　　　 3 各元素的占用空间大小（单位为字节）
　　　　　 4 指向函数的指针，用于确定排序的顺序（需要用户自定义一个比较函数）

#include <stdio.h>
#include <stdlib.h>

int values[] = { 88, 56, 100, 2, 25 };

int cmpfunc (const void * a, const void * b)
{
   return ( *(int*)a - *(int*)b );
}
int main()
{
   int n;
   printf("排序之前的列表：\n");
   for( n = 0 ; n < 5; n++ ) {
      printf("%d ", values[n]);
   }
   printf("\n");
   qsort(values, 5, sizeof(int), cmpfunc);

   printf("\n排序之后的列表：\n");
   for( n = 0 ; n < 5; n++ ) {
      printf("%d ", values[n]);
   }
  return(0);
}

645 错误的集合

在这里插入图片描述

通过使用哈希表来和每个元素相对应。
1.初始化哈希表，值都设为false
2.遍历数组，出现则将对应的位置改为true，如果已经为true，则它就是重复的数字。
3.遍历哈希表，如果当年对应的值为false，则它就是丢失的整数。

int* findErrorNums(int* nums, int numsSize, int* returnSize){
    bool hash[numsSize+1];
    static int result[2];
    *returnSize=2;
    for(int i=0;i<numsSize+1;i++)
    {
        hash[i]=false;
    }
    for(int i=0;i<numsSize;i++)
    {
        int m=nums[i];
        if(hash[m]==false)
        hash[m]=true;
        else if(hash[m]==true)
        result[0]=nums[i];
    }
    for(int i=1;i<numsSize+1;i++)
    {
        if(hash[i]==false)
        {
            result[1]=i;
            break;
        }
    }
    return result;
}

697 数组的度

在这里插入图片描述

(感觉有点麻烦）
思路：找数组中的众数，并且众数不止一个
1.创建一个数组result，用于存储每个数的频度
2.遍历result数组找到频度最大的数（众数的频度）
3.遍历原数组（nums）包含众数的最小长度，如果众数不是一个，则需要对最小长度进行比较

int findShortestSubArray(int* nums, int numsSize){
        int result[100000]={0};
        for(int i=0;i<numsSize;i++)
            result[nums[i]]++;
        int fre=0;
        for(int i=0;i<100000;i++)
        {
            if(result[i]>fre)
                fre=result[i]; //找到找众数的频度
        }
        int com=100000,start,end,num;
        for(int i=0;i<100000;i++)
        {
            start=0,end=0,num=0;
            if(result[i]==fre)
                {
                num=i;
                for(int i=0;i<numsSize;i++)
                    {
                        if(nums[i]==num)
                            { 
                                start=i;
                                break;
                            }
                    }
                for(int i=numsSize-1;i>0;i--)
                    {
                        if(nums[i]==num)
                            {
                                end=i;
                                 break;
                            }
                    }
                if(end-start+1<com)
                    com=end-start+1;
                }
    }
        return com;
}

448找到所有数组中消失的数字

在这里插入图片描述

方法一：采用哈希表
1.建立长度为numsSize+1的哈希表并将初值设为false。
2.遍历数组，将hash[nums[i]设为ture。
3.再次遍历哈希表，将值为false的下标存入result数组，并记录数组长度。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* findDisappearedNumbers(int* nums, int numsSize, int* returnSize){
    bool hash[numsSize+1];
    for(int i=0;i<numsSize+1;i++)
    hash[i]=false;
    for(int i=0;i<numsSize;i++)
    {
        if(nums[i]>=1&&nums[i]<=numsSize)
        hash[nums[i]]=true;
    }
    static int result[1000000]={0};
    int num=0;
    for(int i=1;i<numsSize+1;i++)
    {
        if(hash[i]==false)
        {
            result[num]=i;
            num++;
        }
    }
    *returnSize=num;
    return result;
}

方法二：
1.遍历数组，如果当前值在[1,n]，就把其对应下标的数改成负数。
2.再次遍历数组，如果当前的值为正数，则说明这个数没有在数组中出现，返回i+1（其中i为下标）

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* findDisappearedNumbers(int* nums, int numsSize, int* returnSize){
    int *array=(int *)malloc(sizeof(int)*numsSize);
    int num=0;
    for(int i=0;i<numsSize;i++)
    {
        //if(abs(nums[i])>=1&&abs(nums[i])<=numsSize)
        nums[abs(nums[i])-1]=-abs(nums[abs(nums[i])-1]);
    }
    for(int i=0;i<numsSize;i++)
    {
        if(nums[i]>0)
        {
            array[num++]=i+1;
        }
    }
    *returnSize=num;
    return array;
}

442 数组中重复的数据

在这里插入图片描述

方法一：设置哈希表，用于记录元素是否出现
1.遍历数组，将其对应的哈希表中的元素设置为true。
2.如果当前哈希表对应的值已经为true，则该整数出现两次，存入要返回的数组中。

int* findDuplicates(int* nums, int numsSize, int* returnSize){
    bool result[numsSize+1];
    for(int i=0;i<numsSize+1;i++)
    result[i]=false;
    int *array=(int *)malloc(sizeof(int)*numsSize);
    for(int i=0;i<numsSize;i++)
    array[i]=0;
    int w=0;
    for(int i=0;i<numsSize;i++)
    {
        if(result[nums[i]]==true)
        {
            array[w]=nums[i];
            w++;
        }else
        result[nums[i]]=true;
    }
    *returnSize=w;
    return array;
}

方法二：
1.建立数组array用于存储每个数的频度，数组result用于存储最后的结果并返回。
2.遍历数组nums，更新数组array。
3.遍历array，筛选频度为2的数字，存入result。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* findDuplicates(int* nums, int numsSize, int* returnSize){
    int *array=(int *)malloc(sizeof(int)*(numsSize+1));
    int *result=(int *)malloc(sizeof(int)*(numsSize));
    int num=0;
    for(int i=0;i<numsSize+1;i++)
     array[i]=0;
    for(int i=0;i<numsSize;i++)
    {
        array[nums[i]]++;
    }
    for(int i=0;i<numsSize+1;i++)
    {
        printf("%d ",array[i]);
    }
    for(int i=0;i<numsSize+1;i++)
    {
        if(array[i]==2)
        result[num++]=i;
    }
    *returnSize=num;
    return result;
}

41 缺失的第一个正数

在这里插入图片描述

1.首先处理小于或等于0的数，将他们变为numsSize+1
2.遍历数组，将每个元素对应的下标减一，再找到对应的元素之后将其变为负数。
3.遍历数组，如果当前元素大于0，则下标+1就是缺失的正数，否则就是numsSize+1。

int firstMissingPositive(int* nums, int numsSize){
    for(int i=0;i<numsSize;i++)
    {
        if(nums[i]<=0)
        nums[i]=numsSize+1;
    }
    for(int i=0;i<numsSize;i++)
    {   
        if(abs(nums[i])<=numsSize
        nums[abs(nums[i])-1]=-abs(nums[abs(nums[i])-1]);
    }
    for(int i=0;i<numsSize;i++)
    {
        if(nums[i]>0)
        return i+1;
    }
    return numsSize+1;
}

// 3 4 -1 1
// 3 4 5 1
// 3 4 -5 1
// 3 4 -5 -1
// -3 4 -5 -1
所以缺失的第一个正数是2

有点冰冰
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LeetCode刷题笔记.rar
07-05
《LeetCode刷题笔记》是针对LeetCode这个在线编程挑战平台的个人学习心得与总结，主要涵盖数据结构和算法两大核心领域。LeetCode是一个全球知名的编程训练网站，它提供了丰富的编程题目，帮助开发者提升编程技能，...
leetcode-堆
雪雪
04-08 302
659.输入一个按升序排序的整数数组（可能包含重复数字），你需要将它们分割成几个子序列，其中每个子序列至少包含三个连续整数。返回你是否能做出这样的分割？ 示例 1： 输入: [1,2,3,3,4,5] 输出: True 解释: 你可以分割出这样两个连续子序列 : 1, 2, 3 3, 4, 5 解题思路： 贪婪解法：第一个map用来建立数字和其出现次数之间的映射fre，第二个用来建立可...
leetcode刷题一 （数组匹配）
weixin_43598042的博客
06-15 171
leetcode刷题1：在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列从从上到下递增排序。匹配某个数字
哈希表（散列表）原理详解
热门推荐
那年聪聪
06-03 28万+
哈希表（散列表）原理详解
LeetCode 刷题笔记 with Java.zip
11-23
《LeetCode刷题笔记withJava》是一份专为Java开发者准备的算法实战指南，涵盖了LeetCode网站上前一百道编程挑战题目。这份资料旨在帮助程序员提升算法能力，掌握数据结构和问题解决技巧，对于准备面试或者想要提升...
谷歌高畅Leetcode刷题笔记.pdf
08-04
这本书名为《LeetCode101：和你一起你轻松刷题（C++）》的电子书，作者高畅ChangGao，旨在帮助有C++基础但缺乏刷题经验的读者。本文将详细阐述该电子书中提及的IT知识点，覆盖算法与数据结构两大板块，以及十五个...
leetcode刷题笔记之JavaScript
11-08
leetcode刷题笔记之JavaScript LeetCode刷题笔记之JavaScript知识分享 在本篇文章中，我们将讨论LeetCode中的二叉树、数组、链表、哈希表、栈、队列、图等数据结构和算法题目，并提供相应的JavaScript解决方案。 ...
Leetcode刷题笔记-堆
08-19
### Leetcode刷题笔记——堆相关题型解析 在算法学习和面试准备的过程中，Leetcode是一个不可或缺的资源库。本文将深入探讨堆相关的基础知识及其在Leetcode中的具体应用，特别是针对“Top K”问题的经典解决方案。 ...
LeetCode128.最长连续序列
方温热的博客
08-17 208
给定一个未排序的整数数组nums，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。
一起学习LeetCode热题100道（48/100）
weixin_53224223的博客
08-20 302
7.注意：虽然代码中包含了回溯部分（即减少当前路径和的计数并从prefixSums中删除它），但在本问题中，由于树是无环的，并且我们不需要精确跟踪每条路径，因此这部分是多余的。输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22。输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8。1.这是主函数，接收根节点和目标和作为参数，并返回满足条件的路径数量。
力扣面试经典算法150题：删除有序数组中的重复项 II
weixin_48668564的博客
08-16 734
力扣面试经典算法150题：删除有序数组中的重复项 II
Leetcode 219. 存在重复元素 II
铁马冰河入梦来
08-20 191
哈希表解决存在重复元素二问题
Leetcode-day26-贪心算法
m0_61890209的博客
08-18 202
找到每个阶段的局部最优，最后找到全局最优。举个例子：十堆钞票，每堆里面取一张，找最大金额。贪心先从每堆里面找出金额最大的，进而推出总体的最大金额。思路：贪心：先对两个数组排序，大尺寸的饼干尽可能去满足大胃口的小孩。需要注意的是这里内层可以用index,就避免了双层for循环这个题可以把数组中的节点按山坡画出来，按照题意，首先把数组中元素等于1，2的情况写出来，然后分析，可以把数组中的元素按照坡度画出来，如下图，其实就是找的山峰元素和最左和最右元素（元素个数大于3）。
回溯算法——LeetCode491 递增子序列
Beilin_LeBron的博客
08-15 178
力扣题目链接491.递增子序列注意这里不能使用先排序在用used判断去重！
二分查找5️⃣-山脉数组的封顶索引
2202_75331338的博客
08-15 330
对于山峰来说，我们会发现封顶的值是最大，对于封顶左边来说，后一个数比前一个数大；◦ 如果 mid 位置呈现上升趋势，说明我们接下来要在 [mid + 1, right] 区间继续搜索；◦ 如果 mid 位置呈现下降趋势，说明我们接下来要在 [left, mid - 1] 区间搜索；◦ 因此，我们可以遍历数组内的每一个元素，找到某一个元素比两边的元素大即可。本题的数组不是有序数组，但我们依然可以使用二分查找，原因是因为我们发现了。输入：arr = [0,2,1,0]◦ 峰顶的特点：比两侧的元素都要大。
Leetcode JAVA刷刷站（31）下一个排列
m0_73399576的博客
08-15 554
Leetcode JAVA刷刷站——下一个排列篇
leetcode_62. 不同路径 + 63. 不同路径 II
最新发布
m0_62593050的博客
08-20 850
m x n网格的左上角到达右下角，每次只能向下或者向右移动一步。问总共有多少条不同的路径
【leetcode】合并 K 个升序链表-25-6
qq_43552933的博客
08-16 254
方法：结构体排序+优先队列。
日拱一卒（2）——leetcode学习记录：平衡二叉树（二）
m0_72708335的博客
08-15 279
b. 左右子节点都存在，返回 max(1+递归（左子节点），1+递归（右子节点））3. 左右子节点深度差小于等于1，返回 递归 左子节点判断and右子节点判断。a. 左右子节点存在一个，返回 1+递归（存在的子节点）d.大前提，如果主节点为None，返回 0。c. 左右子节点都不存在，返回1。2. 左右子节点深度差大于1，返回 False。给定一个二叉树，判断它是否是 平衡二叉树。编程小白，所以结果比较差，见笑。1. 递归计算二叉树的深度。一、任务：平衡二叉树。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值