《剑指Offer》和为定值的两个数

最新推荐文章于 2022-04-13 16:23:51 发布

HelloWorld_EE

最新推荐文章于 2022-04-13 16:23:51 发布

阅读量754

点赞数 1

分类专栏：剑指Offer 文章标签：和为定值的两个数剑指Offer 排序

本文链接：https://blog.csdn.net/u010412719/article/details/49208709

版权

剑指Offer 专栏收录该内容

58 篇文章 2 订阅

订阅专栏

题目描述：

输入一个递增排序的数组和一个数字S，在数组中查找两个数，是的他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

思路一

按顺序进行扫描，时间复杂度为O(n*n)

/*

输入：
每个测试案例包括两行：
第一行包含一个整数n和k，n表示数组中的元素个数，k表示两数之和。其中1 <= n <= 10^6，k为int
第二行包含n个整数，每个数组均为int类型。
输出：
对应每个测试案例，输出两个数，小的先输出。如果找不到，则输出“-1 -1”
样例输入：
6 15
1 2 4 7 11 15
样例输出：
4 1


*/
/*
思路：按顺序进行扫描，时间复杂度为O(n*n) 
*/

#include<stdio.h>
#include<stdlib.h>
bool findTwoNumInArrayEqualS(int *arr,int len,int S,int *first,int *second){
    if(arr==NULL||len<2){
        return false;
    }
    bool isExist=false;
    for(int i=0;i<len-1;i++){
        for(int j=i+1;j<len;j++){
            if(arr[i]+arr[j]==S){
                *first=arr[i];
                *second=arr[j];
                return true;
            }
        }
    }
    return isExist;

}
int main(void){
    int n,k;
    while(scanf("%d%d",&n,&k)!=EOF&&n>1&&n<1000000&&k>0){
        int *arr=(int *)malloc(n*sizeof(int));
        if(arr==NULL){
            exit(EXIT_FAILURE);
        }
        for(int i=0;i<n;i++){
            scanf("%d",arr+i);
        }
        int first,second;
        bool isExist=findTwoNumInArrayEqualS(arr,n,k,&first,&second);
        if(isExist){
            printf("%d   %d\n",first,second);
        }
        else{
            printf("-1  -1\n");
        }
    }

    return 0;
}

上面虽然能够完成此功能，但是时间复杂度为O(n*n),因此，应该寻找更好的方法使时间复杂度更小。

思路2

思路：从前到后开始遍历数组，对于每个数，然后用二分查找的方法来查找S-arr[i]是否在arr中，
此方法的时间复杂度为O(nlogn),相比第一种方法，有所改进



#include<stdio.h>
#include<stdlib.h>
/*
函数的功能：在数组中二分查找某数字是否存在。 
参数的说明
@param arr:数组的指针
@param len:数组的长度
@param data:要查找的数字 

*/ 
int  BSearch(int *arr,int len,int data){
    if(arr==NULL||len<1){
        return -1;
    }
    if(data>arr[len-1]||data<arr[0]){
        return -1;
    }
    int begin=0;
    int end=len-1;
    int mid;
    while(begin<=end){
        mid=begin+(end-begin)/2;
        if(arr[mid]==data){
            return mid;
        }
        else if(arr[mid]>data){
            end=mid-1;
        }
        else{
            begin=mid+1;
        }
    }
    return -1;

}
/*
函数的功能：在利用二分查找法在数字找到两个数字等于定值S
参数的说明：
@param arr:数组的指针
@param  len:数组的长度
@param  S：定值
@param  fisrt:用来保存找到的第一个数的指针
@param second：用来保存找到的第二个数的指针 
*/ 
bool findTwoNumInArrayEqualS(int *arr,int len,int S,int *first,int *second){
    if(arr==NULL||len<2){
        return false;
    }
    bool isExist=false;
    for(int i=0;i<len;i++){
        int index=BSearch(arr,len,S-arr[i]); 
        if(index!=-1){
            *first=arr[i];
            *second=arr[index];
            return true;
        }
    }
    return isExist;

}
int main(void){
    int n,k;
    while(scanf("%d%d",&n,&k)!=EOF&&n>1&&n<1000000&&k>0){
        int *arr=(int *)malloc(n*sizeof(int));
        if(arr==NULL){
            exit(EXIT_FAILURE);
        }
        for(int i=0;i<n;i++){
            scanf("%d",arr+i);
        }
        int first,second;
        bool isExist=findTwoNumInArrayEqualS(arr,n,k,&first,&second);
        if(isExist){
            printf("%d   %d\n",first,second);
        }
        else{
            printf("-1  -1\n");
        }
    }

    return 0;
}

思路3

我们假设数组为A，长度为len，给定的和为sum，
最好的方法是先用数组的第一个数A[low]和最后一个数A[high]相加，看是否等于sum，
如果等于sum，则找到了一组数，返回true，如果大于sum，则将较大的数向前移动一位，即high–，此时变成了第一个和倒数第二个数相加，
如果小于sum，则将较小的数向后移动一位，即low++，此时变成了第二个和最后一个数相加，依此类推，
如果low==high时还未找到和为sum的一组数，则返回false。该算法的时间复杂度为O（n），空间复杂度为O（1）。


#include<stdio.h>
#include<stdlib.h>
bool findTwoNumInArrayEqualS(int *arr,int len,int S,int *first,int *second){
    if(arr==NULL||len<2){
        return false;
    }
    bool isExist=false;
    int begin=0;
    int end=len-1;
    int sum;
    while(begin<end){
        sum=arr[begin]+arr[end];
        if(sum==S){
            *first=arr[begin];
            *second=arr[end];
            return true;
        }
        else if(sum>S){//此时说明：最大值不参与 
            end--;
        }
        else{
            begin++;
        }
    }
    return isExist;

}
int main(void){
    int n,k;
    while(scanf("%d%d",&n,&k)!=EOF&&n>1&&n<1000000&&k>0){
        int *arr=(int *)malloc(n*sizeof(int));
        if(arr==NULL){
            exit(EXIT_FAILURE);
        }
        for(int i=0;i<n;i++){
            scanf("%d",arr+i);
        }
        int first,second;
        bool isExist=findTwoNumInArrayEqualS(arr,n,k,&first,&second);
        if(isExist){
            printf("%d   %d\n",first,second);
        }
        else{
            printf("-1  -1\n");
        }
    }

    return 0;
}

以上提供了三种思路来完成。
我们现在来拓展一下，假设数组是乱序的，而且规定数组中的元素全部为非负整数，同样给定一个数sum，在数组中找出任意两个数，使二者的和为sum。

可能有的人会说，这个简单，直接将其排序，然后用前面的方法来做，这确实是可行的，但时间复杂度是O(nlogn),这时有没有某种方法可以降低时间复杂度嫩？？如下

思路

因为题目中限定了数组中的元素为非负整数，因此我们可以用哈希数组，开辟一个长度为sum的bool数组B[sum]，并全部初始化为false，
对数组A进行一次遍历，如果当前的元素A[i]大于sum，则直接跳过，
否则，继续作如下判断，如果B[A[i]]为false，则将B[sum-A[i]]置为ture，这样当继续向后遍历时，
如果有B[A[i]]为true，则有符合条件的两个数，分别为A[i]和sum-A[i]。如果遍历A结束后依然没有发现有B[A[i]]为true的元素，则说明找不到符合条件的元素。
该算法的时间复杂度为O（n），但空间复杂度为O（sum）。或者如果知道非负整数数组A的最大值为MAX，则也可以开辟一个MAX大小的bool数组，思路是一样的。




#include<stdio.h>
#include<stdlib.h>
#include<string.h> 
bool findTwoNumInArrayEqualS(int *arr,int len,int S,int *first,int *second){
    if(arr==NULL||len<2){
        return false;
    }
    bool isExist=false;
    //开辟一个长度为S的辅助数组 
    bool *temp=(bool *)malloc((S+1)*sizeof(bool));
    if(temp==NULL){
        exit(EXIT_FAILURE);
    }
    memset(temp,false,(S+1)*sizeof(bool));//初始化为false； 
    for(int i=0;i<len;i++){
        if(arr[i]>=S){//遇到元素大于S的直接跳过 
            continue;
        }
        else {
            if(temp[arr[i]]){//为true，就说明，已经找到了符合条件的两个数，但不能保证乘积是最小的。，如果需要乘积最小的，只能将结果保存起来，然后选择出最小的即可。 
                *first=arr[i];
                *second=S-arr[i];
                return true; 

            }
            else{//如果arr[i}没有被标记，则将其S-arr[i]标记为true。 
                temp[S-arr[i]]=true;
            }
        }
    }
    return isExist;

}
int main(void){
    int n,k;
    while(scanf("%d%d",&n,&k)!=EOF&&n>1&&n<1000000&&k>0){
        int *arr=(int *)malloc(n*sizeof(int));
        if(arr==NULL){
            exit(EXIT_FAILURE);
        }
        for(int i=0;i<n;i++){
            scanf("%d",arr+i);
        }
        int first,second;
        bool isExist=findTwoNumInArrayEqualS(arr,n,k,&first,&second);
        if(isExist){
            printf("%d   %d\n",first,second);
        }
        else{
            printf("-1  -1\n");
        }
    }

    return 0;
}

HelloWorld_EE

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
《剑指Offer》和为定值的两个数

题目描述：输入一个递增排序的数组和一个数字S，在数组中查找两个数，是的他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。思路一按顺序进行扫描，时间复杂度为O(n*n) /*输入：每个测试案例包括两行：第一行包含一个整数n和k，n表示数组中的元素个数，k表示两数之和。其中1 <= n <= 10^6，k为int第二行包含n个整数，每个数组均为int类型。输出：对应每
复制链接

扫一扫