CodeGuide项目中的排列算法详解：从数学原理到代码实现-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00769/article/details/148393904

CodeGuide项目中的排列算法详解：从数学原理到代码实现

CodeGuide :books: 本代码库是作者小傅哥多年从事一线互联网 Java 开发的学习历程技术汇总，旨在为大家提供一个清晰详细的学习教程，侧重点更倾向编写Java核心内容。如果本仓库能为您提供帮助，请给予支持(关注、点赞、分享)！项目地址: https://gitcode.com/gh_mirrors/code/CodeGuide

一、排列算法的数学基础

排列是组合数学中的一个基本概念，它描述了从一组元素中按特定顺序选取元素的不同方式。在实际编程中，我们经常需要处理两类排列问题：

可重复排列：元素可以重复使用，排列长度为r时，排列数为n^r
无重复排列：元素不可重复使用，排列数为n!/(n-r)!

理解这两类排列的数学原理，对于编写高效的排列生成算法至关重要。CodeGuide项目中提供了这两种排列的Java实现，让我们深入分析其实现原理。

二、可重复排列的实现解析

算法实现

public static List<List<Integer>> permutationWithRepetitions(int[] permutationOptions, int permutationLength) {
    if (permutationLength == 1) {
        List<List<Integer>> result = new ArrayList<>();
        for (int permutationOption : permutationOptions) {
            List<Integer> item = new ArrayList<>();
            item.add(permutationOption);
            result.add(item);
        }
        return result;
    }
    List<List<Integer>> permutations = new ArrayList<>();
    List<List<Integer>> smallerPermutations = permutationWithRepetitions(permutationOptions, permutationLength - 1);
    for (int currentOption : permutationOptions) {
        for (List<Integer> smallerPermutation : smallerPermutations) {
            List<Integer> permutation = new ArrayList<>();
            permutation.add(currentOption);
            permutation.addAll(smallerPermutation);
            permutations.add(permutation);
        }
    }
    return permutations;
}

算法分析

递归基：当排列长度为1时，直接返回每个元素作为单独列表
递归过程：
- 先生成n-1长度的所有排列
- 然后将每个元素添加到所有n-1排列的前面
时间复杂度：O(n^r)，其中n是元素个数，r是排列长度
空间复杂度：O(n^r)，需要存储所有排列结果

示例说明

对于输入[1,2,3]，长度为2的排列：

首先生成长度为1的排列：[1],[2],[3]
然后将每个元素(1,2,3)添加到每个小排列前面
最终得到9种排列：[1,1],[1,2],[1,3],[2,1],[2,2],[2,3],[3,1],[3,2],[3,3]

三、无重复排列的实现解析

算法实现

public static List<List<Integer>> permutationWithoutRepetitions(int[] permutationOptions) {
    if (permutationOptions.length == 1) {
        List<List<Integer>> result = new ArrayList<>();
        result.add(List.of(permutationOptions[0]));
        return result;
    }
    List<List<Integer>> permutations = new ArrayList<>();
    int[] smallerOptions = new int[permutationOptions.length - 1];
    System.arraycopy(permutationOptions, 1, smallerOptions, 0, smallerOptions.length);
    List<List<Integer>> smallerPermutations = permutationWithoutRepetitions(smallerOptions);
    int firstOption = permutationOptions[0];
    for (List<Integer> smallerPermutation : smallerPermutations) {
        for (int positionIndex = 0; positionIndex <= smallerPermutation.size(); positionIndex++) {
            List<Integer> permutationPrefix = new ArrayList<>(smallerPermutation.subList(0, positionIndex));
            List<Integer> permutationSuffix = new ArrayList<>(smallerPermutation.subList(positionIndex, smallerPermutation.size()));
            List<Integer> permutation = new ArrayList<>(permutationPrefix);
            permutation.add(firstOption);
            permutation.addAll(permutationSuffix);
            permutations.add(permutation);
        }
    }
    return permutations;
}