15.Permutations-全排列（中等题）

最新推荐文章于 2024-08-07 08:04:59 发布

原创最新推荐文章于 2024-08-07 08:04:59 发布 · 709 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LintCode #全排列

LintCode笔记专栏收录该内容

259 篇文章

订阅专栏

本文深入探讨了全排列问题，提供两种解决方案：递归法通过固定元素递归求解，字典法则通过查找并交换元素来生成下一个排列。适用于没有重复数字的列表。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

全排列

题目

给定一个数字列表，返回其所有可能的排列。

注意事项
你可以假设没有重复数字。
样例

给出一个列表[1,2,3]，其全排列为：
挑战

使用递归和非递归分别解决。
题解

1.递归解法
首先固定第一项，然后求后面所有项的全排列，代码中第一个swap函数意思是所有元素轮流放置在begin位置上，再调用permutation函数求已固定项后面所有全排列，再次调用swap函数将已交换位置的元素还原。

class Solution {
    /**
     * @param nums: A list of integers.
     * @return: A list of permutations.
     */
    private ArrayList<List<Integer>> list = new ArrayList<List<Integer>>();

    public List<List<Integer>> permute(int[] nums) {
        permutation(nums,0,nums.length);

        return list;
    }

    private void permutation(int[] nums, int start, int end)
    {
        if (start == end)
        {
            ArrayList<Integer> arrList = new ArrayList<Integer>();
            for (int i=0;i<end;i++)
            {
                arrList.add(nums[i]);
            }
            list.add(arrList);
        }
        else
        {
            for (int j=start;j<end;j++)
            {
                swap(nums,j,start);
                permutation(nums,start+1,end);
                swap(nums,j,start);
            }
        }
    }

    private void swap(int[] nums, int i, int j)
    {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

2.字典法

算法：
a.对于排列a[1…n]，查找所第一对a[i]<a[i+1]，如没有找到则说明当前排列已不存在更大的字典排序。
b.找到a[i]之后最后一个大于a[i]的值a[j]，将a[i]与a[j]交换。
c.将区间a[i+1,n]逆序排列即可。
由于字典法只能排列出当前排列的后续所有字典排列，无法排列出之前的字典排列，所以除非当前排列是排序数组，否则结果不全，需预先进行排序。递归法无此问题。

class Solution {
    /**
     * @param nums: A list of integers.
     * @return: A list of permutations.
     */
    public List<List<Integer>> permute(int[] nums) {
        ArrayList<List<Integer>> list = new ArrayList<List<Integer>>();
        if (nums.length == 0)
        {
            list.add(new ArrayList<Integer>());
            return list;
        }
        Arrays.sort(nums);
        addList(list,nums);
        while (nextPermutation(nums))
        {
            addList(list,nums);
        }

        return list;
    }

    private void addList(ArrayList<List<Integer>> list, int[] nums)
    {
        ArrayList<Integer> arrList = new ArrayList<Integer>();
        for (int i=0;i<nums.length;i++)
        {
            arrList.add(nums[i]);
        }
        list.add(arrList);
    }

    private boolean nextPermutation(int[] arr)
    {
        int i=arr.length-2;
        boolean bFind = false;
        for(;i >= 0;i--)
        {
            if(arr[i] < arr[i + 1])
            {
                bFind = true;
                break;
            }
        }
        if (!bFind)
        {
            return false;
        }
        int j = i;
        for (int k=i+1;k<arr.length;k++)
        {
            if (arr[k] > arr[i])
            {
                j = k;
            }
        }
        swap(arr, i, j);
        reverse(arr, i+1, arr.length-1);

        return true;
    }

    private void reverse(int[] arr,int start, int end)
    {
        while (start < end)
        {
            swap(arr, start++, end--);
        }
    }

    private void swap(int[] nums, int i, int j)
    {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}