数据结构进阶篇，数组排列专题

最新推荐文章于 2022-09-16 09:02:01 发布

descire

最新推荐文章于 2022-09-16 09:02:01 发布

阅读量305

点赞数

文章标签：数据结构算法 leetcode java js

本文链接：https://blog.csdn.net/dai_qingyun/article/details/122795156

版权

46. 全排列

「题目：」

给定一个不含重复数字的数组 nums ，返回其所有可能的全排列。你可以按任意顺序返回答案。

「示例：」

输入：nums = [1,2,3]，输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]。

「解题思路：」

这种要求给出具体可行解的题型一般多是采用搜索回溯法。

由于是全排列，所以递归的终止条件应该是已选元素的个数等于 nums 的长度。

同时，每一个枚举的轮次中需要过滤掉当前选中的元素，所以以过滤之后的数组作为枚举过程中的状态。

时间复杂度：O(nxn!)，空间复杂度：O(n)。

const permute = function(nums) {
    const ans = [];
    const path = [];

    const backtrack = (nums) => {
        if (nums.length === 0) {
            ans.push([...path]);
            return;
        }

        for (let i = 0; i < nums.length; i++) {
            path.push(nums[i]);

            backtrack([...nums.slice(0, i), ...nums.slice(i + 1)]);

            path.pop();
        }
    }

    backtrack(nums);

    return ans;
};

通过生成新的数组来过滤选中元素的方式非常的低效，这里可以通过记录状态来优化生成新数组的时间消耗：

const permute = function(nums) {
    const ans = [];
    const path = [];

    const used = [];

    const backtrack = (count) => {
        if (count === nums.length) {
            ans.push([...path]);
            return;
        }

        for (let i = 0; i < nums.length; i++) {
            if (used[i]) {
                continue;
            }
            path.push(nums[i]);
            used[i] = true;

            backtrack(count + 1);

            path.pop();
            used[i] = false;
        }
    }

    backtrack(0);

    return ans;
};

47. 全排列 II

「题目：」

给定一个可包含重复数字的序列 nums ，按任意顺序返回所有不重复的全排列。

「示例：」

输入：nums = [1,1,2]，输出：[[1,1,2], [1,2,1], [2,1,1]]。

「解题思路：」

相比较上一题，本题 nums 是包含重复数字的，所以在枚举全排列的过程中，一定会出现重复的情况。

那么在获取结果时，通过哈希表过滤重复全排列即可：

时间复杂度：O(nxn!)，空间复杂度：O(n)。

const permuteUnique = function(nums) {
    const ans = [];
    const path = [];
    const used = [];
    const record = new Set();

    const backtrack = (count) => {
        if (count === nums.length) {
            const item = [...path];
            const key = item.toString();
            if (!record.has(key)) {
                record.add(key);
                ans.push(item);
            }
            return;
        }

        for (let i = 0; i < nums.length; i++) {

            if (used[i]) {
                continue;
            }

            path.push(nums[i]);
            used[i] = true;

            backtrack(count + 1);

            path.pop();
            used[i] = false;
        }
    }

    backtrack(0);
    return ans;
};

哈希表的方式并不能优化搜索回溯的时间复杂度，之所以出现重复全排列，是因为在相同枚举轮次选中了相同的数字。

先对 nums 进行排序预处理，这样在每个轮次中只要过滤掉相邻的重复元素，即可达到剪枝优化的效果。

const permuteUnique = function(nums) {
    const ans = [];
    const path = [];
    const used = [];

    nums.sort((a, b) => a - b);
    const backtrack = (count) => {
        if (count === nums.length) {
            return ans.push([...path]);
        }

        for (let i = 0; i < nums.length; i++) {
            if (i > 0 && nums[i] === nums[i - 1] && !used[i - 1]) {
                continue;
            }
            if (used[i]) {
                continue;
            }

            path.push(nums[i]);
            used[i] = true;

            backtrack(count + 1);

            path.pop();
            used[i] = false;
        }
    }

    backtrack(0);
    return ans;
};