有没有更好的方法来改组 C++ 中的向量？

Question

I was making a BlackJack/21 game as I'm learning C++ to give me some experience in actually working on a project. I'm coming from Java, where there's a nice Collections.shuflfe(...) feature, but I couldn't find a reliable (and random) solution to achieve a similar result with C++.

I tried the below, and it's working quite well, but I was wondering if there's a much better way to do this, as I feel like I might not need to be using two vectors. However, I can't quite figure out what I could do to replace it, if anything at all. Currently, this is efficient enough for my simple card game, but I want to ask if there's anything I could improve on to make this simpler and/or more efficient for future uses?

template <class T> static vector<T> shuffle(vector<T> input) {
    vector<T> values;
    vector<int> indexes;
    for (int i = 0; i < input.size(); i++) {
        indexes.push_back(i);
    }

    //Seed the random number
    srand(static_cast<unsigned int>(time(NULL)));
    while(!indexes.empty()) {
        //Gets a random index from the currently unused indexes for the input.
        int index = rand() % indexes.size();
        int location = indexes.at(index);

        //Adds the value of the input at the randomly generated location to the new values.
        values.push_back(input.at(location));

        //remove chosen index from the list
        indexes.erase(indexes.begin() + index);
    }

    return values;
}

Answer 1

std::shuffle in <algorithm> should be what you're looking for. Here's an example of it in use.

#include <iostream>
#include <algorithm>
#include <vector>
#include <random>

int main () {
  std::vector<int> myvector {1,2,3,4,5};

  std::random_device rd;
  std::default_random_engine gen(rd);

  std::shuffle (myvector.begin(), myvector.end(), gen);

  for (int& x: myvector) std::cout << ' ' << x;
  std::cout << std::endl;

  return 0;
}

This example is adapted to use vectors from a version found at http://www.cplusplus.com/reference/algorithm/shuffle/ . Checkout the link for more info on std::shuffle

Answer 2

As others have pointed out, there's a shuffle function in the standard libraries... but if you're curious, in-place shuffle is fairly easy to implement.

template<typename T, typename E>
void shuffle(std::vector<T> & items, E & engine)
{
    for (unsigned i = 0; i < items.size() - 1; i++)
    {
        std::uniform_int_distribution<int> dist(i, items.size() - 1);
        int iTarget = dist(engine);
        std::swap(items[i], items[iTarget]);
    }
}

It works like this:

• We divide the vector into shuffled and unshuffled portions, with i being the index of the first unshuffled item.
• We start with i = 0 : the shuffled portion is empty, and the unshuffled portion comprises the whole vector.
• While the unshuffled portion isn't empty, we're going to move items out of it and into the shuffled portion.
  • We pick a random index in the unshuffled range (between i and the end of the vector) and designate it as the "target" item.
  • We take the first unshuffled item ( items[i] ) and swap it with the target.
  • The target (now at position i ) is considered shuffled . We increment i , meaning that the shuffled portion grew and the unshuffled portion shrank.

Does this shuffle actually produce a uniform distribution? See for yourself, with a simple test program:

int main()
{
    std::random_device rd;
    std::mt19937 engine(rd());

    static const int N_TEST_CASES = 200000;
    static const int N_ITEMS = 10;

    std::vector<std::vector<int> > distributions;
    distributions.resize(N_ITEMS);
    for (int i = 0; i < N_ITEMS; i++)
    {
        distributions[i].resize(N_ITEMS);
        for (int j = 0; j < N_ITEMS; j++)
            distributions[i][j] = 0;
    }

    for (int iTestCase = 0; iTestCase < N_TEST_CASES; iTestCase++)
    {
        std::vector<int> items;
        items.resize(N_ITEMS);
        for (int i = 0; i < N_ITEMS; i++)
            items[i] = i;

        shuffle(items, engine);

        for (int iItem = 0; iItem < N_ITEMS; iItem++)
            for (unsigned iPosition = 0; iPosition < items.size(); iPosition++)
                if (items[iPosition] == iItem)
                    distributions[iItem][iPosition]++;
    }

    for (int iItem = 0; iItem < N_ITEMS; iItem++)
    {
        std::cout << "Item " << iItem << ":\n";
        for (unsigned iPosition = 0; iPosition < distributions[iItem].size(); iPosition++)
            std::cout << "  Position #" << iPosition << ": " << (float)distributions[iItem][iPosition] / (float)N_TEST_CASES << "\n";

        std::cout << "\n";
    }

    return 0;
}

Answer 3

Make vector<T> input a reference ( vector<T> & input ), iterate over input , and for each iteration

1. Generate a random integer r in the range of the elements. ( 0 <= r < input.size() )
2. Swap ( std::iter_swap ) the current element with the r 'th element ( r 'th iterator := input.begin() + r ).