c语言数组洗牌的实现

1.前言

        测试数据中，需要用到随机数据，同时要求数据不能重复。所以最终想到了洗牌的方式来生成测试数据，也就是大名鼎鼎的shuffle算法。

2.相关知识

2.1 算法描述

考虑了不需要额外地申请空间，所以需要再数组内部进行调整。

for i=1 to n do swap( a[i], a[random(i,n)] );

2.2 数学证明

数学归纳法证明，随机数据为平均分布：

1. 当n=1时，所以元素arr[0]在任何一个位置的概率为1/1，命题成立；
2. 假设当n=k时，命题成立，即原数组中任何一个元素在任何一个位置的概率为1/k；
3. 则当n=k+1时，当算法执行完k次时，前k个元素在前k个位置的概率均为1/k；
4. 当执行最后一步时，前k个元素中任何一个元素被替换到第k+1位置的概率为：(1-1/(k+1)) * 1/k = 1/(k+1)；
5. 在前面k个位置任何一个位置的概率为(1-1/(k+1)) * 1/k = 1/(k+1)；
6. 对于第k+1个元素，其在原位置的概率为1/k+1，在前k个位置任何一个位置的概率为：(1-k /(k+1)) * (1/k) = 1/(k+1)；
7. 所以对于第k+1个元素，其在整个数组前k+1个位置上的概率也均为1/k+1；

综上所述，对于任意n，只要按照方案中的方法，即可满足每个元素在任何一个位置出现的概率均为1/n。

3.实现

基础数组申请：

static inline u32 *
__integer_array_alloc(u32 min, u32 max)
{
    u32 ix = 0;
    u32 *parry = NULL;
    size_t nmemb = max - min + 1;

    parry = (u32 *)malloc(nmemb * sizeof(u32));
    if (!parry) {
        return NULL;
    }

    for (ix = 0; ix < nmemb; ix++) {
        parry[ix] = min + ix;
    }

    return parry;
}

洗牌，选取 roll rear 两个位置，进行交换。但要注意的是 rand() 获取的其实是伪随机数。某些安全场景下需要换为真随机数。

static inline void
__integer_array_shuffle(u32 *parry, size_t nmemb)
{
    u32 ix = 0;
    u32 roll = 0;
    u32 rear = 0;

    for (ix = 0; ix < nmemb; ix++) {
        roll = rand() % (nmemb - ix);
        rear = nmemb - ix - 1;

        if (roll == rear) {
            continue;
        }

        /* Swap */
        parry[roll] = parry[roll] ^ parry[rear];
        parry[rear] = parry[roll] ^ parry[rear];
        parry[roll] = parry[roll] ^ parry[rear];
    }
}

为了方便查看效果，加一个打印函数

static inline void
__integer_array_display(u32 *parry, size_t nmemb)
{
    printf("---------------------------------------------\n");
    u32 ix = 0;
    for (ix = 0; ix < nmemb; ix++) {
        printf("%4d ", parry[ix]);
        if (((ix + 1) & 0x7) == 0) {
            printf("\n");
        }
    }
    printf("\n");
    printf("---------------------------------------------\n");
}

所以，最终封装的函数如下：

u32 *utils_random_sequence_alloc(u32 min, u32 max)
{
    u32 *parry = NULL;

    if (max <= min) {
        printf("Input error\n");
        return NULL;
    }

    parry = __integer_array_alloc(min, max);
    __integer_array_display(parry, max - min + 1);
    __integer_array_shuffle(parry, max - min + 1);
    __integer_array_display(parry, max - min + 1);
    return parry;
}

生成100个随机数据，执行结果如下：

---------------------------------------------
   0    1    2    3    4    5    6    7
   8    9   10   11   12   13   14   15
  16   17   18   19   20   21   22   23
  24   25   26   27   28   29   30   31
  32   33   34   35   36   37   38   39
  40   41   42   43   44   45   46   47
  48   49   50   51   52   53   54   55
  56   57   58   59   60   61   62   63
  64   65   66   67   68   69   70   71
  72   73   74   75   76   77   78   79
  80   81   82   83   84   85   86   87
  88   89   90   91   92   93   94   95
  96   97   98   99  100
---------------------------------------------
---------------------------------------------
  36   25   30   75   52   44   89   12
  27   29    6   21   13   63   84    0
  41   22   81   79    7   28   83   47
  57   66   11   46   43   15   18   40
   4   39   70   71   14   77   64   97
  96   95   10   38  100   60   88   20
  69   26   68   53   16   56   61   17
  90   65   73   33   76   92   58   24
  23   98   74   34   51   42   49   55
   9   59   62   93   37   87   19   82
   8   54   80   85   45   78   94    3
  35   67    2    1   48   50   99   31
  91    5   72   86   32
---------------------------------------------

4. 结论

        本章介绍的shuffle算法为非常好理解且实现简单的算法，在项目实用性非常强。同样的在c++中，也有std::random_shuffle的实用方法。

————————————————
参考文章：
[1]：https://blog.csdn.net/cyningsun/article/details/7545679
[2]：https://blog.csdn.net/y417244146/article/details/46819091