以下是几种不同
语言实现
数组全排列的函数：
###
JavaScript 实现
#### 方法一
```
javascript
var arr = [1, 2, 3];
// swap用来交换
数组a中的两个
元素
function swap(arr, p, q) {
[arr[p], arr[q]] = [arr[q], arr[p]];
}
//
全排列函数pai，在
数组arr中，对p位置到q位置之间的
元素进行
全排列
function pai(arr, p, q) {
if (p == q) {
console.log(arr); //
一个数的
全排列就是自己，
输出自己
} else {
for (let i = p; i < q; i++) {
swap(arr, i, p); // 把 arr 中的每个
元素都作一次头
元素
pai(arr, p + 1, q); // 对头
元素后的数据再次递归实现
全排列
swap(arr, i, p); // 排完之后要换回来，防止重复排列
}
}
}
pai(arr, 0, arr.length);
```
此代码通过递归和交换
元素的方式，将
数组的每个
元素依次作为头
元素，对剩余
元素进行
全排列，最后恢复
元素位置以避免重复排列[^1]。
#### 方法二
```
javascript
function fullpermutate(args) {
let result = [];
let len = args.length;
if (len > 1) {
// 遍历每一项
for (let i = 0; i < len; i++) {
// 拿到当前的
元素
let left = args[i];
// 除了当前
元素的其他
元素组合(分为字符串和
数组两种不同情况)
let rest = null;
if (typeof args == 'string') {
rest = args.slice(0, i) + args.slice(i + 1, len);
} else {
rest = args.filter(item => item != args[i]);
}
// 上一次递归返回的
全排列
let preResult = fullpermutate(rest);
let preLen = preResult.length;
// 组合在一起
for (let j = 0; j < preLen; j++) {
let temp = null;
if (typeof args == 'string') {
temp = left + preResult[j];
result.push(temp);
} else {
temp = [left].concat(preResult[j]);
result.push(temp);
}
}
}
} else if (len == 1) {
result.push(args);
}
return result;
}
```
该函数通过递归的方式，遍历
数组的每个
元素，将其与剩余
元素的
全排列组合起来，最终得到整个
数组的
全排列[^2]。
#### 方法三
```
javascript
var permArr = [], usedChars = [];
function permute(input) {
var i, ch;
for (i = 0; i < input.length; i++) {
ch = input.splice(i, 1)[0];
usedChars.push(ch);
if (input.length == 0) {
permArr.push(usedChars.slice());
}
permute(input);
input.splice(i, 0, ch);
usedChars.pop();
}
return permArr;
}
console.log(permute([5, 3, 7, 1]));
```
此代码使用了递归和回溯的思想，通过不断地取出
元素和恢复
元素，生成
数组的
全排列[^5]。
### C++ 实现
#### 方法一
```cpp
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int main() {
int a[3] = {2, 3, 1};
sort(a, a + 3);
do {
for (int i = 0; i < 3; i++)
cout << a[i] << " ";
cout << endl;
} while (next_permutation(a, a + 3));
}
```
该代码使用了`next_permutation`函数，它会生成
数组的下
一个字典序排列，通过循环不断调用该函数，
输出数组的
全排列，且不会产生重复的排列[^3]。
#### 方法二
```cpp
#include <iostream>
using namespace std;
int n = 0;
template <class T>
void Swap(T *a, T *b) {
T temp = *a;
*a = *b;
*b = temp;
}
template <class T>
void Perm(T A[], int k, int m) {
if (k > m) {
for (int i = 0; i <= m; i++) {
cout << A[i] << " ";
}
n++;
cout << endl;
} else {
for (int i = k; i <= m; i++) {
Swap(&A[k], &A[i]);
Perm(A, k + 1, m);
Swap(&A[k], &A[i]);
}
}
}
int main() {
char A[4] = {'a', 'b', 'c', 'd'};
Perm(A, 0, 3);
cout << "Total number is: " << n << endl;
return 0;
}
```
此代码通过递归和交换
元素的方式，生成
数组的
全排列，并统计排列的总数[^4]。
扫一扫
357
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
