【算法】解题总结：剑指Offer 41 和为S的连续正数序列、剑指Offer 40 数组中只出现一次的两个数字

JZ41 和为S的连续正数序列

（中等）

题目

描述
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!


返回值描述：
输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序

示例
输入：
9
返回值：
[[2,3,4],[4,5]]

思路

1 暴力穷举（前缀和法）

（注：我开始还以为我这种算法算是暴力解法，但是看了官方的题解后，发现还有更无脑暴力的方法，时间复杂度都三次方了，至于我这个时间复杂度为二次方的算法，竟然是叫做前缀和法，看来是我还不够暴力吧）

我在做的时候，首先用的是暴力穷举的方法，这种方法思路简单，不过就是效率太低了，这种方法倒是适合做题前来热身，便于更好地理解题意。

暴力穷举的思路也十分简易，从 1 开始，向后找若干个数，若它们的和与所传入的和相等，则将这串连续的数放入 ArrayList 中，之后，再从 2 开始，向后…，同上思路，以此类推，再从 n 开始，最后，再将若干个动态数组，再合并到一个大的二维动态数组中即可，关于其他注意事项就是编写时注意临界范围即可。

【实现】

public class JZ41和为S的连续正数序列 {
    public ArrayList<ArrayList<Integer>> FindContinuousSequence(int sum) {
        if (sum < 0) {
            return null;
        }

        ArrayList<ArrayList<Integer>> deepList = new ArrayList<ArrayList<Integer>>();
        int inSum = 0;
        int endIndex = 0;
        int i = 0, j = 0;
        for (i = 1; i <= sum / 2; i++) {
            inSum = i;
            for (j = i + 1; inSum < sum; j++) {
                inSum += j;
            }

            if (inSum == sum) {
                ArrayList<Integer> list = new ArrayList<Integer>();
                endIndex = --j;
                for (int k = i; k <= endIndex; k++) {
                    list.add(k);
                }
                deepList.add(list);
            }
        }
        return deepList;
    }

    public static void main(String[] args) {
        JZ41和为S的连续正数序列 s = new JZ41和为S的连续正数序列();
        s.FindContinuousSequence(9);
    }
}

2 滑动窗口

此方法十分巧妙，“滑动窗口”更是十分形象的名字，实现起来也十分通俗易懂，在计算机网络中也有应用，例如滑动窗口协议，也就是通常所说的连续ARQ协议，发送窗口和接收窗口的变动，也是类似的思路和动作，用此思路实现此题的具体方法由于时间原因也不再自己写了，下面给出官方的思路图解，十分清楚：

（此方法链接）

【C++实现】

class Solution {
public:
    vector<vector<int> > FindContinuousSequence(int sum) {
        vector<vector<int>> ret;
        int l = 1, r = 1;
        int tmp = 0;
        while (l <= sum / 2) {
            if (tmp < sum) {
                tmp += r;
                ++r;
            }
            else if (tmp > sum) {
                tmp -= l;
                ++l;
            }
            else {
                vector<int> ans;
                for (int k=l; k<r; ++k) 
                    ans.push_back(k);
                ret.push_back(ans);
                tmp -= l;
                ++l;
            }
        }
        return ret;
    }
};

JZ40 数组中只出现一次的两个数字

（中等）

题目

描述
一个整型数组里除了两个数字只出现一次，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

示例
输入：
[1,4,1,6]
返回值：
[4,6]
说明：
返回的结果中较小的数排在前面

思路

1 暴力解法

求数组中只出现一个的数，两层循环即可实现，过于基础，不再赘述，具体细节看代码：

【实现】

public class JZ40数组中只出现一次的两个数字 {
    public int[] FindNumsAppearOnce (int[] array) {
        if (array == null || array.length < 2) {
            return null;
        }

        int len = array.length;
        boolean flag = true;
        int[] res = new int[2];
        int k = 0;
        for (int i = 0; i < len; i++) {
            flag = true;
            for (int j = 0; j < len; j++) {
                if (i == j) {
                    continue;
                }
                if (array[i] == array[j]) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                res[k++] = array[i];
            }
        }

        if (res[0] > res[1]) {
            int tmp = res[0];
            res[0] = res[1];
            res[1] = tmp;
        }

        return res;
    }
}

2 哈希法

将数组的所有元素读入 HashMap 中，并记录下出现的次数，最终再遍历一遍 HashMap ，找出出现次数为 1 的元素即可。

【实现】

public class JZ40数组中只出现一次的两个数字 {
    public int[] FindNumsAppearOnce (int[] array) {
        if (array == null || array.length < 2) {
            return null;
        }
        
        Map<Integer, Integer> map = new HashMap();
        int[] res = new int[2];
        int k = 0;
        for (int x : array) {
            if (!map.containsKey(x)) { //不存在当前数
                map.put(x, 1);
            } else { //存在当前数
                map.put(x, 2);
            }
        }

        Iterator<Integer> iterator = map.keySet().iterator();
        while (iterator.hasNext()) {
            int key = iterator.next();
            if (map.get(key) == 1) {
                res[k++] = key;
            }
        }

		if (res[0] > res[1]) {
            int tmp = res[0];
            res[0] = res[1];
            res[1] = tmp;
        }

        return res;
    }
}

3 异或法

（下图解法的链接）

发现这种方法的执行速度也不见得有什么突破性的提升（如果有，可能也是测试数据不够多面），因此，我也不打算现在研究了，等以后二刷的时候再看吧。