深度遍历实现数字序列全排列（没有重复）

最新推荐文章于 2025-03-05 09:59:08 发布

原创最新推荐文章于 2025-03-05 09:59:08 发布 · 481 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#DFS

数据结构与算法专栏收录该内容

30 篇文章

订阅专栏

本文介绍了一种使用深度优先遍历算法遍历由数字构建的矩阵的方法。通过构建n*n大小的矩阵并利用深度优先遍历进行元素访问，确保了每个元素仅被访问一次。文章详细解释了如何通过矩阵进行遍历，并提供了具体的代码实现。

参考图的深度优先遍历：先用 n 个数字构建出 n * n 大小的矩阵，然后通过矩阵进行深度遍历

通过判断子集中是否包含某一元素，来判断一个元素是否isVisited

public class Solution {
       public static void main(String[] args) {
        int[] nums = new int[]{1, 2, 3};
        System.out.println(permuteUnique(nums));
    }

    public static List<List<Integer>> permuteUnique(int[] nums) {
        int n = nums.length;
        int[][] matrix = new int[n][n];
        for (int i = 0; i < matrix.length; i++) {
            for (int j = i + 1; j < matrix.length; j++) {
                matrix[i][j] = 1;
                matrix[j][i] = 1;
            }
        }

        List<List<Integer>> res = new ArrayList<>();

        for (int i = 0; i < matrix.length; i++) {
            ArrayList<Integer> subRes = new ArrayList<>();
            dfs(matrix, nums, i, subRes, res);
        }

        return res;
    }

	//图矩阵的层次遍历
    public static void dfs(int[][] matrix, int[] nums, int index,
                           ArrayList<Integer> subRes, List<List<Integer>> res) {

        subRes.add(nums[index]);
        int vertexIndex = getFirstNeighbor(matrix, index);

        while (vertexIndex != -1) {
            System.out.println(vertexIndex);
            if (!subRes.contains(nums[vertexIndex])) {
                dfs(matrix, nums, vertexIndex, subRes, res);
                int lastIndex = subRes.size() - 1;
                subRes.remove(lastIndex);
            }
            vertexIndex = getNextNeighbor(matrix, index, vertexIndex);
        }

        if (subRes.size() == matrix.length) {
            ArrayList<Integer> temp = new ArrayList<>();
            for (Integer item : subRes) {
                temp.add(item);
            }
            res.add(temp);
        }

    }
   
    //得到第一个邻接结点的下标 vertexIndex
    public static int getFirstNeighbor(int[][] matrix, int index) {
        for (int i = 0; i < matrix.length; i++) {
            if (matrix[index][i] > 0)
                return i;
        }
        return -1;
    }

	//根据前一个邻接结点的下标来获取下一个邻接结点
    public static int getNextNeighbor(int[][] matrix, int index, int firstNeighbor) {
        for (int i = firstNeighbor + 1; i < matrix.length; i++) {
            if (matrix[index][i] > 0)
                return i;
        }
        return -1;
    }

}