（最近博客被盗了，此文章被删除，现在重新发一遍）
前两天，同事问我怎么处理这个问题：他手里有一个比较大的数，还有一堆乱七八糟的数，怎样找出那些数相加等于这个比较大的数。我想了想感觉这是个比较恶心的算法，在网上找了有很多例子，都觉得不太合适。
我们把这个较大的数称作“和”，用sum表示，计算查找的时候我们可能会遇到一些问题：
1. sum没有规则，可能非常大，还可能带着小数点。所以不能用普通的int类型来计算。
2. 数组中可能存在多个集合符合条件，且元素个数不同，比如（1+2+3+4）=10，（4+6）=10。还有可能组中存在重复数据，比如（1+1+2）=4，（2+2）=4。这样用循环语句写就非常麻烦，应该用递归方法。
3. 会不会有的元素就等于“和”本身呢？
我想了一下午，觉得可以用穷举法暴力查找实现：
首先，我们拿到了一个乱七八糟的数组，我们先给他排个序，升序排序，从小到大。
然后，为了增加循环递归的效率，先把相加结果肯定不等于sum的数去掉。数组已经是按大小个排序了，就用最大的数加最小的数，如果相加大于sum，那这个最大数在这个数组里跟谁加都不会等于sum，果断踢走。max+min>sum，则删除max。
最后，数组都排完序了，“太大个”的都踢走了。剩下的就是我们要循环查找的数了。
double a={a0,a1,a2…..an}，如果a[n]+a[n-1]>sum，跳过a[n-1]，判断a[n]+a[n-2]和sum的关系；如果a[n]+a[n-2]
上代码
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class CreateTest {
private static List findNumIndex;// 存储符合条件的数组元素下表
private static boolean findon;// 是否可以从数组中找到相加等于“和”的元素
private static boolean someoneEqualSum;// 数组中是否有某个元素等于“和”本身
private static double[] a;// 数组
private static double sum;// “和”
public CreateTest(double[] a, double sum) {
this.a = a;
this.sum = sum;
findon = false;
findNumIndex = new ArrayList();
someoneEqualSum = false;
}
public void start() {
a = maopao(a);// 首先冒泡排序
List list = new LinkedList();
for (int i = 0; i < a.length; i++) {// 把double数组付给list
list.add(a[i]);
}
boolean flag = true;
do {
double mix = list.get(0);// 当前最小值
double max = list.get(list.size() - 1);// 当前最大值
if (max == sum) {// 找到等于“和”的元素,打个标记
someoneEqualSum = true;
}
if (mix + max > sum && flag) {// 删除没用的最大值
list.remove(list.size() - 1);
} else {
flag = false;
}
} while (flag);
startMath(list, sum);
if (!findon) {
System.out.println("未找到符合条件的数组");
}
}
public double[] maopao(double[] a) {
for (int i = 0; i < a.length - 1; i++) {
for (int k = 0; k < a.length - 1 - i; k++) {
if (a[k] > a[k + 1]) {
double b = a[k];
a[k] = a[k + 1];
a[k + 1] = b;
}
}
}
return a;
}
public void startMath(List list, double sum) {
if (someoneEqualSum) {// 先输出等于“和”本身的数
System.out.println("相加等于" + sum + "的数组为：");
System.out.println(sum);
System.out.println("-----------------------");
}
for (int i = 0; i <= list.size() - 2; i++) {
findNumIndex.clear();
findNumIndex.add(list.size() - 1 - i);// 记录第一个元素坐标
double indexNum = list.get(list.size() - 1 - i);// 从最大的元素开始，依次往前推
action(list, indexNum, list.size() - 1 - i, sum);
}
}
/**
* 递归方法
*
* @param list
* 被查询的数组
* @param indexsum
* 当前元素相加的和
* @param index
* 下一个元素位置
* @param sum
* 要匹配的和
*/
public void action(List list, double indexsum, int index, double sum) {
if (index == 0)
return;
if (indexsum + list.get(index - 1) > sum) {// 元素【index-1】太大了，跳到下一个元素继续遍历
action(list, indexsum, index - 1, sum);
} else if (indexsum + list.get(index - 1) < sum) {// 元素【index-1】可能符合条件，继续往下找
findNumIndex.add(index - 1);// 记录此元素坐标
indexsum = indexsum + list.get(index - 1);// 更新元素的和
action(list, indexsum, index - 1, sum);
} else if (indexsum + list.get(index - 1) == sum) {
findNumIndex.add(index - 1);
findon = true;// 告诉系统找到了
System.out.println("相加等于" + sum + "的数组为：");
for (int a : findNumIndex) {
System.out.println(list.get(a));
}
System.out.println("-----------------------");
return;
}
}
public static void main(String[] args) {
double[] a = { 1, 8.3, 43, 22, 12, 7, 65, 100, 86, 97, 14, 53, 523,
555, 265, 74, 2, 556, 76, 98, 34, 78, 33, 50, 22 };
double sum = 100;
CreateTest s = new CreateTest(a, sum);
s.start();
}
}
执行的结果：
相加等于100.0的数组为：
100.0
-----------------------
相加等于100.0的数组为：
98.0
2.0
-----------------------
相加等于100.0的数组为：
97.0
2.0
1.0
-----------------------
相加等于100.0的数组为：
86.0
14.0
-----------------------
相加等于100.0的数组为：
78.0
22.0
-----------------------
相加等于100.0的数组为：
76.0
22.0
2.0
-----------------------
相加等于100.0的数组为：
65.0
34.0
1.0
-----------------------
相加等于100.0的数组为：
50.0
43.0
7.0
-----------------------
相加等于100.0的数组为：
43.0
34.0
22.0
1.0
-----------------------
代码优点：
1. 可输出多组符合条件的集合
2. 可以输出等于sum本身的元素
3. 循环递归调用
4. 支持小数点
代码缺点：
1. 程序有一个bug：如果sum=100，数组={98,2,1,1}，输出的结果只有98+2=100。结果98+1+1=100被忽略了。
2. 穷举法暴力查找，效率差。
