Question

我正在寻找ANSI C中的一个函数，它可以像PHP的shuffle()一样随机化一个数组。有这样的功能还是我必须自己编写？如果我必须自己编写，那么最好/最高效的方法是什么？

到目前为止我的想法：

遍历数组，比如100次，并将随机索引与另一个随机索引交换
创建一个新数组并使用第一个数据中的随机索引填充它，每次检查索引是否已被采用（性能= 0复杂度=严重）

Answer 1

从Asmodiel的link粘贴到Ben Pfaff's Writings，以保持持久性：

#include <stdlib.h>

/* Arrange the N elements of ARRAY in random order.
   Only effective if N is much smaller than RAND_MAX;
   if this may not be the case, use a better random
   number generator. */
void shuffle(int *array, size_t n)
{
    if (n > 1) 
    {
        size_t i;
        for (i = 0; i < n - 1; i++) 
        {
          size_t j = i + rand() / (RAND_MAX / (n - i) + 1);
          int t = array[j];
          array[j] = array[i];
          array[i] = t;
        }
    }
}

编辑：这是适用于任何类型（int，struct，...）到memcpy的通用版本。使用要运行的示例程序，它需要VLA，而不是每个编译器都支持这一点，因此您可能希望将其更改为malloc（这将执行得很糟糕）或静态缓冲区大到足以容纳您抛出的任何类型：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

/* compile and run with
 * cc shuffle.c -o shuffle && ./shuffle */

#define NELEMS(x)  (sizeof(x) / sizeof(x[0]))

/* arrange the N elements of ARRAY in random order.
 * Only effective if N is much smaller than RAND_MAX;
 * if this may not be the case, use a better random
 * number generator. */
static void shuffle(void *array, size_t n, size_t size) {
    char tmp[size];
    char *arr = array;
    size_t stride = size * sizeof(char);

    if (n > 1) {
        size_t i;
        for (i = 0; i < n - 1; ++i) {
            size_t rnd = (size_t) rand();
            size_t j = i + rnd / (RAND_MAX / (n - i) + 1);

            memcpy(tmp, arr + j * stride, size);
            memcpy(arr + j * stride, arr + i * stride, size);
            memcpy(arr + i * stride, tmp, size);
        }
    }
}

#define print_type(count, stmt) \
    do { \
    printf("["); \
    for (size_t i = 0; i < (count); ++i) { \
        stmt; \
    } \
    printf("]\n"); \
    } while (0)

struct cmplex {
    int foo;
    double bar;
};

int main() {
    srand(time(NULL));

    int intarr[] = { 1, -5, 7, 3, 20, 2 };

    print_type(NELEMS(intarr), printf("%d,", intarr[i]));
    shuffle(intarr, NELEMS(intarr), sizeof(intarr[0]));
    print_type(NELEMS(intarr), printf("%d,", intarr[i]));

    struct cmplex cmparr[] = {
        { 1, 3.14 },
        { 5, 7.12 },
        { 9, 8.94 },
        { 20, 1.84 }
    };

    print_type(NELEMS(intarr), printf("{%d %f},", cmparr[i].foo, cmparr[i].bar));
    shuffle(cmparr, NELEMS(cmparr), sizeof(cmparr[0]));
    print_type(NELEMS(intarr), printf("{%d %f},", cmparr[i].foo, cmparr[i].bar));

    return 0;
}

Answer 2

以下代码可确保根据从usec时间获取的随机种子对数组进行混洗。这也正确地实现了Fisher–Yates shuffle。我已经测试了这个函数的输出，看起来很好（甚至期望任何数组元素都是shuffle之后的第一个元素。甚至期望成为最后一个元素。）

void shuffle(int *array, size_t n) {    
    struct timeval tv;
    gettimeofday(&tv, NULL);
    int usec = tv.tv_usec;
    srand48(usec);


    if (n > 1) {
        size_t i;
        for (i = n - 1; i > 0; i--) {
            size_t j = (unsigned int) (drand48()*(i+1));
            int t = array[j];
            array[j] = array[i];
            array[i] = t;
        }
    }
}

Answer 3

C标准中没有随机化数组的函数。

看看Knuth--他有工作的算法。
或者看看Bentley - 编程珍珠或更多编程珍珠。
或者查看几乎所有的算法书。

确保公平洗牌（原始订单的每个排列都同样可能）很简单，但并非无足轻重。

Answer 4

这是一个使用memcpy而不是赋值的解决方案，因此您可以将它用于任意数据上的数组。你需要两倍的原始数组内存，成本是线性O（n）：

void main ()
{
    int elesize = sizeof (int);
    int i;
    int r;
    int src [20];
    int tgt [20];

    for (i = 0; i < 20; src [i] = i++);

    srand ( (unsigned int) time (0) );

    for (i = 20; i > 0; i --)
    {
        r = rand () % i;
        memcpy (&tgt [20 - i], &src [r], elesize);
        memcpy (&src [r], &src [i - 1], elesize);
    }
    for (i = 0; i < 20; printf ("%d ", tgt [i++] ) );
}

Answer 5

我只想回应尼尔巴特沃思的回答，并指出你的第一个想法有些麻烦：

你建议，

例如，遍历数组100次，并将随机索引与另一个随机索引交换

严格要求。我假设存在randn(int n)，一个RNG的包装器，产生均匀分布在[0， n -1]和swap(int a[], size_t i, size_t j)中的数字，

swap(int a[], size_t i, size_t j) {
  int temp = a[i]; a[i] = a[j]; a[j] = temp;
}

交换a[i]和a[j]。现在让我们实施你的建议：

void silly_shuffle(size_t n, int a[n]) {
    for (size_t i = 0; i < n; i++)
        swap(a, randn(n), randn(n)); // swap two random elements
}

请注意，这并不比这个更简单（但仍然错误）的版本更好：

void bad_shuffle(size_t n, int a[n]) {
    for (size_t i = 0; i < n; i++)
        swap(a, i, randn(n));
}

嗯，怎么了？考虑这些函数给你的排列数：在<0， n n （或silly_shuffle的2× n ）随机选择> -1]，代码将“公平地”选择 n ²（或2× n ²）中的一种方式来重新组合套牌。麻烦的是有 n ！ = n ×（ n -1）×⋯×2×1阵列的可能排列，既不是 n ²也不是2× n ²是 n ！的倍数，证明某些排列比其他排列更有可能。

Fisher-Yates shuffle实际上相当于你的第二个建议，只有一些优化会改变（性能= 0，复杂度=严重）到（性能=非常好，复杂性=非常简单）。（实际上，我不确定是否存在更快或更简单的正确版本。）

void fisher_yates_shuffle(size_t n, int a[n]) {
    for (size_t i = 0; i < n; i++)
        swap(a, i, i+randn(n-1-i)); // swap element with random later element
}

ETA：另见this post on Coding Horror。

Answer 6

您要寻找的功能已在标准C库中提供。名称为qsort。随机排序可以实现为：

int rand_comparison(const void *a, const void *b)
{
    (void)a; (void)b;

    return rand() % 2 ? +1 : -1;
}

void shuffle(void *base, size_t nmemb, size_t size)
{
    qsort(base, nmemb, size, rand_comparison);
}

示例：

int arr[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

srand(0); /* each permutation has its number here */

shuffle(arr, 10, sizeof(int));

...并且输出为：

3, 4, 1, 0, 2, 7, 6, 9, 8, 5

Answer 7

我没有在答案中看到它，所以我提出这个解决方案，如果它可以帮助任何人：

static inline void shuffle(size_t n, int arr[])
{
    size_t      rng;
    size_t      i;
    int         tmp[n];
    int         tmp2[n];

   memcpy(tmp, arr, sizeof(int) * n);
    bzero(tmp2, sizeof(int) * n);
    srand(time(NULL));
    i = 0;
    while (i < n)
    {
        rng = rand() % (n - i);
        while (tmp2[rng] == 1)
            ++rng;
        tmp2[rng] = 1;
        arr[i] = tmp[rng];
        ++i;
    }
}

Answer 8

与 Nomadiq 相同的答案，但 Random 保持简单。如果您一个接一个地调用该函数，Random 将是相同的：

#include <stdlib.h>
#include <time.h>

void shuffle(int aArray[], int cnt){
    int temp, randomNumber;
    time_t t;
    srand((unsigned)time(&t));
    for (int i=cnt-1; i>0; i--) {
        temp = aArray[i];
        randomNumber = (rand() % (i+1));
        aArray[i] = aArray[randomNumber];
        aArray[randomNumber] = temp;
    }
}

C中的随机数组

8 个答案: