【算法世界】（八）找出数组中的两个数，使得二者之和为特定值target

最新推荐文章于 2021-11-20 19:30:57 发布

暂7师师长常乃超

最新推荐文章于 2021-11-20 19:30:57 发布

阅读量1.9k

点赞数 1

分类专栏：【算法世界】【leetcode】

本文链接：https://blog.csdn.net/zzh920625/article/details/78095607

版权

【算法世界】同时被 2 个专栏收录

8 篇文章 10 订阅

订阅专栏

【leetcode】

2 篇文章 1 订阅

订阅专栏

上午无意间看到微信群里有朋友在发算法面试题，我就看了看，中午吃完饭也思考了一下，做个总结。

题目

如上图所示，这位朋友面试的应该是一家不在北美之内的公司，哈哈。（return indices，indices是index的复数形式，盛行于除北美国家以外的英语里，而indexes在美国、加拿大等国的英语里）

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9;

return [0, 1].

之后填充：

class Solution{
     public int[] twoSum(int[] nums, int target){
         //TODO with Java
     }
}

分析

一、遍历

最容易想到的一种解决方案，就是类似于选择排序那样，从左到右一点点慢慢缕，直到找到对应的那两个数为止，小编我自己实现了一把，如下：

//遍历的方式返回
int[] getSumSort(int[] arr, int sum,int n){
	int i,j;
	for(i = 0; i <n-1; i++){
		for(j =i +1;j < n; j++){
			if(arr[i] + arr[j] == sum){
				return new int[]{i,j};
			}
				
		}
	}
	return new int[]{-1,-1};
}

在Eclipse中跑了一遍：

public static void main(String[] args) {
	
	int[] array = new int[]{7,1,4,10,12,21};
	int length = array.length;
	int[] result = new int[2];
	
	SumEqualsTarget test = new SumEqualsTarget();
	
	//遍历的方式
	result = test.getSumSort(array,16,length);
	
	System.out.println(Arrays.toString(result));
}

显示结果：

这种写法确实是最low的一种写法，遍历的效率无疑是最低的，由于这种写法完全就是选择排序那套，参考各种排序的时间复杂度，如图：

可见，我这样子做完之后，时间复杂度为O(n^2)，比较消耗性能（性能很低很低），需要优化。

二、做差

1、思路：

这个想法是前几天晚上和Celine在路上交流的一个想法，题目和这个基本一直，当时我是想用tartget值和array中的数做差，得到一个int result，在排除掉被减数本身的数组中，看是否存在result这个值。即比如：

array[1, 3, 5, 7, 8, 9]；

target = 15;

用7做基准，result = target - 7 = 15 - 7 = 8; 相当于要在这个排除掉7的新数组中{1, 3, 5, 8, 9}，看是否有8的存在。

2.分析

我当时的这种想法，首先选择基准的时候，需要遍历一次array数组，时间复杂度O（n），之后在剩余的数中进行查找，通过找网上的资料，对比如图：

可知，对于剩下的n-1个元素，如果进行查找"result"的值，比较简便的是“顺序查找”和“二分查找”，前者时间复杂度是O（n），后者是O（lgN），但是后者的前提是事先排序！！！

经过计算，如果最终采用“顺序查找”的方式来做，时间复杂度是O（n*n）即O（n^2），因为找基准被减数为O（n），查找也为O（n）。对于最终采用“二分查找”的方式，他的总时间复杂度则为O（n*lgN）,明显要比顺序查找小一些了，Pay Attention：如果使用“二分查找”，需要首先这个数组是有序的，那就提前先进行快排，那么如果我使用实现了一版代码，如下：

public static void main(String[] args) {
	//定义原始数组、数组长度、两个数之和的目标值target
	int[] array = new int[]{1,4,7,10,12,21}; //这里先进行快速排序，得到的数组名称为array（快排过程不予演示，时间复杂度O（n*lg2N））
	int length = array.length;
	int target = 14;
	
	//做差的方式，内部基于二分查找
	for(int i=0; i<length; i++){
		int index;
		
		int[] arrNew = ArrayUtils.remove(array, i); //ArrayUtils需要导入import org.apache.commons.lang3.*的包
		
		int result1 = binarySearch(arrNew,target-array[i]);

		if( result1 != -1){
			index = ArrayUtils.indexOf(array, arrNew[result1]);
			System.out.println("得到的下标值为：" + i +" , " + index);
		}
	
	}
}

//二分查找的方式
public static int binarySearch(int[] srcArray, int des){   
	  
	int low = 0;   
	int high = srcArray.length-1;   
	while(low <= high) {   
		int middle = (low + high)/2;   
		if(des == srcArray[middle]) {   
			return middle;   
		}else if(des <srcArray[middle]) {   
			high = middle - 1;   
		}else {   
			low = middle + 1;   
		}  
	}  
	return -1;  
}

由上可见，快速排序O（n*lgN），寻找基础O（n）,二分查找O（lgN），则这种方法的总的时间复杂度为O（n*lgN），要比遍历时O（n^2）小多了。虽然每次循环都需要实例化一个新的数组，但是一遍循环之后，该数组被释放，空间复杂度上并没有增加太多，非常可选的一个方案。

三、对做差法做封装

如上代码所示，我在main()方法中写了一些逻辑代码，其实这里仅仅需要调用一个方法就ok了，main中的有些职能是属于binarySearch()这个方法中的。即在设计模式中学过的“单一职责原则”，同时结合题目，需要返回原数组的下标值，由于我先进行一趟排序，所以需要把原数组扔进去，在binarySearch()中查到的下标索引，需要转换为Array这个数组的下标索引，这样就Ok了！

这类的问题，有对排序、查询的基础了解，有了思路，实现就不难了。

That's all.