数组-接口5-使用实例1(两数之和)

清疚 2023-10-03 00:01 7阅读 0赞

## 题目和示例 ##

![6c62f57f193e4cb1ac447e4aff1f7141.png][]

## 解题思路： ##

其实没感觉什么哈希表，就是暴力破解法，不过暴力破解经过了一点点改进。

就是先算出target-nums\[i\]，再去和数组里的元素nums\[j\]比。

而不是一个个计算nums\[i\]+\[j\]再判断是不是和等于target。

假设一共有n个元素，显然\*\*后者\*\*的计算加法的次数最多为(n-1)+(n-2)+(n-3)+...+3+2+1=n(n-1)/2次;

而\*\*前者\*\*只需要计算减法最多n-1次;这样优劣就很显然了；

## 解题C代码： ##

int* twoSum(int* nums, int numsSize, int target, int* returnSize)
    {
        int* r = (int*)malloc(sizeof(int) * 2);
        *returnSize = 2;
        int t = 0, i = 0, j = 0;
        for (; i < numsSize; i++)
        {
            t = target - nums[i];
            for (j = i + 1; j < numsSize; j++)
                if (nums[j] == t)
                {
                    r[0] = i;
                    r[1] = j;
                    return r;
                }
        }
        return 0;
    }

## 测试C代码（末尾有不同颜色字体标出的重点）： ##

#include	<stdio.h>
    #include	<stdlib.h>
    
    // 待添加的接口
    // 两数之和
    /*
    其实没感觉什么哈希表，就是暴力破解法，不过暴力破解经过了一点点改进。
    就是先算出target-nums[i]，再去和数组里的元素nums[j]比。
    而不是一个个计算nums[i]+[j]再判断是不是和等于target。
    假设一共有n个元素，显然**后者**的计算加法的次数最多为(n-1)+(n-2)+(n-3)+...+3+2+1=n(n-1)/2次;
    而**前者**只需要计算减法最多n-1次;这样优劣就很显然了；
    */
    int* twoSum(int* nums, int numsSize, int target, int* returnSize)
    {
        int* r = (int*)malloc(sizeof(int) * 2);
        *returnSize = 2;
        int t = 0, i = 0, j = 0;
        for (; i < numsSize; i++)
        {
            t = target - nums[i];
            for (j = i + 1; j < numsSize; j++)
                if (nums[j] == t)
                {
                    r[0] = i;
                    r[1] = j;
                    return r;
                }
        }
        return 0;
    }
    
    
    int main(void)
    {
        // ------------测试用例数据,需要根据实际测试用例进行内容替换{-------
        // ---- 适用接口:参数为一个整型数组和数组长度的整数，再加一个整数；预期结果是一个整型数组 ---------------
        // 第一维度：用例个数
        int nums[][100] = { { 2,7,11,15 } ,{ 3,2,4 }, { 3,3}};
        // 元素个数 = 用例个数;数组内容是nums[]中每个数组的实际长度
        int numsSize[] = { 4, 3, 2};
        // 第二个参数：元素个数 = 用例个数
        int kNum[] = { 9, 6, 6 };
        // 每个用例的预期结果
        // 预期结果：第一维度，用例个数
        int res[][100] = { { 0,1 } ,{ 1,2 }, { 0,1 }};
        int resSize[] = { 2,2,2 };
        // -----------------------}测试用例数据结束-------------------------
    
        int flag_res = 0;   // 统计测试用例通过与否的个数
        int temp = 0;   // 暂存每次调用接口处理后的结果
    
        for (int i = 0; i < sizeof(numsSize) / sizeof(int); i++) {   // 循环测试
    
            int* fp;
            int returnSize;
            int resTemp[100];   // 暂存每次调用接口处理后的结果
            fp = resTemp;
    
            // 需要根据实际给出的接口进行接口替换
            fp = twoSum(nums[i], numsSize[i], kNum[i], &returnSize);  // 调用测试用例，返回实际计算结果。
    
            temp = 0;
            for (int j = 0; j < returnSize; j++)
            {
                if (fp[j] != res[i][j])
                {
                    temp = 1;
                    break;
                }
            }
            // 检查单个用例实际结果是否符合预期，不符合预期则将结果输出
            if (temp < 1)
            {
                flag_res++; // 实际结果与预期一致时增加统计数
            }
            else
            {
                flag_res--;
                printf("\n第 %d 个（序号从0开始）测试用例实际结果与预期不一致！\n", i);
                printf("实际结果是：\n");
                for (int j = 0; j < returnSize; j++)
                {
                    printf("%d\t", fp[j]);
                }
                printf("\n预期结果是：\n");
                for (int j = 0; j < resSize[i]; j++)
                {
                    printf("%d\t", res[i][j]);
                }
            }
        }
    
        // 检查总用例实际结果是否都符合预期，输出结论
        if (flag_res < (int)(sizeof(resSize) / sizeof(int)))
        {
            printf("\n测试用例部分通过！\n");
        }
        else
        {
            printf("\n测试用例全部通过！\n");
        }
    
        return 0;
    }

## 不同颜色字体标出的重点 ##

*\#include <stdio.h>*

*\#include <stdlib.h>*

*//* *待添加的接口*

*//* *两数之和*

*/\**

*其实没感觉什么哈希表，就是暴力破解法，不过暴力破解经过了一点点改进。*

*就是先算出target-nums\[i\]，再去和数组里的元素nums\[j\]比。*

*而不是一个个计算nums\[i\]+\[j\]再判断是不是和等于target。*

*假设一共有n个元素，显然\*\*后者\*\*的计算加法的次数最多为(n-1)+(n-2)+(n-3)+...+3+2+1=n(n-1)/2次;*

*而\*\*前者\*\*只需要计算减法最多n-1次;这样优劣就很显然了；*

*\*/*

*int\* twoSum(int\* nums, int numsSize, int target, int\* returnSize)*

*\{*

*int\* r = (int\*)malloc(sizeof(int) \* 2);*

*\*returnSize = 2;*

*int t = 0, i = 0, j = 0;*

*for (; i < numsSize; i++)*

*\{*

*t = target - nums\[i\];*

*for (j = i + 1; j < numsSize; j++)*

*if (nums\[j\] == t)*

*\{*

*r\[0\] = i;*

*r\[1\] = j;*

*return r;*

*\}*

*return 0;*

*\}*

*int main(void)*

*\{*

*// ------------**测试用例数据,**需要根据实际测试用例进行内容替换**\{-------*

*// ----* *适用接口:参数为一个整型数组和数组长度的整数，再加一个整数；预期结果是一个整型数组 ---------------*

*//* *第一维度：用例个数*

*int nums\[\]\[100\] = \{ \{ 2,7,11,15 \} ,\{ 3,2,4 \}, \{ 3,3\}\};*

*//* *元素个数 = 用例个数;数组内容是nums\[\]中每个数组的实际长度*

*int numsSize\[\] = \{ 4, 3, 2\};*

*//* *第二个参数：元素个数 = 用例个数*

*int kNum\[\] = \{ 9, 6, 6 \};*

*//* *每个用例的预期结果*

*//* *预期结果：第一维度，用例个数*

*int res\[\]\[100\] = \{ \{ 0,1 \} ,\{ 1,2 \}, \{ 0,1 \}\};*

*int resSize\[\] = \{ 2,2,2 \};*

*// -----------------------\}**测试用例数据结束-------------------------*

*int flag\_res = 0; //* *统计测试用例通过与否的个数*

*int temp = 0; //* *暂存每次调用接口处理后的结果*

*for (int i = 0; i < sizeof(numsSize) / sizeof(int); i++) \{ //* *循环测试*

*int\* fp;*

*int returnSize;*

*int resTemp\[100\]; //* *暂存每次调用接口处理后的结果*

*fp = resTemp;*

*//* *需要根据实际给出的接口进行接口替换*

*fp = twoSum(nums\[i\], numsSize\[i\], kNum\[i\], &returnSize); //* *调用测试用例，返回实际计算结果。*

*temp = 0;*

*for (int j = 0; j < returnSize; j++)*

*\{*

*if (fp\[j\] != res\[i\]\[j\])*

*\{*

*temp = 1;*

*break;*

*\}*

*//* *检查单个用例实际结果是否符合预期，不符合预期则将结果输出*

*if (temp < 1)*

*\{*

*flag\_res++; //* *实际结果与预期一致时增加统计数*

*\}*

*else*

*\{*

*flag\_res--;*

*printf("\\n**第 %d 个（序号从0开始）测试用例实际结果与预期不一致！\\n", i);*

*printf("**实际结果是：\\n");*

*for (int j = 0; j < returnSize; j++)*

*\{*

*printf("%d\\t", fp\[j\]);*

*\}*

*printf("\\n**预期结果是：\\n");*

*for (int j = 0; j < resSize\[i\]; j++)*

*\{*

*printf("%d\\t", res\[i\]\[j\]);*

*\}*

*//* *检查总用例实际结果是否都符合预期，输出结论*

*if (flag\_res < (int)(sizeof(resSize) / sizeof(int)))*

*\{*

*printf("\\n**测试用例部分通过！\\n");*

*\}*

*else*

*\{*

*printf("\\n**测试用例全部通过！\\n");*

*\}*

*return 0;*

*\}*

[6c62f57f193e4cb1ac447e4aff1f7141.png]: https://img-blog.csdnimg.cn/6c62f57f193e4cb1ac447e4aff1f7141.png

数组-接口5-使用实例1(两数之和)

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关数组-接口5-使用实例1(两数之和)

相关 1.两数之和

相关 1. 两数之和

相关【数组】两数之和

相关 1. 两数之和

相关 1. 两数之和

相关【数组】---1. 两数之和

相关 1. 两数之和

相关 1.两数之和

相关 1.两数之和