分别求4的幂集和全排列，要求都输出显示。（可以做n的幂集和全排列）

在数学和计算机科学中，幂集是指集合的所有子集构成的新集合，包括空集和原集合本身。而全排列则是指从给定元素中所有可能的不同有序组合。

对于整数4的幂集，我们可以通过递归的方式来列举所有的子集：

{ }, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}, {4}

这里省略了大括号表示集合，仅列出元素。共有8个子集，因为4的二进制表示有三位，每一位对应一个子集。

全排列（Permutations）通常是计算阶为4的排列数目，即4的阶乘，因为每个位置都有4种选择，所以总共有 \(4! = 4 \times 3 \times 2 \times 1 = 24\) 种不同的排列。例如4的全排列可能是：

1, 2, 3, 4
1, 2, 4, 3
1, 3, 2, 4
...
3, 1, 2, 4

全排列会一一列出这24种顺序。

如果你需要编写程序来生成特定大小n的幂集和全排列，可以使用相应的算法库或编程语言内置函数。例如，在Python中，`itertools`模块提供了生成幂集和全排列的方便方法。

相关问题

求解幂集问题和全排列问题。 要求：给出求解算法思路； 并选用一种自己熟悉的编程语言实现； 并分析算法的时间复杂度；(c++)

求解幂集问题是指给定一个集合S，找出其所有子集构成的集合，包括空集和自身。全排列问题则是找出一个序列的所有可能的不同排列方式。

**算法思路**：
1. **幂集**：可以采用递归或迭代的方式生成所有子集。对于每个元素，可以选择包含它，也可以选择不包含，这样就有两中选择。每次从当前结果集中加入一个新的子集，直到所有的元素都处理完毕。
2. **全排列**：可以使用回溯法，即递归地对未排序的元素进行位置交换，每一步选择一个未排序的元素放在当前已排序部分的最后，并继续对剩余元素进行全排列，直到所有元素都有序。

**C++ 实现** (幂集)：

#include <iostream>
#include <vector>
using namespace std;

void generatePowerSet(vector<int>& set, vector<vector<int>>& result, int index = 0) {
    // 添加当前子集到结果
    result.push_back(set);

    // 如果还没有处理完所有元素，继续添加元素
    if (index != set.size()) {
        for (int i = index; i < set.size(); ++i) {
            swap(set[index], set[i]); // 将set[i]放到set[index]的位置
            generatePowerSet(set, result, index + 1); // 继续处理下一个元素
            swap(set[index], set[i]); // 撤销操作，恢复原状态
        }
    }
}

int main() {
    vector<int> set = {1, 2};
    vector<vector<int>> powerSet;
    generatePowerSet(set, powerSet);
    for (const auto& subset : powerSet) {
        cout << "{" << subset[0];
        for (size_t i = 1; i < subset.size(); ++i)
            cout << "," << subset[i];
        cout << "}";
        cout << " ";
    }
    return 0;
}

**C++ 实现** (全排列)：

#include <vector>
using namespace std;

void permute(vector<int>& nums, vector<vector<int>>& res, int start, int end) {
    if (start == end) {
        res.push_back(nums);
    } else {
        for (int i = start; i <= end; ++i) {
            swap(nums[start], nums[i]);
            permute(nums, res, start + 1, end);
            swap(nums[start], nums[i]); // 回溯：撤销当前交换
        }
    }
}

int main() {
    vector<int> nums = {1, 2, 3};
    vector<vector<int>> permRes;
    permute(nums, permRes, 0, nums.size() - 1);
    for (const auto& permutation : permRes) {
        for (auto num : permutation)
            cout << num << ' ';
        cout << '\n';
    }
    return 0;
}

**时间复杂度**：
- 幂集算法：O(2^n)，因为对于n个元素，有2^n种可能的子集。
- 全排列算法：O(n!)，最坏情况下需要对n个元素进行n次交换，形成n!种排列。其中n是集合的大小。