力扣 (C语言)题库第66题加一

博客围绕LeetCode上数组加一问题展开,给定非空整数数组表示非负整数,要在该数基础上加一。介绍了三种情况的解题思路,包括数组最后一位不为9、元素全为9、元素不全为9的情况,使用C语言实现,还提醒确定数组长度时的注意事项。

给定一个由 整数 组成的 非空 数组所表示的非负整数,在该数的基础上加一。

最高位数字存放在数组的首位, 数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外,这个整数不会以零开头。

示例 1:

输入:digits = [1,2,3]
输出:[1,2,4]
解释:输入数组表示数字 123。

示例 2:

输入:digits = [4,3,2,1]
输出:[4,3,2,2]
解释:输入数组表示数字 4321。

示例 3:

输入:digits = [0]
输出:[1]

来源:力扣(LeetCode)
链接:https://leetcode.cn/problems/plus-one
解题思路:可以为情况讨论

1)当数组元素最后一个不为9时,让最后一位加一,直接将原数组放到新定义的数组中,再返回出来   

2)当数组里面的元素全为9时,让数组长度加一,让新数组的第一位为1,其余全为0

3)当数组里面元素不全为9时,---->见代码部分

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* plusOne(int* digits, int digitsSize, int* returnSize){
    int *a=(int *)malloc(sizeof(int)*(digitsSize+1));
    int i,cnt=0;
    
    if(digits[digitsSize-1]!=9){ //当最后一位数不为9时
        *returnSize=digitsSize;    
        a[digitsSize-1]=digits[digitsSize-1]+1;//直接让最后一位加一
        for(i=0;i<digitsSize-1;i++){
            a[i]=digits[i];//其他直接等过去
        }      
        return a;
    }
    else{
        for(i=0;i<digitsSize;i++){
            if(digits[i]==9){//判断数组里面有多少个9
                cnt++;
            }
        }
        if(digitsSize==cnt){//如果数组长度等于cnt,代表数组里的数全为9
            *returnSize=digitsSize+1;
             a[0]=1;//第一位置为一
            for(i=1;i<(digitsSize+1);i++){
                a[i]=0;//其余位置全为0
            } 
            return a;
        }else{//当9的个数小于digitsSize时
            int t;
            digits[digitsSize-1]+=1;//让最后一位数加1
            t=digits[digitsSize-1];//让t等于数组的后一位数
            a[digitsSize-1]=t%10;// 新数组a的最后一位对t取余         
            for(i=digitsSize-2;i>=0;i--){
                a[i]=(digits[i]+t/10)%10;//新数组a让原数组(digits)加上后一位数除以10,防止a[i]大于10需要取余
                t=digits[i]+t/10;//t为a[i]取余前的数
            }
            *returnSize=digitsSize;
            return a;
        }     
    }
    return a;
}

注意:每次确定好数组长度要用*returnSize等于该长度

### 问题解力扣LeetCode)是个面向编程面试准备的在线评测平台,提供了大量算法与数据结构相关的目,非常适合使用 C 语言进行编程练习。对于 C 语言开发者来说,LeetCode目可以很好地锻炼对指针、数组、字符串、链表、树、图等核心概念的理解和应用。 以下是些常见的 C 语言题解思路与技巧: --- ### 1. 使用双指针技巧 双指针是种常见的优化方法,用于处理数组或链表中的问。例如,求两数之和、删除重复元素等。 **示例:删除排序数组中的重复项** ```c int removeDuplicates(int* nums, int numsSize) { if (numsSize == 0) return 0; int i = 0; for (int j = 1; j < numsSize; j++) { if (nums[j] != nums[i]) { i++; nums[i] = nums[j]; } } return i + 1; } ``` --- ### 2. 排序与查找 排序是 C 语言中常用的操作,可以使用标准库中的 `qsort` 函数进行排序。结合排序和双指针可以解决如“两个数组的交集”等问。 **示例:两个数组的交集** ```c int cmp(const void* a, const void* b) { return *(int*)a - *(int*)b; } int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) { qsort(nums1, nums1Size, sizeof(int), cmp); qsort(nums2, nums2Size, sizeof(int), cmp); *returnSize = 0; int index1 = 0, index2 = 0; int* result = malloc(sizeof(int) * (nums1Size + nums2Size)); while (index1 < nums1Size && index2 < nums2Size) { int num1 = nums1[index1], num2 = nums2[index2]; if (num1 == num2) { if (*returnSize == 0 || num1 != result[*returnSize - 1]) { result[(*returnSize)++] = num1; } index1++; index2++; } else if (num1 < num2) { index1++; } else { index2++; } } return result; } ``` --- ### 3. 栈与队列的实现 栈和队列是常见的数据结构,在 C 语言中可以通过数组或链表模拟实现。例如,使用两个队列实现栈,或者使用两个栈实现队列。 **示例:用两个栈实现队列** ```c typedef struct { int* stack1; int top1; int* stack2; int top2; int capacity; } MyQueue; MyQueue* myQueueCreate(int capacity) { MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue)); obj->capacity = capacity; obj->stack1 = (int*)malloc(capacity * sizeof(int)); obj->stack2 = (int*)malloc(capacity * sizeof(int)); obj->top1 = -1; obj->top2 = -1; return obj; } void myQueuePush(MyQueue* obj, int x) { obj->stack1[++(obj->top1)] = x; } int myQueuePop(MyQueue* obj) { if (obj->top2 == -1) { while (obj->top1 != -1) { obj->stack2[++(obj->top2)] = obj->stack1[(obj->top1)--]; } } return obj->stack2[(obj->top2)--]; } int myQueuePeek(MyQueue* obj) { if (obj->top2 == -1) { while (obj->top1 != -1) { obj->stack2[++(obj->top2)] = obj->stack1[(obj->top1)--]; } } return obj->stack2[obj->top2]; } bool myQueueEmpty(MyQueue* obj) { return obj->top1 == -1 && obj->top2 == -1; } void myQueueFree(MyQueue* obj) { free(obj->stack1); free(obj->stack2); free(obj); } ``` --- ### 4. 递归与回溯 递归和回溯是解决组合、排列、子集等问的强大工具。例如,LeetCode 第 491 “非递减子序列”可以通过深度优先搜索(DFS)解决。 **示例:非递减子序列** ```c int** ans; int ansSize; int* temp; int tempSize; void dfs(int cur, int last, int* nums, int numsSize, int** returnColumnSizes) { if (cur == numsSize) { if (tempSize >= 2) { ans[ansSize] = malloc(sizeof(int) * tempSize); memcpy(ans[ansSize], temp, sizeof(int) * tempSize); (*returnColumnSizes)[ansSize++] = tempSize; } return; } if (nums[cur] >= last) { temp[tempSize++] = nums[cur]; dfs(cur + 1, nums[cur], nums, numsSize, returnColumnSizes); tempSize--; } if (nums[cur] != last) { dfs(cur + 1, last, nums, numsSize, returnColumnSizes); } } int** findSubsequences(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) { ans = malloc(sizeof(int*) * 32768); *returnColumnSizes = malloc(sizeof(int*) * 32768); temp = malloc(sizeof(int) * numsSize); ansSize = tempSize = 0; dfs(0, INT_MIN, nums, numsSize, returnColumnSizes); *returnSize = ansSize; return ans; } ``` --- ### 5. 循环队列的设计 循环队列是种特殊的队列结构,可以有效利用数组空间。 **示例:设计循环队列** ```c typedef struct { int* data; int head; int tail; int size; } MyCircularQueue; MyCircularQueue* myCircularQueueCreate(int k) { MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue)); obj->data = (int*)malloc(k * sizeof(int)); obj->head = 0; obj->tail = 0; obj->size = k; return obj; } bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) { if ((obj->tail + 1) % obj->size == obj->head) return false; obj->data[obj->tail] = value; obj->tail = (obj->tail + 1) % obj->size; return true; } bool myCircularQueueDeQueue(MyCircularQueue* obj) { if (obj->head == obj->tail) return false; obj->head = (obj->head + 1) % obj->size; return true; } int myCircularQueueFront(MyCircularQueue* obj) { if (obj->head == obj->tail) return -1; return obj->data[obj->head]; } int myCircularQueueRear(MyCircularQueue* obj) { if (obj->head == obj->tail) return -1; return obj->data[(obj->tail + obj->size - 1) % obj->size]; } bool myCircularQueueIsEmpty(MyCircularQueue* obj) { return obj->head == obj->tail; } bool myCircularQueueIsFull(MyCircularQueue* obj) { return (obj->tail + 1) % obj->size == obj->head; } void myCircularQueueFree(MyCircularQueue* obj) { free(obj->data); free(obj); } ``` --- ### 6. 动态内存管理 LeetCode 的 C 语言解法通常涉及动态内存分配(如 `malloc` 和 `free`)。需要注意内存泄漏和越界访问问。 --- ### 7. 调试技巧 - 使用 `printf` 输出中间变量。 - 利用调试器(如 GDB)逐步执行。 - 对边界条件进行特殊处理。 --- ### 总结 C 语言LeetCode 上的应用广泛,尤其适合练习底层数据结构与算法。掌握指针操作、内存管理、递归与回溯等技能,是解决 LeetCode的关键。此外,熟悉标准库函数(如 `qsort`、`memcpy`)也能提高代码效率。 ---
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值