LeetCode 46. Permutations-优快云博客

本文链接：https://blog.youkuaiyun.com/emoheithree/article/details/78590748

本文提供LeetCode第46题“全排列”的两种解题思路及代码实现。一种是利用链表进行元素的选择与回溯，另一种是通过交换元素的方式实现全排列。

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

LeetCode 46. Permutations

Given a collection of distinct numbers,return all possible permutations.

For example,

[1,2,3] have the following permutations:

[

[1,2,3],

[1,3,2],

[2,1,3],

[2,3,1],

[3,1,2],

[3,2,1]

]

思路一：通过遍历线性表每次选择一个元素将其加入链表，删除该元素并递归执行，当线性表中没有元素是结束递归。

public class Node{
                   intval;
                   Nodenext;
                   publicNode(int val){
                            this.val= val;
                   }
         }
public voiddfs(List<List<Integer>> res, Node head, List<Integer> ans){
             if(head.next==null) {res.add(newArrayList<Integer>(ans)); return;}
             Node p = head, q=head.next;
 
             while(q!=null){
                       ans.add(q.val);
                       p.next = q.next;
                       dfs(res,head,ans);
                       ans.remove(ans.size()-1);
                       p.next = q;
                       p = p.next; q= q.next;
             }
}

完整代码：

class Solution {
         publicclass Node{
                   intval;
                   Nodenext;
                   publicNode(int val){
                            this.val= val;
                   }
         }
   public List<List<Integer>> permute(int[] nums) {
       List<List<Integer>> res = newArrayList<List<Integer>>();
       if(nums.length == 0) return res;
       Arrays.sort(nums);
 
        Node head= new Node(0);
       Node p=head;
       for(int i=0;i<nums.length;i++){
                Node tmp=newNode(nums[i]);
                p.next = tmp;
                p = p.next;
       }
       dfs(res,head,new ArrayList<Integer>());
       return res;
    }
    public voiddfs(List<List<Integer>> res, Node head, List<Integer> ans){
             if(head.next==null) {res.add(newArrayList<Integer>(ans)); return;}
             Node p = head, q=head.next;
 
             while(q!=null){
                       ans.add(q.val);
                       p.next = q.next;
                       dfs(res,head,ans);
                       ans.remove(ans.size()-1);
                       p.next = q;
                       p = p.next; q= q.next;
             }
    }
}

思路二：通过每次交换当前元素i 与 i+k元素递归调用：

private void backtrack(int[]nums,List<List<Integer>> result,List<Integer> res,int index)
    {
       if(index==nums.length)
       {
            result.add(newArrayList<Integer>(res));
           return;
       }
       
       for(int i=index;i<nums.length;i++)
       {
           swap(nums,index,i);
           res.add(nums[index]);
           backtrack(nums,result,res,index+1);
           res.remove(res.size()-1);
           swap(nums,index,i);
       }
}

完整代码：

class Solution {
   public List<List<Integer>> permute(int[] nums) {
       
       List<List<Integer>> result = new ArrayList<>();
       List<Integer> res = new ArrayList<>();
       
       if(nums!=null && nums.length>0)
           backtrack(nums,result,res,0);
       
       return result;
       
    }
   
   private void backtrack(int[] nums,List<List<Integer>>result,List<Integer> res,int index)
    {
       if(index==nums.length)
       {
           result.add(new ArrayList<Integer>(res));
           return;
       }
       
       for(int i=index;i<nums.length;i++)
       {
           swap(nums,index,i);
           res.add(nums[index]);
            backtrack(nums,result,res,index+1);
           res.remove(res.size()-1);
           swap(nums,index,i);
       }
    }
   
   private void swap(int[] nums,int i,int j)
    {
       int tmp = nums[i];
       nums[i]=nums[j];
       nums[j]=tmp;
    }
}