输入一个n,输出1~n之间数的全排列（n<=5）

### 回答1：
可以使用递归的方法来实现全排列。

首先，我们需要一个函数来交换两个数的位置：

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

然后，我们可以编写一个递归函数来生成全排列：

void permute(int *arr, int start, int end) {
    if (start == end) {
        // 输出当前排列
        for (int i = 0; i <= end; i++) {
            printf("%d ", arr[i]);
        }
        printf("\n");
    } else {
        // 生成所有可能的排列
        for (int i = start; i <= end; i++) {
            swap(&arr[start], &arr[i]);
            permute(arr, start + 1, end);
            swap(&arr[start], &arr[i]);
        }
    }
}

最后，我们可以在主函数中调用这个函数来生成全排列：

int main() {
    int n;
    scanf("%d", &n);
    int arr[n];
    for (int i = 0; i < n; i++) {
        arr[i] = i + 1;
    }
    permute(arr, 0, n - 1);
    return 0;
}

这个程序会输出1~n之间所有数的全排列。

### 回答2：
全排列是指从给定的n个元素中取出若干个元素按照一定的顺序排列成不同的排列。对于n个元素的全排列，其总数为n!（n的阶乘）。以下是输出1~n之间数的全排列的一个简单递归实现的过程：

1. 定义一个函数 dfs(int k) 。函数的功能是产生k~n之间数的全排列。

2. 如果 k=n，则将当前的排列输出。

3. 否则，从当前位置k开始，枚举所有可能的数，并与当前位置进行交换，得到一个新的排列。

4. 进入 dfs(k+1) ，继续产生k+1~n之间数的全排列。

5. 将交换后的数与当前位置交换回来，递归结束。

实现代码如下：

#include <iostream>
using namespace std;

int a[10]; // 存放当前排列
bool vis[10]; // 标记是否使用过
int n; // 数的个数

void dfs(int k) {
if (k > n) { // 已经遍历完n个数，输出当前排列
for (int i = 1; i <= n; ++i) {
cout << a[i] << " ";
}
cout << endl;
return;
}
for (int i = k; i <= n; ++i) { // 枚举所有可能的数，从k一直到最后一个数
if (!vis[i]) { // 当前数还没有被使用过
vis[i] = true; // 标记为已使用
swap(a[i], a[k]); // 交换位置，得到新的排列
dfs(k+1); // 递归，对剩下的数进行排列
swap(a[i], a[k]); // 交换回来
vis[i] = false; // 取消标记
}
}
}

int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
a[i] = i; // 初始排列为 1~n
vis[i] = false; // 初始化标记数组
}
dfs(1); // 从第一个位置开始排列
return 0;
}

### 回答3：
全排列是一种组合方式，在计算机 science 领域广泛应用，例如排序算法等。给定一个整数n，要求输出1~n之间所有数的全排列，这需要使用递归算法来实现。

首先，我们定义一个函数来完成全排列的递归算法。这个函数的输入参数包括一个数组a和两个整数i和n，其中a是一个数组用于存储排列的数，i是当前排列的位置，n是最大排列的位置。在递归过程中，我们将数组a中第i个位置的数和其后面所有数进行交换，然后递归调用同一个函数，i+1，直到i=n为止。最后，当i=n时，我们将数组a中的内容输出即可。

接下来，我们可以写出完整的代码实现：

def permute(a, i, n):
    if i == n:
        print(a)
    else:
        for j in range(i, n+1):
            a[i], a[j] = a[j], a[i]
            permute(a, i+1, n)
            a[i], a[j] = a[j], a[i]

在主程序中，我们读入一个n作为输入，然后初始化一个数组a包括1~n之间的数。最后，我们调用permute函数，并将数组a的起始位置和结束位置传递给函数，即：permute(a, 0, n-1)。

下面是完整的Python代码：

def permute(a, i, n):
    if i == n:
        print(a)
    else:
        for j in range(i, n+1):
            a[i], a[j] = a[j], a[i]
            permute(a, i+1, n)
            a[i], a[j] = a[j], a[i]

n = int(input("请输入一个整数n："))
a = list(range(1, n+1))
permute(a, 0, n-1)

当n为5时，上述代码的输出结果为：

[1, 2, 3, 4, 5]
[1, 2, 3, 5, 4]
[1, 2, 4, 3, 5]
[1, 2, 4, 5, 3]
[1, 2, 5, 4, 3]
[1, 2, 5, 3, 4]
[1, 3, 2, 4, 5]
[1, 3, 2, 5, 4]
[1, 3, 4, 2, 5]
[1, 3, 4, 5, 2]
[1, 3, 5, 4, 2]
[1, 3, 5, 2, 4]
[1, 4, 3, 2, 5]
[1, 4, 3, 5, 2]
[1, 4, 2, 3, 5]
[1, 4, 2, 5, 3]
[1, 4, 5, 2, 3]
[1, 4, 5, 3, 2]
[1, 5, 2, 4, 3]
[1, 5, 2, 3, 4]
[1, 5, 4, 2, 3]
[1, 5, 4, 3, 2]
[1, 5, 3, 4, 2]
[1, 5, 3, 2, 4]
[2, 1, 3, 4, 5]
[2, 1, 3, 5, 4]
[2, 1, 4, 3, 5]
[2, 1, 4, 5, 3]
[2, 1, 5, 4, 3]
[2, 1, 5, 3, 4]
[2, 3, 1, 4, 5]
[2, 3, 1, 5, 4]
[2, 3, 4, 1, 5]
[2, 3, 4, 5, 1]
[2, 3, 5, 4, 1]
[2, 3, 5, 1, 4]
[2, 4, 3, 1, 5]
[2, 4, 3, 5, 1]
[2, 4, 1, 3, 5]
[2, 4, 1, 5, 3]
[2, 4, 5, 1, 3]
[2, 4, 5, 3, 1]
[2, 5, 1, 4, 3]
[2, 5, 1, 3, 4]
[2, 5, 4, 1, 3]
[2, 5, 4, 3, 1]
[2, 5, 3, 4, 1]
[2, 5, 3, 1, 4]
[3, 2, 1, 4, 5]
[3, 2, 1, 5, 4]
[3, 2, 4, 1, 5]
[3, 2, 4, 5, 1]
[3, 2, 5, 4, 1]
[3, 2, 5, 1, 4]
[3, 1, 2, 4, 5]
[3, 1, 2, 5, 4]
[3, 1, 4, 2, 5]
[3, 1, 4, 5, 2]
[3, 1, 5, 4, 2]
[3, 1, 5, 2, 4]
[3, 4, 1, 2, 5]
[3, 4, 1, 5, 2]
[3, 4, 2, 1, 5]
[3, 4, 2, 5, 1]
[3, 4, 5, 2, 1]
[3, 4, 5, 1, 2]
[3, 5, 1, 4, 2]
[3, 5, 1, 2, 4]
[3, 5, 4, 1, 2]
[3, 5, 4, 2, 1]
[3, 5, 2, 4, 1]
[3, 5, 2, 1, 4]
[4, 2, 3, 1, 5]
[4, 2, 3, 5, 1]
[4, 2, 1, 3, 5]
[4, 2, 1, 5, 3]
[4, 2, 5, 1, 3]
[4, 2, 5, 3, 1]
[4, 3, 2, 1, 5]
[4, 3, 2, 5, 1]
[4, 3, 1, 2, 5]
[4, 3, 1, 5, 2]
[4, 3, 5, 1, 2]
[4, 3, 5, 2, 1]
[4, 1, 3, 2, 5]
[4, 1, 3, 5, 2]
[4, 1, 2, 3, 5]
[4, 1, 2, 5, 3]
[4, 1, 5, 2, 3]
[4, 1, 5, 3, 2]
[4, 5, 3, 1, 2]
[4, 5, 3, 2, 1]
[4, 5, 1, 3, 2]
[4, 5, 1, 2, 3]
[4, 5, 2, 1, 3]
[4, 5, 2, 3, 1]
[5, 2, 3, 4, 1]
[5, 2, 3, 1, 4]
[5, 2, 4, 3, 1]
[5, 2, 4, 1, 3]
[5, 2, 1, 4, 3]
[5, 2, 1, 3, 4]
[5, 3, 2, 4, 1]
[5, 3, 2, 1, 4]
[5, 3, 4, 2, 1]
[5, 3, 4, 1, 2]
[5, 3, 1, 4, 2]
[5, 3, 1, 2, 4]
[5, 4, 3, 2, 1]
[5, 4, 3, 1, 2]
[5, 4, 2, 3, 1]
[5, 4, 2, 1, 3]
[5, 4, 1, 2, 3]
[5, 4, 1, 3, 2]
[5, 1, 3, 4, 2]
[5, 1, 3, 2, 4]
[5, 1, 4, 3, 2]
[5, 1, 4, 2, 3]
[5, 1, 2, 4, 3]
[5, 1, 2, 3, 4]

可以看到，上述代码输出了所有从1到5的全排列，每个排列占用了一行。