试题:组合的模板非递归实现

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

template <typename T>
void show(const vector<T> & element, const vector<int> & index)
{
    assert(index.size() > 0);
    assert(element.size() >= index.size());
    for (int i = 0; i < index.size(); ++i) {
        cout << element[index[i]] << " ";
    }
    cout << endl;
}

template <typename T>
void select(const vector<T> & element, int n, vector<int> & index)
{
    if (n <= 0 || n > element.size()) {
        return;
    }

    index.clear();
    for (int i = 0; i < n; ++i) {
        index.push_back(i);
    }

    while (true) {
        while (index[n - 1] <= element.size() - 1) {
            show(element, index);
            ++index[n - 1];
        }

        int index_bound = element.size();
        int carry_index = n - 2;
        while (carry_index >= 0) {
            ++index[carry_index];
            --index_bound;
            if (index[carry_index] < index_bound) {
                break;
            }
            else {
                assert(index[carry_index] == index_bound);
                --carry_index;
            }
        }
        if (carry_index >= 0) {
            for (int i = carry_index + 1; i < n; ++i) {
                index[i] = index[i - 1] + 1;
            }
        }
        else {
            break;
        }
    }
}

template <typename U, typename V>
void combine(U begin, U end, V * pfirst)
{
    vector<V> element(begin, end);
    vector<int> index;
    index.reserve(element.size());

    for (int i = 1; i <= element.size(); ++i) {
        select(element, i, index);
    }
}

template <typename T>
void combine(T begin, T end)
{
    combine(begin, end, &*begin);
}

int main()
{
    int data[] = { 1, 2, 3, 4, 5, 6 };
    combine(data, data + sizeof(data) / sizeof(data[0]));
    combine(data, *(&data + 1));

    return 0;
}