2024年最全【算法】剑指 Offer II 083(3)，实战解析-CSDN博客

本文链接：https://blog.csdn.net/2401_84904581/article/details/138711909

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

使用交换的方式

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
		backtrack(nums, 0, ans);
		return ans;
	}

	private void backtrack(int[] nums, int cur, List<List<Integer>> ans) {
		if (cur == nums.length) {
			ans.add(Arrays.stream(nums).boxed().collect(Collectors.toList()));
			return;
		}
		// 当前位置保持不变，接着排下一个
		backtrack(nums, cur + 1, ans);
		// 换后面的某一个到当前位置
		for (int i = cur + 1; i < nums.length; ++i) {
			swap(nums, cur, i);
			backtrack(nums, cur + 1, ans);
			swap(nums, cur, i);
		}
	}

	private void swap(int[] nums, int a, int b) {
		nums[a] ^= nums[b];
		nums[b] ^= nums[a];
		nums[a] ^= nums[b];
	}
}

c

/\*\*
 \* Return an array of arrays of size \*returnSize.
 \* The sizes of the arrays are returned as \*returnColumnSizes array.
 \* Note: Both returned array and \*columnSizes array must be malloced, assume caller calls free().
 \*/
int\*\* permute(int\* nums, int numsSize, int\* returnSize, int\*\* returnColumnSizes){
    \*returnSize = numsSize;
    for (int i = 2; i < numsSize; ++i) {
        \*returnSize \*= i;
    }

    int \*\*ans = (int \*\*) malloc(sizeof(int \*) \* (\*returnSize));
    \*returnColumnSizes = (int \*) malloc(sizeof(int) \* (\*returnSize));
    for (int i = 0; i < \*returnSize; ++i) {
        ans[i] = (int \*) malloc(sizeof(int) \* numsSize);
        (\*returnColumnSizes)[i] = numsSize;
    }

    int ansSize = 0;

    backtrack(nums, numsSize, 0, ans, &ansSize);

    return ans;
}

void backtrack(int\* nums, int numsSize, int cur, int \*\*ans, int \*ansSize) {
    if (cur == numsSize) {
        for (int i = 0; i < numsSize; ++i) {
            ans[\*ansSize][i] = nums[i];
        }
        \*ansSize += 1;
        return;
    }
    // 当前位置保持不变，接着排下一个
    backtrack(nums, numsSize, cur + 1, ans, ansSize);
    // 换后面的某一个到当前位置
    for (int i = cur + 1; i < numsSize; ++i) {
        swap(nums, cur, i);
        backtrack(nums, numsSize, cur + 1, ans, ansSize);
        swap(nums, cur, i);
    }
}

void swap(int\* nums, int a, int b) {
    nums[a] ^= nums[b];
    nums[b] ^= nums[a];
    nums[a] ^= nums[b];
}

c++

class Solution {
private:
    void backtrack(vector<int> &nums, int cur, vector<vector<int>> &ans) {
        if (cur == nums.size()) {
            ans.push\_back(nums);
            return;
        }
        // 当前位置保持不变，接着排下一个
        backtrack(nums, cur + 1, ans);
        // 换后面的某一个到当前位置
        for (int i = cur + 1; i < nums.size(); ++i) {
            swap(nums[cur], nums[i]);
            backtrack(nums, cur + 1, ans);
            swap(nums[cur], nums[i]);
        }
    }
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> ans;

        backtrack(nums, 0, ans);

        return ans;
    }
};

python

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        n = len(nums)
        ans = []

        def backtrack(cur: int) -> None:
            if cur == n:
                ans.append(nums[:])
                return
            # 当前位置保持不变，接着排下一个
            backtrack(cur + 1)
            # 换后面的某一个到当前位置
            for i in range(cur + 1, n):
                nums[cur], nums[i] = nums[i], nums[cur]
                backtrack(cur + 1)
                nums[cur], nums[i] = nums[i], nums[cur]

        backtrack(0)
        return ans

go

func permute(nums []int) [][]int {
    n := len(nums)
	var ans [][]int

	var backtrack func(cur int)
	backtrack = func(cur int) {
		if cur == n {
			ans = append(ans, append([]int{}, nums...))
			return
		}
		// 当前位置保持不变，接着排下一个
		backtrack(cur + 1)
		// 换后面的某一个到当前位置
		for i := cur + 1; i < n; i++ {
			nums[cur], nums[i] = nums[i], nums[cur]
			backtrack(cur + 1)
			nums[cur], nums[i] = nums[i], nums[cur]
		}
	}

	backtrack(0)

	return ans
}

rust

impl Solution {
    pub fn permute(mut nums: Vec<i32>) -> Vec<Vec<i32>> {
        let mut ans = Vec::new();

        Solution::backtrack(&mut nums, 0, &mut ans);

        ans
    }

    fn backtrack(nums: &mut Vec<i32>, cur: usize, ans: &mut Vec<Vec<i32>>) {
        if cur == nums.len() {
            ans.push(nums.clone());
            return;
        }
        // 当前位置保持不变，接着排下一个
        Solution::backtrack(nums, cur + 1, ans);
        // 换后面的某一个到当前位置
        (cur + 1..nums.len()).for\_each(|i| {
            nums.swap(cur, i);
            Solution::backtrack(nums, cur + 1, ans);
            nums.swap(cur, i);
        });
    }
}

在这里插入图片描述