数据结构与算法--有序数组中找出和为s的两个数字

有序数组中找和为s的两个数字

题目：输入一个递增排序的数组array，和一个数字s，在数组中找出两个数，使得这两个数的和是s，如果有多对，输出一对即可。

最简单方案

双循环，每次获取一个数据，和数组中其他数据求和，与s比较，此方法最直观，时间复杂度是O(n²)，比如必然会有更优解

优化方案一

既然要找两个数字，而且是数组，第一感觉就是双指针的策略，分析如下
- 既然要找两个数字，那么假如我们随机选两个，如果和小于s，那么应该向后找，反之向前找
- 案例分析法{1,2，4,7，11,15}，找和为15 的
- 初始化两个指针分别指向最后元素positionBig，指向第一个元素 positionSmall
- 如果两个数据和正好是s，那么得到解
- 如果两个数据和大于s，说明需要减少，那么应该positionBig –
- 如果两个数据和小于s，说明需要增大，那么应该positionSmall++
- 如下图：
如上分析有如下代码

/*** 在有序数组中查找和为 s的两个数字* @author liaojiamin* @Date:Created in 17:38 2021/6/29*/
public class FindSumInSortArray {public static void main(String[] args) {int[] array = new int[]{1,2,3,7,8,11,14,16,17,18,23,47,59,67,79,83,222,344,556,778};System.out.println(findSumNum(array, 111));}/*** 找出递增排序数组中的两个数字，使得这两个数字的和为 s* */public static boolean findSumNum(int[] array, int s){if(array == null || array.length <= 0){return false;}int positionBig = array.length -1;int positionSmall = 0;while (array[positionBig] + array[positionSmall] != s){if(positionBig < positionSmall){return false;}if(array[positionBig] + array[positionSmall] > s){positionBig --;}if(array[positionBig] + array[positionSmall] < s){positionSmall++;}}System.out.println(array[positionSmall] + " + "+ array[positionBig] +" = "+ s);return true;}
}

如上代码中我们while循环的退出条件是 positionBig< positionSmall那么我们总共应该就是一次循环，时间福再度是O(n)，不使用额外空间

变种题型，非有序数组

题目：输入一个非有序数组array，和一个数字s，在数组中找出两个数的组合，使得这两个数的和是s，如果有多对，输出多对即可。

因为没有了有序的特性，我们无法用上题中的方案，最简单办法，先排序，在按上面的方法，这样时间复杂度比如超过O(n)
另一中思路，空间换时间：
- 遍历数组，并且将数组已经遍历过的值k 存储在hash中，存储模式为 key = k， value = k，这样可以用O(1)的时间拿到已经范问过的数据
- 每次遍历数组中数据 n 时候，查找hash中 s-n
- 如果s-n 存在，那么在之前遍历过的数据中存在与n 配对后和为s的数据，一次遍历完数据，找到我们需要的所有配对：

 /*** 非有序数组中找出和为s的两个数* */public static boolean findSumInList(int[] array, int s){if(array == null || array.length <= 0){return false;}boolean exists = false;Map<Integer, Integer> sumKeyValue = new HashMap<>();for (int i = 0; i < array.length; i++) {Integer key = array[i];if(sumKeyValue.containsKey(s - key)){System.out.println(key +" + "+ (s-key) +" = "+ s);exists = true;}sumKeyValue.put(key, key);}return  exists;}

以上解法借助了HashMap，所以在时间复杂度计算中需要考虑containsKey的开销，如果出题人不让用jdk相关的集合类，我们可以通过数组自己实现一个Hash。

更复杂的题型

类似题：输入一个正数s，打印所有和为s的连续正数序列(至少含有2个数字)，例如，输入15，得到1+2+3+4+5 = 4+5+6=7+8，所以我们有打印出三个连续的序列1 ~ 5， 4 ~ 6， 7 ~ 8

按如上题目的解决思路，此处也是寻找和为s的值，只不过是N数据的和，并且没有给出数字，那么案例中s=15，时候其实隐含的条件就是数组是 1~14 ，因为条件中都是正整数，那么有如下分析：
- 依然双指针方法，因为此处我们需要找连续的数据，那么不能前后寻找，设positionBig = array.length，positionSmall = pogitionBig-1
- 如果positionSmall ~ positionBig 中所有数据和为 s，那么得出正解，此时让positionBig–，positionSmall = positionBig-1，继续求解
- 如果positionSmall ~ positionBig中所有数据和 > s,那么说明数据和过大，我们应该减少大的值positionBig–
- 如果positionSmall ~ positionBig 中所有数据和 < s, 说明数据和过小，我们扩大数据的基数，让更多数据累加 positionSmall –
- 我们从后向前逐个逐个的查询求和的组合，最后得到正解
- 如下图所示：
第一个数列：
第二个数列：
第三个数列：
经如上分析有如下代码：

/*** 在有序数组中查找和为 s的两个数字* @author liaojiamin* @Date:Created in 17:38 2021/6/29*/
public class FindSumInSortArray {public static void main(String[] args) {int[] arrayAll = new int[]{1,2,3,4,5,6,7,8,9,10,11,12,13,14};System.out.println(findAllSumList(arrayAll, 15));}public static boolean findAllSumList(int[] array, int s){if(array == null || array.length <= 0){return false;}boolean exists = false;int positionBig = array.length -1;int positionSmall = 0;while (array[positionBig] > s){positionBig --;}positionSmall = positionBig-1;while (positionBig > 0){Integer sum = 0;for (int i = positionSmall; i <= positionBig; i++) {sum+=array[i];}if(sum == s){System.out.println(array[positionSmall] + " ~ "+ array[positionBig] +" = "+ s);exists = true;positionBig--;positionSmall = positionBig-1;continue;}if(sum < s){positionSmall--;if(positionSmall < 0){return exists;}continue;}if(sum > s){positionBig --;continue;}}return exists;}
}

如上实现代码中我用双指针的方式来做了一个类似双循环的操作，每次找到解，则递减一位，让标记为从一个方向遍历整个数组，时间复杂度O(n²)。

变种题型：输入一个正数s，打印所有和为s的元素的组合(至少含有1个数字)，例如，输入{1,2,3,4,5,6,7,8,9,10,11,12,13,14}，9，得到如下

9
8,1
7,2
6,3
6,2,1
5,4
5,3,1
4,3,2

解题分析：
- 如上案例分析中，存在不很多不连续的数列也可以符合组合求和的题目要求，因此连续查找的方式需要进行调整
- 还是延续上题中思路，找到第一个小于目标值的positionBig，令positionSmall = positiomBig - 1
- 依次遍历positionSmall ~ 0 ，并在临时数组temp 保存positionBig值
- 令sum = positionSmall + sum(temp)，
- 当sum > s，说明当前数据过大，需要减小，执行positionSmall –
- 当sum < s ，说明当前数据过小，但是可能符合要求，将positionSmall 添加到temp，执行positionSmall –
- 当sum = s ，符合题解，将当前temp 添加到resultList队列中得到一组解，并且执行positionSmall –
- 依次执行如上流程，直到positionSmall < 0，执行positionBig –
- 查找退出条件 positionBig < 0
经如上分析有如下代码：

/*** 在有序数组中查找和为 s的数字的所有组合情况* @author liaojiamin* @Date:Created in 17:38 2021/6/29*/
public class FindSumInSortArray {public static void main(String[] args) {int[] arrayAll = new int[]{1,2,3,4,5,6,7,8,9,10,11,12,13,14};List<int[]> allCombom = findAllCombination(arrayAll, 9);for (int[] mySumNum : allCombom) {for (int i = 0; i < mySumNum.length; i++) {if(mySumNum[i] > 0){System.out.print(mySumNum[i] + ",");}}System.out.println();}}/*** 有序数组中找出所有和为s的数字的组合,* */public static List<int[]> findAllCombination(int[] array, int s){if(array == null || array.length <= 0){return Lists.newArrayList();}int positionBig = array.length - 1;List<int[]> allCombination = new ArrayList<>();while (array[positionBig] >= s){if(array[positionBig] == s){allCombination.add(new int[]{array[positionBig]});}positionBig--;}while (positionBig > 0){int positionSmall = positionBig - 1;int[] temp = new int[positionBig+1];temp[0] = array[positionBig];int tempPosition = 1;while (positionSmall >= 0){int sum = 0;for (int i=0;i<temp.length;i++){sum+=temp[i];}sum += array[positionSmall];if(sum > s){positionSmall --;continue;}if(sum < s){temp[tempPosition] = array[positionSmall];tempPosition ++;positionSmall--;continue;}if(sum == s){temp[tempPosition] = array[positionSmall];allCombination.add(temp);temp = new int[positionBig];tempPosition = 0;temp[tempPosition] = array[positionBig];tempPosition ++;positionSmall --;continue;}}positionBig --;}return allCombination;}
}