Java算法之 给定一个整型数组，找出两个整数为指定整数的和

为什么80%的码农都做不了架构师？>>>   

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

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

    /**
     * 暴力破解
     * (穷举，时间复杂度：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("找不到这两个数");
    }

 

问题描述：
给定一个整型的数组，找出其中的两个数使其和未指定的值，返回两个数的数组下标（假定是无序数组，数组元素各不相同，要求时间复杂度为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.containsKey(two)&&target!=2*two)
            {
                result[0]=i;
                result[1]=map.get(two);
                // 返回找到的两个数的数组下标
                return result;
            }
        }
        // 没有找到
        return result;
    }

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

 

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

分析： 
与上面的不同，这里需要算出的是存不存在这两个数，可以在上一篇的基础上修改一下数据结构，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));
    }
}

 

转载于:https://my.oschina.net/90888/blog/1649282