问题描述：求一个正整数是哪几个正整数相加的和 (这些数要各不相同)

说明：给定一个正整数，如8，要求输出以下数组，因为他们的和为8：

[1, 2, 5]

[1, 3, 4]

[1, 7]

[2, 6]

[3, 5]

[8]

 

代码是一个牛人写的，我只是加了几个语句来输出程序具体的执行过程：

package com.joe;

import java.util.LinkedList;

public class T
{
 static LinkedList<Integer> list = new LinkedList<Integer>();

    public static void split(int n, int base)
    {
        if (n == 0)
        {
            System.out.println("找到一个组合：" + list);
            System.out.println();
            return;
        }
        for (int i = base + 1; i <= n; i++)
        {       
            list.addLast(i);
            System.out.println("添加" + i + ", 当前list = " + list + ", 进入递归调用split(" + (n-i) + ", " + i + ")");
            split(n - i, i); // n-i 实际上是把之前所添加进list的数都减掉，等于0时说明list中的数加起来刚好等于n
            System.out.print("当前list = " + list + ", 删除最后一个元素：");
            int delNum = list.removeLast(); // 从下层递归返回才会执行这句，最后一个添加的数不符合要求
            System.out.print(delNum);
            System.out.println("。返回到上层递归中的for循环，此时list = " + list + "，i=" + i + ", 执行i++后判断i<=" + n + ",再继续。");
        }
    }

 public static void main(String[] args)
 {
  split(8, 0);
 }

}

 

运行结果：

添加1, 当前list = [1], 进入递归调用split(7, 1)
添加2, 当前list = [1, 2], 进入递归调用split(5, 2)
添加3, 当前list = [1, 2, 3], 进入递归调用split(2, 3)
当前list = [1, 2, 3], 删除最后一个元素：3。返回到上层递归中的for循环，此时list = [1, 2]，i=3, 执行i++后判断i<=5,再继续。
添加4, 当前list = [1, 2, 4], 进入递归调用split(1, 4)
当前list = [1, 2, 4], 删除最后一个元素：4。返回到上层递归中的for循环，此时list = [1, 2]，i=4, 执行i++后判断i<=5,再继续。
添加5, 当前list = [1, 2, 5], 进入递归调用split(0, 5)
找到一个组合：[1, 2, 5]

当前list = [1, 2, 5], 删除最后一个元素：5。返回到上层递归中的for循环，此时list = [1, 2]，i=5, 执行i++后判断i<=5,再继续。
当前list = [1, 2], 删除最后一个元素：2。返回到上层递归中的for循环，此时list = [1]，i=2, 执行i++后判断i<=7,再继续。
添加3, 当前list = [1, 3], 进入递归调用split(4, 3)
添加4, 当前list = [1, 3, 4], 进入递归调用split(0, 4)
找到一个组合：[1, 3, 4]

当前list = [1, 3, 4], 删除最后一个元素：4。返回到上层递归中的for循环，此时list = [1, 3]，i=4, 执行i++后判断i<=4,再继续。
当前list = [1, 3], 删除最后一个元素：3。返回到上层递归中的for循环，此时list = [1]，i=3, 执行i++后判断i<=7,再继续。
添加4, 当前list = [1, 4], 进入递归调用split(3, 4)
当前list = [1, 4], 删除最后一个元素：4。返回到上层递归中的for循环，此时list = [1]，i=4, 执行i++后判断i<=7,再继续。
添加5, 当前list = [1, 5], 进入递归调用split(2, 5)
当前list = [1, 5], 删除最后一个元素：5。返回到上层递归中的for循环，此时list = [1]，i=5, 执行i++后判断i<=7,再继续。
添加6, 当前list = [1, 6], 进入递归调用split(1, 6)
当前list = [1, 6], 删除最后一个元素：6。返回到上层递归中的for循环，此时list = [1]，i=6, 执行i++后判断i<=7,再继续。
添加7, 当前list = [1, 7], 进入递归调用split(0, 7)
找到一个组合：[1, 7]

当前list = [1, 7], 删除最后一个元素：7。返回到上层递归中的for循环，此时list = [1]，i=7, 执行i++后判断i<=7,再继续。
当前list = [1], 删除最后一个元素：1。返回到上层递归中的for循环，此时list = []，i=1, 执行i++后判断i<=8,再继续。
添加2, 当前list = [2], 进入递归调用split(6, 2)
添加3, 当前list = [2, 3], 进入递归调用split(3, 3)
当前list = [2, 3], 删除最后一个元素：3。返回到上层递归中的for循环，此时list = [2]，i=3, 执行i++后判断i<=6,再继续。
添加4, 当前list = [2, 4], 进入递归调用split(2, 4)
当前list = [2, 4], 删除最后一个元素：4。返回到上层递归中的for循环，此时list = [2]，i=4, 执行i++后判断i<=6,再继续。
添加5, 当前list = [2, 5], 进入递归调用split(1, 5)
当前list = [2, 5], 删除最后一个元素：5。返回到上层递归中的for循环，此时list = [2]，i=5, 执行i++后判断i<=6,再继续。
添加6, 当前list = [2, 6], 进入递归调用split(0, 6)
找到一个组合：[2, 6]

当前list = [2, 6], 删除最后一个元素：6。返回到上层递归中的for循环，此时list = [2]，i=6, 执行i++后判断i<=6,再继续。
当前list = [2], 删除最后一个元素：2。返回到上层递归中的for循环，此时list = []，i=2, 执行i++后判断i<=8,再继续。
添加3, 当前list = [3], 进入递归调用split(5, 3)
添加4, 当前list = [3, 4], 进入递归调用split(1, 4)
当前list = [3, 4], 删除最后一个元素：4。返回到上层递归中的for循环，此时list = [3]，i=4, 执行i++后判断i<=5,再继续。
添加5, 当前list = [3, 5], 进入递归调用split(0, 5)
找到一个组合：[3, 5]

当前list = [3, 5], 删除最后一个元素：5。返回到上层递归中的for循环，此时list = [3]，i=5, 执行i++后判断i<=5,再继续。
当前list = [3], 删除最后一个元素：3。返回到上层递归中的for循环，此时list = []，i=3, 执行i++后判断i<=8,再继续。
添加4, 当前list = [4], 进入递归调用split(4, 4)
当前list = [4], 删除最后一个元素：4。返回到上层递归中的for循环，此时list = []，i=4, 执行i++后判断i<=8,再继续。
添加5, 当前list = [5], 进入递归调用split(3, 5)
当前list = [5], 删除最后一个元素：5。返回到上层递归中的for循环，此时list = []，i=5, 执行i++后判断i<=8,再继续。
添加6, 当前list = [6], 进入递归调用split(2, 6)
当前list = [6], 删除最后一个元素：6。返回到上层递归中的for循环，此时list = []，i=6, 执行i++后判断i<=8,再继续。
添加7, 当前list = [7], 进入递归调用split(1, 7)
当前list = [7], 删除最后一个元素：7。返回到上层递归中的for循环，此时list = []，i=7, 执行i++后判断i<=8,再继续。
添加8, 当前list = [8], 进入递归调用split(0, 8)
找到一个组合：[8]

当前list = [8], 删除最后一个元素：8。返回到上层递归中的for循环，此时list = []，i=8, 执行i++后判断i<=8,再继续。