找出数组中两数之和为指定值的所有整数对

一，问题描述

给定一个整型数组（数组中的元素可重复），以及一个指定的值。打印出数组中两数之和为指定值的 所有整数对

思路1：可以用hash表来存储数组中的元素，这样我们取得一个数后，去判断sum - val 在不在数组中，如果在数组中，则找到了一对二元组，它们的和为sum，该算法的缺点就是需要用到一个hash表，增加了空间复杂度。

思路2：同样是基于查找，我们可以先将数组排序，然后依次取一个数后，在数组中用二分查找，查找sum -val是否存在，如果存在，则找到了一对二元组，它们的和为sum，该方法与上面的方法相比，虽然不用实现一个hash表，也没不需要过多的空间，但是时间多了很多。排序需要O(nLogn)，二分查找需要(Logn)，查找n次，所以时间复杂度为O(nLogn)。

思路3：该方法基于第2种思路，但是进行了优化，在时间复杂度和空间复杂度是一种折中，但是算法的简单直观、易于理解。首先将数组排序，然后用两个指向数组的指针，一个从前往后扫描，一个从后往前扫描，记为first和last，如果 fist + last < sum 则将fist向前移动，如果fist + last > sum，则last向后移动。

二，算法分析

一共有两种方法来求解。方法一借助排序，方法二采用HashSet

方法一：

先将整型数组排序，排序之后定义两个指针left和right。left指向已排序数组中的第一个元素，right指向已排序数组中的最后一个元素

将 arr[left]+arr[right]与 给定的元素比较，若前者大，right--；若前者小，left++；若相等，则找到了一对整数之和为指定值的元素。

此方法采用了排序，排序的时间复杂度为O(NlogN)，排序之后扫描整个数组求和比较的时间复杂度为O(N)。故总的时间复杂度为O(NlogN)。空间复杂度为O(1)

方法二：

依次遍历整型数组，对整型数组中的每一个元素，求解它的suplement（expectedSum-arr[i]）.suplement就是指定的值减去该数组元素。

如果该元素的 suplement不在HashSet中，则将该元素添加到HashSet。

如果该元素的suplement在HashSet中，说明已经找到了一对整数之和为指定值的元素。

该方法使用了HashSet，故空间复杂度为O(N)，由于只需要扫描一遍整型数组，故时间复杂度为O(N)

三，完整代码实现：

import java.util.Arrays;import java.util.HashSet;public class ExpectSumOfTwoNumber {        public static void expectSum_bySort(int[] arr, int expectSum)    {        if(arr == null || arr.length == 0)            return;        Arrays.sort(arr);        int left = 0, right = arr.length - 1;                while(left < right)        {            if(arr[left] + arr[right] > expectSum)                right--;            else if(arr[left] + arr[right] < expectSum)                left++;            else//equal            {                System.out.println(arr[left] + " + " + arr[right] + " = " + expectSum);                 left++;                right--;            }        }    }            public static void expectSum_bySet(int[] arr, int expectSum)    {        if(arr == null || arr.length == 0)            return;        HashSet<Integer> intSets = new HashSet<Integer>(arr.length);                int suplement;        for (int i : arr)        {            suplement = expectSum - i;            if(!intSets.contains(suplement)){                intSets.add(i);            }else{                System.out.println(i + " + " + suplement + " = " + expectSum);            }        }    }        //hapjin test    public static void main(String[] args) {        int[] arr = {2,7,4,9,3};        int expectSum = 11;        expectSum_bySet(arr, expectSum);        System.out.println("************");        expectSum_bySort(arr, expectSum);        System.out.println("----------------");        int[] arr2 = {3,7,9,1,2,8,5,6,10,5};        int expectSum2 = 10;        expectSum_bySet(arr2, expectSum2);        System.out.println("**********");        expectSum_bySort(arr2, expectSum2);    }}

问题描述：给定一个整型的数组，找出其中的两个数使其和未指定的值，返回两个数的数组下标（假定是无序数组，数组元素各不相同，要求时间复杂度为O(n),n为数组长度,可以使用辅助空间）

分析：时间复杂度是O(n)，即是扫描一遍数组，不可嵌套扫描。必须全部数组扫描和查找全部，扫描+查找=O(n)，可以使用数据结构哈希表，哈希表的查找的时间复杂度是O(1)。

理一理代码思路

（1）. 因为输出是数组下标，那么就让数组下标为哈希表中的值，数组的值为哈希表中的键，扫描一遍数组，put进HashMap，代码如下（时间复杂度O(n)，n为数组大小）：

        HashMap<Integer, Integer> map=new HashMap<Integer, Integer>();        for(int i=0;i<nums.length;i++)        {            map.put(nums[i], i);        }

（2）.第二遍扫描就是要查找出值，这里要做两个判断，一个就是两个结果数的值不能相同，这是题目要求的，还有一个就是判断HashMap是否有值，代码如下（最坏情况的时间复杂度是O(n)，n为数组大小）：

        for(int i=0;i<nums.length;i++)        {            // 得到第二个数的值            int two=target-nums[i];            // 如果存在第二个数的数组下标&&结果的两个数不是同一个数的值            if(map.containsValue(two)&&target!=2*two)            {                result[0]=i;                result[1]=map.get(two);                // 返回找到的两个数的数组下标                return result;            }        }

整合代码最终如下

    /**     * 使用辅助空间(使用哈希表，时间复杂度是O(n),空间复杂度：O(n),n是数组大小)     * @param nums     * @param target     * @return 没有找到的话数组中数值就是{-1,-1}，否则找到，其实我想返回null的，但是觉得返回null不礼貌，因为null有毒     */    public static int[] findTwo3(int[] nums, int target)    {        // 结果数组        int[] result={-1,-1};        // 目标是数组下标，所以键值对为<数值,数值对应数组下标>，这里要说一下，哈希表的查找的时间复杂度是O(1)        HashMap<Integer, Integer> map=new HashMap<Integer, Integer>();        // 1.扫描一遍数组，加入哈希表，时间复杂度是O(n)        for(int i=0;i<nums.length;i++)        {            map.put(nums[i], i);        }        // 2.第二次扫描，目标值-当前值，差值作为key，看看map里有木有，没有就下一个循环，直到数组扫描完毕或找到value,所以最坏情况的时间复杂度是O(n)        for(int i=0;i<nums.length;i++)        {            // 得到第二个数的值            int two=target-nums[i];            // 如果存在第二个数的数组下标&&结果的两个数不是同一个数的值            if(map.containsValue(two)&&target!=2*two)            {                result[0]=i;                result[1]=map.get(two);                // 返回找到的两个数的数组下标                return result;            }        }        // 没有找到        return result;    }

思考：假如数组中有重复的话，那么上面的算法将失效，因为数据结构HashMap<Interget,Interget>已经不合适，这样我觉得可以使用HashMap<Interget,List<Interget>>来解决。

问题描述：给定一个整型数组，是否能找出其中的两个数使其和为某个指定的值？（假定是无序数组）

解法一：暴力破解（穷举法，不提倡）

    /**     * 暴力破解     * (穷举，时间复杂度：O(n^2)，正常是不会用这个滴，假如只是为了快速解题，对时间没有限制，用这个最简单)     *     * @param nums     * @param target     */    public static void findTwo1(int[] nums, int target)    {        int one, two;        for (int i = 0; i < nums.length; i++)        {            one = nums[i];            two = target - one;            for (int j = 0; j < nums.length; j++)            {                if (i != j)                {                    if (two == nums[j])                    {                        System.out.println("one:" + one + " two:" + two);                        return;                    }                }            }        }        System.out.println("找不到这两个数");    }

解法二：二分法（相当于用两个指针）

    /**     * 两个指针二分查找     * (排序时间复杂度为O(nlog(n)),while最多O(N)，所以最终程序的时间复杂度为：O(nlo(n)))     *     * @param nums     * @param target     */    public static void findTwo2(int[] nums, int target)    {        // 1.排列（用的是Dual-Pivot Quicksort(快速排序),时间复杂度为O(nlog(n))）        Arrays.sort(nums);        // 2.类二分查找        int left = 0;        int right = nums.length - 1;        while (left < right)        {            if (nums[left] + nums[right] > target)            {// 太大 right减少                right--;            }            else if (nums[left] + nums[right] < target)            {// 太小left增加                left++;            }            else            {// 找到结果，结束查找                System.out.println("one:" + nums[left] + " two:" + nums[right]);                return;            }        }        System.out.println("找不到这两个数");    }

问题描述：
设计一个类，包含如下两个成员函数：
Save(int input) 插入一个整数到一个整数集合里。
Test(int target) 检查是否存在两个数和为输入值。如果存在着两个数，则返回true，否则返回false
允许整数集合中存在相同值的元素

分析：
与[算法学习]给定一个整型数组，找出两个整数为指定整数的和(2)不同，这里需要算出的是存不存在这两个数，可以在上一篇的基础上修改一下数据结构，HashMap

理一理代码思路

（1）. 写Save(int input)。这个就简单了，只需判断是否存在input为key，有就value+1，没有就value=1。代码如下：

public void Save(int input){    int count = 0;    if (map.containsKey(input))    {        count = map.get(input);    }    map.put(input, count + 1);}

（2）. 检查是否存在两个数和为输入值。上面的分析已经讲得差不多，这里就直接贴代码。代码如下：

public boolean Test(int target){    Iterator<Integer> iterator = map.keySet().iterator();    while (iterator.hasNext())    {        int one = iterator.next();        int two = target - one;        System.out.println("one:"+one+" two:"+two);        if (map.containsKey(two))        {            // two<<1等价于two*2            if (!(target ==two<<1 && map.get(two) == 1))            {                return true;            }        }    }return false;}

整合代码最终如下

import java.util.HashMap;import java.util.Iterator;public class TwoNumOfSum3{    // key：数值，value：数值对应的个数    HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();    /**     * 插入一个整数到一个整数集合里     * @param input     */    public void Save(int input)    {        int count = 0;        if (map.containsKey(input))        {            count = map.get(input);        }        map.put(input, count + 1);    }    /**     * 检查是否存在两个数和为输入值     * @param target     * @return 如果存在着两个数，则返回true，否则返回false     */    public boolean Test(int target)    {        Iterator<Integer> iterator = map.keySet().iterator();        while (iterator.hasNext())        {            int one = iterator.next();            int two = target - one;            System.out.println("one:"+one+" two:"+two);            if (map.containsKey(two))            {                if (!(target ==two<<1 && map.get(two) == 1))                {                    return true;                }            }        }        return false;    }    /**     * @param args     */    public static void main(String[] args)    {        TwoNumOfSum3 t=new TwoNumOfSum3();        t.Save(5);        t.Save(10);        t.Save(4);        t.Save(7);        System.out.println(t.Test(12));    }}

时间复杂度O(n)的解法

我们可以用一个哈希表或数组或bitmap(后两者要求数组中的整数非负)来保存sum-x的值， 这样我们就只需要遍历数组两次即可找到和为指定值的整数对。这种方法需要O(n) 的辅助空间。如果直接用数组或是bitmap来做，辅助空间的大小与数组中的最大整数相关， 常常导致大量空间浪费。比如原数组中有5个数：1亿，2亿，3亿，4亿，5亿。sum为5亿， 那么我们将bitmap中的sum-x位置1，即第4亿位，第3亿位，第2亿位，第1亿位，第0位置1. 而其它位置都浪费了。

如果使用哈希表，虽然不会有大量空间浪费，但要考虑冲突问题。

时间复杂度为O(nlogn)的解法

我们来考虑一种空间复杂度为O(1)，而且实现也很简单的算法。首先，将数组排序。 比如排序后得到的数组a是：-2 -1 0 3 5 6 7 9 13 14。然后使用low和high 两个下标指向数组的首尾元素。如果a[low]+a[high] > sum，那么说明a[high] 和数组中的任何其它一个数的和都一定大于sum(因为它和最小的a[low]相加都大于sum)。 因此，a[high]不会与数组中任何一个数相加得到sum，于是我们可以直接不要它， 即让high向前移动一位。同样的，如果a[low]+a[high] < sum，那么说明a[low] 和数组中的任何其它一个数的和都一定小于sum(因为它和最大的a[high]相加都小于sum)。 因此，我们也可以直接不要它，让low向前移动一位。如果a[low]+a[high]等于sum， 则输出。当low小于high时，不断地重复上面的操作即可。

请设计一个一百亿的计算器

首先要明白这道题目的考查点是什么，

一是大家首先要对计算机原理的底层细节要清楚、要知道加减法的位运算原理和知道计算机中的算术运算会发生越界的情况，

二是要具备一定的面向对象的设计思想。
首先，计算机中用固定数量的几个字节来存储的数值，所以计算机中能够表示的数值是有一定的范围的，为了便于讲解和理解，我们先以byte 类型的整数为例，它用1个字节进行存储，表示的最大数值范围为-128到+127。-1在内存中对应的二进制数据为11111111，如果两个-1相加，不考虑Java运算时的类型提升，运算后会产生进位，二进制结果为1,11111110，由于进位后超过了byte 类型的存储空间，所以进位部分被舍弃，即最终的结果为11111110，也就是-2，这正好利用溢位的方式实现了负数的运算。-128 在内存
中对应的二进制数据为10000000，如果两个-128相加，不考虑Java运算时的类型提升，运算后会产生进位，二进制结果为1,00000000，由于进位后超过了byte类型的存储空间，所以进位部分被舍弃，即最终的结果为00000000，也就是0，这样的结果显然不是我们期望的，这说明计算机中的算术运算是会发生越界情况的，两个数值的运算结果不能超过计算机中的该类型的数值范围。由于Java中涉及表达式运算时的类型自动提升，我们无法用byte类型来做演示这种问题和现象的实验，

大家可以用下面一个使用整数做实验的例子程序体验一下：
int a = Integer.MAX_VALUE;
int b = Integer.MAX_VALUE;
int sum = a + b;
System.out.println(“a=”+a+”,b=”+b+”,sum=”+sum);
先不考虑long类型，由于int的正数范围为2的31次方，表示的最大数值约等于2*1000*1000*1000，
也就是20亿的大小，

所以，要实现一个一百亿的计算器，我们得自己设计一个类可以用于表示很大的整数，并且提供了与另外一个整数进行加减乘除的功能，大概功能如下：
（）这个类内部有两个成员变量，一个表示符号，另一个用字节数组表示数值的二进制数
（）有一个构造方法，把一个包含有多位数值的字符串转换到内部的符号和字节数组中
（）提供加减乘除的功能

[java] view plain copy

1. public class BigInteger //表示很大的整数  
2. {  
3.     int sign;   //标识符号  
4.     byte[] val; //用字节数组表示数值的二进制数  
5.   
6.     //构造方法,把一个包含有多位数值的字符串转换到内部的符号和字节数组中  
7.     public Biginteger(String val)   
8.     {  
9.     sign = ;  
10.     val = ;  
11.     }  
12.   
13.     //+-*%方法  
14.     public BigInteger add(BigInteger other){}    
15.     public BigInteger subtract(BigInteger other){}  
16.     public BigInteger multiply(BigInteger other){}  
17.     public BigInteger divide(BigInteger other){}  
18. }  

 

 

备注：要想写出这个类的完整代码，是非常复杂的，如果有兴趣的话，可以参看jdk 中自带的
java.math.BigInteger 类的源码。面试的人也知道谁都不可能在短时间内写出这个类的完整代码的，他要的
是你是否有这方面的概念和意识，他最重要的还是考查你的能力，所以，你不要因为自己无法写出完整的
最终结果就放弃答这道题，你要做的就是你比别人写得多，证明你比别人强，你有这方面的思想意识就可
以了，毕竟别人可能连题目的意思都看不懂，什么都没写，你要敢于答这道题，即使只答了一部分，那也
与那些什么都不懂的人区别出来，拉开了距离，算是矮子中的高个，机会当然就属于你了。另外，答案中
的框架代码也很重要，体现了一些面向对象设计的功底，特别是其中的方法命名很专业，用的英文单词很
精准，这也是能力、经验、专业性、英语水平等多个方面的体现，会给人留下很好的印象。