寻找和为定值的两个数

寻找和为定值的两个数

1、问题描述

插入一个整数数组和一个整数，在数组中查找一对数，满足它们的和正好是输入的那个整数。如果有多对数的和等于输入的整数，输出任意一对即可。

2、解法一：构建哈希表

针对本题，除了排序以外，笔者比较容易想到的方法是构建哈希表。下面对这个算法进行描述：

算法准备：将插入的整数数组构建成哈希表--在构建哈希表时，笔者采用取余的方法构建哈希函数，采用链表法避免冲突

step1: 遍历输入的整数数组，将输入的目标整数与数组中的元素array[i]相减，得到新的整数b[i]；

step2: 在构建的哈希表中查找b[i]的值；

step3: 若找到，打印array[i]，b[i]的值，算法结束；否则，重复step1和step2

2.1 解法一算法复杂度分析

遍历数组查询array[i]，复杂度为O(n),根据哈希映射查找b[i]是否存在数组中，此种方法耗时O(1)，所以总的时间复杂度为O(n)。

2.2 寻找和为定值--构建哈希表代码

/************************
Author:tmw
date:2017-11-19
************************/
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define HASHSIZE 100
//哈希表数据结构
typedef struct hash_node
{
    int elem;
    struct hash_node *next;
}hash_node;

struct hash_node HashList[HASHSIZE];//构建的哈希表作为全局变量

//取余法构建哈希函数
int hash_fun( int elem )
{
    return elem%HASHSIZE;
}

//创建哈希表
void Create_Hash_List( int* array , int array_len )
{
    int i;
    //初始化哈希表
    for( i = 0 ; i < array_len ; i++ )
    {
        HashList[i].elem = i;
        HashList[i].next = NULL;
    }
    //将数组元素转存入哈希表
    int hash_index;
    for( i = 0 ; i < array_len ; i++ )
    {
        hash_node *new_node;
        new_node = (hash_node*)malloc(sizeof(hash_node));
        new_node->elem = array[i];

        hash_index = hash_fun(array[i]);
        //头插法插入链表
        new_node->next = HashList[hash_index].next;
        HashList[hash_index].next = new_node;
    }
}
//主算法：哈希法查找和为定值的任意两个数
bool Find_twoNumber_Stable_Sum_usingHash(int *array , int array_len , int sum )
{
    Create_Hash_List( array , array_len );
    int i,target,target_hash_index;
    for( i = 0 ; i < array_len ; i++ )
    {
        target = sum - array[i];
        //在哈希表中找target
        target_hash_index = hash_fun(target);
        hash_node *p;
        p = HashList[target_hash_index].next;
        while(p)
        {
            if(p->elem == target)
            {
                printf("%d + %d = %d\n",array[i],target,sum);
                return true;
                //break; //[如果测多个]可将return true注解,将break解注
            }
            p = p->next;
        }
    }
    printf("没有和为 %d 的两个数",sum);
    return false;
}

2.3 寻找和为定值--构建哈希表测试代码及结果

int main()
{
    printf("测试代码\n");
    int i;
    int sum = 15;

    int a[12] = {1,2,4,5,7,11,54,3,8,6,10,13};
    for(i=0;i<12;i++)
        printf("%d ",a[i]);
    printf("\n");
    Find_twoNumber_Stable_Sum_usingHash(a,12,sum);

    int b[15] = {3,4,2,10,5,0,12,13,8,9,16,17,20,1,6};
    for(i=0;i<15;i++)
        printf("%d ",b[i]);
    printf("\n");
    Find_twoNumber_Stable_Sum_usingHash(b,15,sum);

    return 0;
}

3、方法二--排序夹逼法

如果数组是无序的，可以考虑把数组排成有序的，数组变成有序的后，便有好几种方法可以找到其和等于给定的数的两个数。在这里，笔者重点推荐排序夹逼的方法。算法如下：

算法准备：用快速排序，将无序数组变成有序

step1:设定两个游标begin和end,分别指向数组的头和尾

step2:如果某一时刻，array[begin]+array[end]>sum，则begin不动，end--,缩小array[begin]+array[end]的值

step3:如果某一时刻，array[begin]+array[end]<sum，则end不动，begin++,增大array[begin]+array[end]的值

算法结束：当array[begin]+array[end]==sum时，返回array[begin]和array[end]的值，算法结束；当begin==end但

array[begin]+array[end]!=sum，说明数组内没有和为sum的两个数，返回错误。

3.1  排序夹逼法代码

/***********************
Author:tmw
date:2017-11-19
************************/
#include <stdio.h>
#include <stdlib.h>

#define swap(x,y,t) (t=x,x=y,y=t)

//快排中枢元素选取--三数取中子模块
int median3(int *array , int low , int high )
{
    int mid = ( low + high ) / 2;
    int temp;
    if( array[high] < array[mid] )
        swap( array[high] , array[mid] , temp );
    if( array[high] < array[low] )
        swap( array[high] , array[low] , temp );
    //以上，保证array[high]为三数中的最大值
    if( array[low] < array[mid] )
        swap( array[low] , array[mid] , temp );
    //以上，保证array[low]为三数中的中间值
    return array[low];
}
//一次快排
int fast_sort_using_median3(int *array , int low , int high )
{
    array[low] = median3(array,low,high);

    int target = array[low];//中枢元素备份

    while( low < high )
    {
        while( low < high && array[high] >= target  )
            high--;
        array[low] = array[high];

        while( low < high && array[low] <= target   )
            low++;
        array[high] = array[low];
    }
    array[low] = target;
    return low;
}
//所有元素快排
int* fast_sort_all(int *array , int low , int high)
{
    if( low < high )
    {
        int mid_index;
        mid_index = fast_sort_using_median3(array,low,high);
        fast_sort_all(array,0,mid_index-1);
        fast_sort_all(array,mid_index+1,high);
    }
    return array;
}

//排序夹逼主算法
void TowSum_Sort_and_Aproach(int *array , int array_len , int sum )
{
    int begin = 0;
    int end = array_len - 1;
    array = fast_sort_all(array,0,array_len - 1);//将数组由无序变有序

    while( begin < end )
    {
        if( array[begin] + array[end] == sum )
        {
            printf("%d + %d = %d\n",array[begin],array[end],sum);
            //begin++;
            //end--;
            break;//如果要求的是输出所有满足条件的整数对，则将此break注解，将begin++;end--解注
        }
        else
        {
            if( array[begin] + array[end] > sum )//array[begin]+array[end]>sum，则begin不动，end--
                end--;
            else//array[begin]+array[end]<sum，则end不动，begin++
                begin++;
        }
    }
    if(begin == end)
        printf("数组中没有和为 %d 的两个数\n",sum);
}

3.2 排序夹逼法测试代码及结果

int main()
{
    printf("测试代码\n");
    int i;
    int sum = 15;

    int a[12] = {1,2,4,5,7,11,54,3,8,6,10,13};
    for(i=0;i<12;i++)
        printf("%d ",a[i]);
    printf("\n");
    TowSum_Sort_and_Aproach(a,12,sum);

    int b[15] = {3,4,2,10,5,0,12,13,8,9,16,17,20,1,6};
    for(i=0;i<15;i++)
        printf("%d ",b[i]);
    printf("\n");
    TowSum_Sort_and_Aproach(b,15,sum);

    return 0;
}

梦想还是要有的，万一实现了呢~~~~ヾ(◍°∇°◍)ﾉﾞ