如何打乱包含最后一个元素的数组？

Question

我尝试过使用std::random_shuffle 和std::shuffle，但它们只会随机播放第一个和第一个和最后一个之间的元素，而不是最后一个。有没有办法洗牌包括最后一个元素的数组（向量）？

//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());

实际上会洗牌所有向量中的ints。

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

您根本不应该使用指向向量的指针⁽¹⁾，而是使用迭代器：

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

std::next 存在是因为您最初将 [1]（向量中的第二个元素）作为 first 参数传递，所以我保留了它（请记住，数组索引在 C++ 中是从 0 开始的）。如果这不是您的意图，只需将整个向量打乱：

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

---

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

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

• 它允许简单的连接/拆分：

  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 将其元素连续存储在内存中。使用迭代器，它将适用于任何容器。