LeetCode46 Permutations

最新推荐文章于 2025-09-08 18:09:18 发布

原创最新推荐文章于 2025-09-08 18:09:18 发布 · 211 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

leetcode 专栏收录该内容

133 篇文章

订阅专栏

本文提供了一种解决LeetCode上第46题全排列问题的有效方法。通过使用递归搜索和回溯策略，实现了对整数数组的所有可能排列进行生成。文章包含了Java、C和Python三种语言的具体实现，每种实现都附有详细的注释说明。

详细见：leetcode.com/problems/permutations

Java Solution: github

package leetcode;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

public class P046_Permutations {
	public static void main(String[] args) {
		System.out.println(new Solution().permute(new int[] {1}));
	}
	/*
	 * 	全排列
	 * 	3 ms
	 * 	70.59% 
	 */
	static class Solution {
	    List<List<Integer>> ans = new LinkedList<List<Integer>>();
		public List<List<Integer>> permute(int[] nums) {
			if (nums == null || nums.length == 0)
				return ans;
	        Arrays.sort(nums);
	        search(nums, 0);
	    	return ans;
	    }
		private void search(int[] nums, int index) {
			if (index == nums.length) {
				List<Integer> answer = new LinkedList<Integer>();
				for (int i = 0; i != nums.length; i ++)
					answer.add(nums[i]);
				ans.add(answer);
			} else {
				for (int i = index; i < nums.length; i ++) {
					swap(nums, index, i);
					search(nums, index + 1);
					swap(nums, index, i);
				}
			}
		}
		private void swap(int[] nums, int i, int j) {
			int temp = nums[i];
			nums[i] = nums[j];
			nums[j] = temp;
		}
	}
}

C Solution: github

/*
    url: leetcode.com/problems/permutations/
    AC 9ms 20.00%
*/


#include <stdio.h>
#include <stdlib.h>

int* arr_copy_of(int* n, int ns) {
    int* ans = (int*) malloc(sizeof(int) * ns);
    int i = 0;
    for (i = 0; i < ns; i ++)
        ans[i] = n[i];
    return ans;
}

void swap(int* a, int* b) {
    int t = *a;
    *a = *b;
    *b = t;
}

void search(int** ans, int* ansIndex, int* n, int ni, int ns) {
    int i = 0;
    if (ni == ns) {
        ans[(*ansIndex) ++] = arr_copy_of(n, ns);
        return;
    }
    for (i = ni; i < ns; i ++) {
        swap(n+i, n+ni);
        search(ans, ansIndex, n, ni+1, ns);
        swap(n+i, n+ni);
    }
}

int** permute(int* n, int s, int* rs) {
    int len = 1, i = 0, ** ans = NULL, ansIndex = 0;
    for (i = s; i > 1; i --) len *= i;
    ans = (int**) malloc(sizeof(int*) * len);
    search(ans, &ansIndex, n, 0, s);
    *rs = len;
    return ans;
}

int main() {
    int n[] = {1, 2, 3};
    int s = 3;
    int rs = 0;
    int** ans = permute(n, s, &rs);
    int i = 0, j = 0;
    for (i = 0; i < rs; i ++) {
        for (j = 0; j < s; j ++)
            printf("%d ", ans[i][j]);
        printf("\r\n");
        free(*(ans+i));
    }
    free(ans);    
}

Python Solution: github

#coding=utf-8

'''
    url: leetcode.com/problems/permutations
    @author:     zxwtry
    @email:      zxwtry@qq.com
    @date:       2017年4月8日
    @details:    Solution: 89ms 33.38%
'''

class Solution(object):
    def swap(self, n, i, j):
        t = n[i]
        n[i] = n[j]
        n[j] = t
        
    def search(self, n, ans, i, nn):
        if i == nn:
            ans.append(list(n))
        for j in range(i, nn):
            self.swap(n, i, j)
            self.search(n, ans, i+1, nn)
            self.swap(n, i, j)
        
    def permute(self, n):
        """
        :type n: List[int]
        :rtype: List[List[int]]
        """
        nn, ans = 0 if n == None else len(n), []
        if nn == 0: return ans
        self.search(n, ans, 0, nn);
        return ans

if __name__ == "__main__":
    n = [1,2,3]
    ans = Solution().permute(n)
    print(ans)