有序数组中找和为s的两个数字
题目：输入一个递增排序的数组array， 和一个数字s， 在数组中找出两个数，使得这两个数的和是s，如果有多对，输出一对即可。
最简单方案
- 双循环，每次获取一个数据，和数组中其他数据求和，与s比较，此方法最直观，时间复杂度是O(n2)，比如必然会有更优解
优化方案一
-
既然要找两个数字，而且是数组，第一感觉就是双指针的策略，分析如下
- 既然要找两个数字，那么假如我们随机选两个，如果和小于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(n2)。
变种题型： 输入一个正数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;
}
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
