c++ - 如何洗牌包括最后一个元素的数组？

Question

我试过使用 std::random_shuffle 和 std::shuffle，但它们只随机播放第一个和第一个和最后一个之间的元素，但不是最后一个。有没有办法打乱包括最后一个元素的数组( vector )？

//NumberGenerator.h
#ifndef __NUMBERGENERATOR_H__
#define __NUMBERGENERATOR_H__
#pragma once
#include "Number.h" //regular numbers
#include "MegaNumber.h" //mega numbers
#include <vector> //<vector>
#include <string> //strings 
using std::to_string; //convert int to strings
#include <algorithm> //shuffle
//#include <random> //std::default_random_engine
#define NON_MEGA_COMBINATIONS 5
#define MEGA_COMBINATIONS 1

using std::vector; //<vectors>
using std::string; //string
using std::random_shuffle; //shuffles arrays

class NumberGenerator
{
public:
    NumberGenerator(vector<Number> numbers, vector<MegaNumber> megaNumbers); //constructor
    ~NumberGenerator();
    string pickNumbers(); //function that randomizes regularDraws and megaDraws
protected: 
    vector<Number> regularDraws; //contains number information
    vector<MegaNumber> megaDraws; //contains mega number information
};

#endif


//NumberGenerator.cpp
#include "NumberGenerator.h"


//constructor
NumberGenerator::NumberGenerator(vector<Number> numbers, vector<MegaNumber> megaNumbers)
{
    regularDraws = numbers;
    megaDraws = megaNumbers;
}

//destructor
NumberGenerator::~NumberGenerator()
{
}


string NumberGenerator::pickNumbers()
{
    srand(rand());
    random_shuffle(&regularDraws[1], &regularDraws[regularDraws.size() - 1]);
    random_shuffle(&megaDraws[1], &megaDraws[megaDraws.size() - 1]);
    string regular;
    string mega;
    string last = to_string(regularDraws[regularDraws.size() - 1].getID());

    for (int i = 1; i <= NON_MEGA_COMBINATIONS; i++)
    {
        regular = regular + " " + to_string(regularDraws[i].getID());
    }

    for (int i = 1; i <= MEGA_COMBINATIONS; i++)
    {
        mega = mega + " " + to_string(megaDraws[i].getID());
    }

    return regular + " " + mega + " " + last;
}



//Number.h
#ifndef __NUMBER_H_
#define __NUMBER_H__
#pragma once


class Number
{
public:
    Number(int id); //constructor
    ~Number(); //destructor


    int getID(); //returns the number ID



protected:
    int ID; //This is the number 
};

#endif 

//Number.cpp
#include "Number.h"


//constructor
Number::Number(int id)
{
    occurence = 0;
    occurencePct = 0;
    ID = id;
}

//destructor
Number::~Number()
{
}

//returns the number ID
int Number::getID() 
{
    return ID; 
}


//MegaNumber.h
#ifndef __MEGANUMBER_H__
#define __MEGANUMBER_H__
#pragma once
#include "Number.h"

//Subclass of Number
class MegaNumber :
    public Number
{
public:
    MegaNumber(int id); //Will be inheriting Number superclass
    ~MegaNumber();
};

#endif

//MegaNumber.cpp
#include "MegaNumber.h"


//constructor
MegaNumber::MegaNumber(int id) : Number::Number(id) //inherits the super class Number
{

}

//destructor
MegaNumber::~MegaNumber()
{
}

//Source.cpp
#include <iostream>
#include "NumberGenerator.h"
int main()
{
vector<Number> arg1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
vector<MegaNumber> arg2 = {0, 1, 2, 3, 4, 5, 6, 7 , 8, 9};
NumberGenerator game(arg1, arg2);
  for (int i = 0; i < 10; i++)
  {
      cout << game.pickNumbers() << endl;
  }
}

这是我的代码的精简版，因为它包含 10 个文件，我认为对于我正在做的事情来说已经足够了。无论如何，每次运行 pickNumbers() 时，最后一个元素都不会被打乱。

Answer 1

所有采用一对迭代器的标准库算法(和其他函数)都在半开范围 [first, last) 上运行。然而，这根本不是问题——所有标准库容器都被设计成 end()(和变体)返回的迭代器是一个 past-the-end 迭代器: 它指向 容器中最后一个真实元素之后的一个。 所以这个调用:

std::vector<int> v = whatever();
std::random_shuffle(v.begin(), v.end());

实际上会打乱 vector 中的 所有 int。

鉴于此，您可以看到您错误地使用了该函数。对于 last 参数，您将传递 &regularDraws[regularDraws.size() - 1](和类似的)—— vector 中最后一个实际元素的地址。由于间隔是半开的，正如我在上面概述的那样，最后一个元素不是随机播放的一部分。

根本不应该使用指向 vector 的指针⁽¹⁾，而应该使用迭代器:

random_shuffle(std::next(regularDraws.begin()), regularDraws.end());

std::next 在那里是因为您最初传递 [1]( vector 中的第二个元素)作为 第一个参数，所以我保留了它(记住数组索引在 C++ 中是基于 0 的)。如果那不是您的意图，只需打乱整个 vector 即可:

random_shuffle(regularDraws.begin(), regularDraws.end());

---

在任何地方使用半开范围实际上是非常有利的:

• 它允许一个空范围的简单表达式:begin == end
• 所有插入点都可以使用迭代器指定，如果我们将迭代器理解为“指向元素之前”的话。 begin 表示“在第一个元素之前插入”，end 表示“在 one-past-last` 元素之前插入”，即“在最后一个元素之后插入”。 "

• 它允许轻松连接/拆分:

  auto b = rng.begin();
  auto e = rng.end();
  auto m = std::next(b, std::distance(b, e) / 2);
  processHalf(b, m);
  processHalf(m, e);
  

---

⁽¹⁾ 您的代码之所以有效，是因为 std::vector 将其元素连续存储在内存中。使用迭代器，它可以与任何容器一起工作。