用c写力扣两数之和代码

以下是用 C 语言写的力扣两数之和代码：

int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    int i, j;
    int* result = (int*)malloc(2 * sizeof(int)); // 用于存放结果的数组
    *returnSize = 2; // 返回数组的大小为 2
    for (i = 0; i < numsSize; i++) {
        for (j = i + 1; j < numsSize; j++) {
            if (nums[i] + nums[j] == target) {
                result[0] = i;
                result[1] = j;
                return result;
            }
        }
    }
    return NULL; // 如果没有找到符合条件的数，则返回 NULL
}

该代码使用了两重循环来遍历数组，找到两个数的和等于目标数的情况下，返回它们的下标。如果没有找到，则返回 NULL。

相关问题

力扣 两数相加 C语言 题解

题目描述：

给出两个非空链表来表示两个非负整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以零开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

解题思路：

题目中要求我们按照逆序的方式存储两个非负整数，也就是说链表的头节点表示该数的个位，第二个节点表示该数的十位，以此类推。

因此，我们可以从两个链表的头节点开始，对应位相加，并记录进位，将结果添加到新的链表中。如果有进位，需要在下一位相加时加上进位。

需要注意的是，当两个链表的长度不一致时，可以将较短的链表的缺失位看作是 0。

最后，如果最高位有进位，还需要在新链表的最高位添加一个值为 1 的节点。

C 语言代码实现：

/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/

struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){
struct ListNode *head = NULL, *tail = NULL;
int carry = 0;

while (l1 || l2) {
int n1 = l1 ? l1->val : 0;
int n2 = l2 ? l2->val : 0;
int sum = n1 + n2 + carry;

if (!head) {
head = tail = malloc(sizeof(struct ListNode));
tail->val = sum % 10;
tail->next = NULL;
} else {
tail->next = malloc(sizeof(struct ListNode));
tail = tail->next;
tail->val = sum % 10;
tail->next = NULL;
}

carry = sum / 10;
if (l1) l1 = l1->next;
if (l2) l2 = l2->next;
}

if (carry > 0) {
tail->next = malloc(sizeof(struct ListNode));
tail = tail->next;
tail->val = carry;
tail->next = NULL;
}

return head;
}

力扣 两数组的交集用C语言实现

请问您需要的是两个数组的交集元素还是交集元素的数量？

如果是交集元素，可以采用双指针的方式，先将两个数组排序，然后设定两个指针 i 和 j，分别指向两个数组的开头，比较两个指针所指向的元素的大小，如果相等，则说明找到了一个交集元素，将其存到结果数组中；如果不相等，则将指向小的元素的指针向后移动一位，直到其中一个指针越界为止。

代码实现如下：

int* intersect(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){
    int i = 0, j = 0, k = 0;
    int* res = (int*)malloc(sizeof(int) * (nums1Size > nums2Size ? nums2Size : nums1Size));
    // 排序
    qsort(nums1, nums1Size, sizeof(int), cmp);
    qsort(nums2, nums2Size, sizeof(int), cmp);
    while (i < nums1Size && j < nums2Size) {
        if (nums1[i] == nums2[j]) {
            res[k++] = nums1[i];
            i++;
            j++;
        } else if (nums1[i] < nums2[j]) {
            i++;
        } else {
            j++;
        }
    }
    *returnSize = k;
    return res;
}

int cmp(const void* a, const void* b) {
    return *(int*)a - *(int*)b;
}

如果是交集元素的数量，可以采用哈希表的方式，用一个哈希表来记录第一个数组中的元素出现的次数，然后遍历第二个数组，在哈希表中查找是否存在相同的元素，如果存在，则说明找到了一个交集元素，将其计数并从哈希表中删除该元素，最后返回计数结果即可。

代码实现如下：

int* intersect(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){
    int i = 0, j = 0, k = 0;
    int* res = (int*)malloc(sizeof(int) * (nums1Size > nums2Size ? nums2Size : nums1Size));
    int* hash = (int*)malloc(sizeof(int) * 1001); // 由于题目条件限制在 [0, 1000] 范围内，所以哈希表可以开得比较小
    memset(hash, 0, sizeof(hash));
    for (i = 0; i < nums1Size; i++) {
        hash[nums1[i]]++;
    }
    for (j = 0; j < nums2Size; j++) {
        if (hash[nums2[j]] > 0) {
            res[k++] = nums2[j];
            hash[nums2[j]]--;
        }
    }
    *returnSize = k;
    return res;
}

希望这些代码能够帮到您，如有疑问请随时问我~