递归算法之组合生成（Combinations）详细解读

Katie。

于 2024-10-24 08:00:00 发布

阅读量1k

点赞数 19

分类专栏：算法分析文章标签：算法

本文链接：https://blog.csdn.net/m0_61840987/article/details/143138856

版权

算法分析专栏收录该内容

87 篇文章

订阅专栏

组合生成（Combinations）是排列组合问题中的一种，它是指从给定的 n 个元素中，选出 k 个元素的所有可能组合，而不考虑顺序。与全排列不同的是，组合生成不关心选出的元素顺序。

组合问题广泛应用于组合数学、统计学、计算机科学等领域。例如，给定一个集合 {1,2,3,4}，生成所有从中选取 2 个元素的组合，结果为：

1. 组合的定义

给定一个包含 n 个元素的集合，从中选择 k 个元素的所有可能子集称为组合。组合的数量不考虑元素的顺序。组合的数量公式为：

它表示从 n 个元素中不考虑顺序选取 k 个元素的方法数。

2. 递归生成组合的思路

递归生成组合的核心思想是：从给定集合中递归选择元素，逐步构建组合。递归的过程中，我们在每一层递归中有两个选择：要么选择当前元素并递归生成剩下的组合，要么不选择当前元素，递归生成其他组合。

递归生成组合的步骤：

设当前在第 start 个元素处，选择该元素或者不选择该元素。
如果选择当前元素，则将其加入当前组合，并递归选择后续的元素。
如果不选择当前元素，则直接递归处理后续的元素。
当组合的大小达到 k 时，将该组合加入结果集。

递归实现 Java 代码

import java.util.ArrayList;
import java.util.List;

public class Combinations {
    
    // 主方法，生成并返回所有从 n 个元素中选出 k 个的组合
    public static List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> combination = new ArrayList<>();
        backtrack(result, combination, 1, n, k);
        return result;
    }
    
    // 回溯法生成组合
    private static void backtrack(List<List<Integer>> result, List<Integer> combination, int start, int n, int k) {
        // 当组合的大小等于 k 时，表示找到一个合法组合，将其加入结果集
        if (combination.size() == k) {
            result.add(new ArrayList<>(combination));
            return;
        }
        
        // 从当前起始位置开始，依次选择元素加入组合
        for (int i = start; i <= n; i++) {
            combination.add(i);           // 选择当前元素 i
            backtrack(result, combination, i + 1, n, k); // 递归选择下一个元素
            combination.remove(combination.size() - 1);  // 回溯，撤销选择
        }
    }
    
    public static void main(String[] args) {
        int n = 4, k = 2;
        List<List<Integer>> combinations = combine(n, k);
        for (List<Integer> combination : combinations) {
            System.out.println(combination);
        }
    }
}

代码详解：

combine 方法用于生成所有从 1 到 n 的元素中选择 k 个元素的组合。它调用 backtrack 递归生成组合。
backtrack 是核心的递归函数，其中 start 参数表示当前处理的元素起始位置，combination 表示当前正在构建的组合，n 是集合的大小，k 是要生成的组合长度。
回溯法：每当组合长度达到 k 时，将该组合加入结果集。在每一步递归中，先选择当前元素，递归处理接下来的元素，然后撤销选择进行回溯。

递归算法的时间复杂度：

生成 C(n,k) 种组合，每次生成一组组合的时间复杂度为 O(k)，因此总的时间复杂度为

O(k \times C(n, k))。

3. 组合的非递归生成方法

3.1 字典序生成组合

字典序生成组合是一种基于迭代的生成方法。假设组合可以表示为一个递增的整数序列 [a1,a2,…,ak]，其中 1≤a1<a2<⋯<ak≤n。从最小的组合开始（即 [1,2,…,k]），然后逐步生成下一个组合，直到生成所有的组合。

字典序生成组合的步骤：

初始化组合为 [1,2,…,k]。
找到组合中可以增大的元素，将其增大并调整其后续元素为递增的最小值。
重复上述步骤直到无法生成新的组合。

字典序法 Java 实现

import java.util.ArrayList;
import java.util.List;

public class IterativeCombinations {
    
    // 使用字典序法生成组合
    public static List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> result = new ArrayList<>();
        int[] combination = new int[k];
        
        // 初始化第一个组合为 [1, 2, ..., k]
        for (int i = 0; i < k; i++) {
            combination[i] = i + 1;
        }
        
        while (true) {
            // 将当前组合加入结果集
            List<Integer> currentCombination = new ArrayList<>();
            for (int num : combination) {
                currentCombination.add(num);
            }
            result.add(currentCombination);
            
            // 找到可以增加的第一个元素
            int i;
            for (i = k - 1; i >= 0; i--) {
                if (combination[i] != n - k + i + 1) {
                    break;
                }
            }
            
            // 如果所有元素都不能增加，退出循环
            if (i < 0) {
                break;
            }
            
            // 增加元素并调整后续元素
            combination[i]++;
            for (int j = i + 1; j < k; j++) {
                combination[j] = combination[j - 1] + 1;
            }
        }
        
        return result;
    }

    public static void main(String[] args) {
        int n = 4, k = 2;
        List<List<Integer>> combinations = combine(n, k);
        for (List<Integer> combination : combinations) {
            System.out.println(combination);
        }
    }
}