C中的随机排列数组

问题描述

| 我正在寻找ANSI C中的一个函数，该函数可以像PHP的

shuffle()

那样随机化数组。是否有这样的功能，还是我必须自己编写？而且，如果我必须自己编写它，那么最佳/最高效的方法是什么？ 到目前为止，我的想法是： 遍历数组100次，然后与另一个随机索引交换一个随机索引 创建一个新数组，并用第一个随机索引填充它，每次检查索引是否已被占用（性能= 0复杂度=严重）     

解决方法

出于持久性，从Asmodiel \的链接粘贴到Ben Pfaff的著作中：

#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

，...）至through4ѭ。要运行一个示例程序，它需要VLA，并非每个编译器都支持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),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),cmparr[i].bar));

    return 0;
}

    ,下面的代码确保将基于从usec时间获取的随机种子对数组进行混洗。这也可以正确地实现Fisher-Yates的混洗。我已经测试了此函数的输出，它看起来不错（甚至期望将任何数组元素作为随机播放之后的第一个元素。甚至还希望将其作为最后一个元素）。

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;
        }
    }
}

    ,C标准中没有用于随机化数组的函数。 看一下Knuth-他有完成这项工作的算法。 或查看Bentley-编程珍珠或更多编程珍珠。 或浏览几乎所有算法书籍。 确保公平的洗牌（原始顺序的每个排列均可能发生）很简单，但并非无关紧要。     ,这是一个使用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++] ) );
}

    ,我只是回应尼尔·巴特沃思（Neil Butterworth）的回答，并指出您的第一个想法有些麻烦： 你建议   遍历数组100次，然后与另一个随机索引交换一个随机索引 使这个严格。我假设存在

randn(int n)

，它是一些RNG的包装，产生的数字均匀地分布在[0，n-1]和

swap(int a[],size_t i,size_t j)

中，

swap(int a[],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,i,randn(n));
}

好吧，怎么了？考虑一下这些函数给您带来多少排列：在[0，n-1]中使用n个（或2×n表示16个字符）随机选择时，代码将“公平地”选择n²（或2×n²）种方式中的一种进行混洗。甲板。麻烦是那里有n！ = n×（n-1）×⋯×2×1阵列的可能排列，并且n²和2×n²都不是n！的倍数，证明某些排列比其他排列更有可能。 Fisher-Yates混洗实际上等效于您的第二个建议，只是在某些优化中（性能= 0，复杂度=严重）变为（性能=很好，复杂度=非常简单）。 （实际上，我不确定是否存在更快或更简单的正确版本。）

void fisher_yates_shuffle(size_t n,i+randn(n-1-i)); // swap element with random later element
}

预计到达时间：另请参阅有关编码恐怖的文章。     ,我没有在答案中看到它，所以我提出了这个解决方案，如果它可以帮助任何人：

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;
    }
}