力扣--数组 入门三题-485/283/27---刷题笔记+思路分析+C语言

1.485. 最大连续 1 的个数

int findMaxConsecutiveOnes(int* nums, int numsSize) {
    //设置两个数字来记录哪个更大
    int countNum=0;
    int maxNum=0;
     if (nums == NULL || numsSize <= 0) {
        return 0;
    }
    for(int i=0;i<numsSize;i++){
        //如果为1 则加一
        if(nums[i]==1){
             countNum++; 
            //如果大于了最大的则赋值为最大的。
            if(countNum>maxNum){
            maxNum=countNum;
        }  
        }
      //如果等于0 停止赋值
      else if(nums[i]==0){
            countNum=0;
      }
    }
    return maxNum;
}

2.287. 寻找重复数

给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n），可知至少存在一个重复的整数。

假设 nums 只有 一个重复的整数 ，返回 这个重复的数 。

#include <stdio.h>

/**
 * Note: 不修改数组 nums，额外空间复杂度 O(1)
 */
int findDuplicate(int* nums, int numsSize) {
    // 1. 入参合法性校验（鲁棒性补充，题目保证有解）
    if (nums == NULL || numsSize <= 1) {
        return -1; // 返回 -1 标识非法输入
    }
    
    // 2. 步骤1：快慢指针找环内相遇点
    int slow = nums[0];   // 慢指针初始走1步
    int fast = nums[nums[0]]; // 快指针初始走2步
    
    while (slow != fast) {
        slow = nums[slow];        // 慢指针每次走1步
        fast = nums[nums[fast]];  // 快指针每次走2步
    }
    
    // 3. 步骤2：重置慢指针，找环的入口（重复数）
    slow = 0; // 慢指针重置为数组起始位置
    while (slow != fast) {
        slow = nums[slow];  // 快慢指针均每次走1步
        fast = nums[fast];
    }
    
    // 4. 返回环的入口，即唯一重复数
    return slow;
}

// 辅助测试代码
int main() {
    // 测试用例 1：[1,3,4,2,2]（重复数：2）
    int nums1[] = {1, 3, 4, 2, 2};
    int numsSize1 = sizeof(nums1) / sizeof(nums1[0]);
    printf("测试用例 1 重复数：%d（预期：2）\n", findDuplicate(nums1, numsSize1));
    
    // 测试用例 2：[3,1,3,4,2]（重复数：3）
    int nums2[] = {3, 1, 3, 4, 2};
    int numsSize2 = sizeof(nums2) / sizeof(nums2[0]);
    printf("测试用例 2 重复数：%d（预期：3）\n", findDuplicate(nums2, numsSize2));
    
    // 测试用例 3：[2,2,2,2,2]（重复数：2）
    int nums3[] = {2, 2, 2, 2, 2};
    int numsSize3 = sizeof(nums3) / sizeof(nums3[0]);
    printf("测试用例 3 重复数：%d（预期：2）\n", findDuplicate(nums3, numsSize3));
    
    return 0;
}

思路二

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

int findDuplicate(int* nums, int numsSize) {
    if (nums == NULL || numsSize <= 1) {
        return -1;
    }
    
    // 步骤1：找到nums中的最大值，确定计数数组的大小（避免内存浪费）
    int max_num = nums[0];
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] > max_num) {
            max_num = nums[i];
        }
    }
    
    // 步骤2：动态分配计数数组（堆内存，避免栈溢出），初始化为0
    int* flag = (int*)calloc(max_num + 1, sizeof(int));
    if (flag == NULL) {
        return -1; // 内存分配失败
    }
    
    // 步骤3：统计每个数字出现的次数
    for (int i = 0; i < numsSize; i++) {
        flag[nums[i]]++;
    }
    
    // 步骤4：寻找重复数
    int duplicate = -1;
    for (int i = 0; i < numsSize; i++) {
        if (flag[nums[i]] != 1) {
            duplicate = nums[i];
            break;
        }
    }
    
    // 步骤5：释放动态内存，避免内存泄漏
    free(flag);
    flag = NULL;
    
    return duplicate;
}