什么是随机数？通俗说法就是随机产生的一个数，这个数预先不能计算出来的，并且所有可能出现的数字，概率应该是均匀的。因此随机数应该满足至少以下两点：

1. 不可计算性，即不确定性。
2. 机会均等，即每个可能出现的数字必须概率相等。

如何产生随机数是一个具有挑战的问题，一般使用随机硬件产生，比如骰子、电子元件噪声、核裂变等。

在计算机编程中，我们经常调用随机数产生器函数，但我们必须清楚的一点是，一般直接调用软件的随机数产生器函数，产生的数字并不是严格的随机数，而是通过一定的算法计算出来的（不满足随机数的不可计算性），我们称它为伪随机数！由于它具有类似随机的统计特征，在不是很严格的情况，使用软件方式产生伪随机相比硬件实现方式，成本更低并且操作简单、效率也更高！

那一般伪随机数如何产生呢？ 一般是通过一个随机种子（比如当前系统时间值），通某个算法（一般是位运算），不断迭代产生下一个数。比如c语言中的stdlib中rand_r函数（用的glibc）：

/* This algorithm is mentioned in the ISO C standard, here extended
   for 32 bits.  */
int
rand_r (unsigned int *seed)
{
  unsigned int next = *seed;
  int result;

  next *= 1103515245;
  next += 12345;
  result = (unsigned int) (next / 65536) % 2048;

  next *= 1103515245;
  next += 12345;
  result <<= 10;
  result ^= (unsigned int) (next / 65536) % 1024;

  next *= 1103515245;
  next += 12345;
  result <<= 10;
  result ^= (unsigned int) (next / 65536) % 1024;

  *seed = next;

  return result;
}

而java中的Random类产生方法next()为：

 protected int next(int bits) {
        long oldseed, nextseed;
        AtomicLong seed = this.seed;
        do {
            oldseed = seed.get();
            nextseed = (oldseed * multiplier + addend) & mask;
        } while (!seed.compareAndSet(oldseed, nextseed));
        return (int)(nextseed >>> (48 - bits));
    }

java中还有一个更精确的伪随机产生器java.security.SecurityRandom, 它继承自Random类，可以指定算法名称，next方法为：

 final protected int next(int numBits) {
        int numBytes = (numBits+7)/8;
        byte b[] = new byte[numBytes];
        int next = 0;

        nextBytes(b);
        for (int i = 0; i < numBytes; i++) {
            next = (next << 8) + (b[i] & 0xFF);
        }

        return next >>> (numBytes*8 - numBits);
    }

当然这个类不仅仅是重写了next方法，在种子设置等都进行了重写。

最近有一道题：已知一个rand7函数，能够产生1～7的随机数，求一个函数，使其能够产生1～10的随机数。

显然调用一次不可能满足，必须多次调用！利用乘法原理，调用rand7() * rand7()可以产生1~49的随机数，我们可以把结果模10（即取个位数）得到0~9的数，再加1,即产生1~10的数。但我们还需要保证概率的机会均等性。显然1～49中，共有49个数，个位为0出现的次数要少1，不满足概率均等，如果直接这样计算，2~10出现的概率要比1出现的概率大！我们可以丢掉一些数字，比如不要大于40的数字，出现大于40,就重新产生。

int rand10() {
    int ans;
    do {
        int i = rand7();
        int j = rand7();
        ans = i * j;
    } while(ans > 40);
    return ans % 10 + 1;
}

随机数的用途就不用多说了，比如取样，产生随机密码等。下面则着重说说其中一个应用--洗牌算法。

我们可能接触比较多的一种情况是需要把一个无序的列表排序成一个有序列表。洗牌算法（shuffle）则是一个相反的过程，即把一个有序的列表（当然无序也无所谓）变成一个无序的列表。

这个新列表必须是随机的，即原来的某个数在新列表的位置具有随机性！

我们假设有1～100共100个无重复数字。

很容易想到一种方案是：

    从第一张牌开始，利用随机函数生成器产生1～100的随机数，比如产生88,则看第88个位置有没有占用，如果没有占用则把当前牌放到第88位置，如果已经占用，则重新产生随机数，直到找到有空位置！

    首先必须承认这个方法是可以实现洗牌算法的。关键在于效率，首先空间复杂度是O(n)，时间复杂度也是O(n)，关键是越到后面越难找到空位置，大量时间浪费在求随机数和找空位置的。

第二中方案：

    从第一张牌开始，设当前位置牌为第i张，利用随机函数生成器产生1～100的随机数，比如产生88，则交换第i张牌和第88张牌。

这样满足了空间是O（1）的原地操作，时间复杂度是O(n)。但是否能够保证每个牌的位置具有机会均等性呢？

首先一个常识是：n张牌，利用随机数产生N种情况，则必须满足N能够整除n，这样就能给予每个牌以N/n的机会（或者说权值），如果N不能整除n，必然机会不均等，即有些牌分配的机会多，有些少。

我们知道100的全排列有100的阶乘种情况，而调用100次随机函数，共可以产生100^100种情况，而n^n 必然不能整除n!，具体证明不在这里叙述。

那我们可以利用第二种方法改进，每次不是产生1~100的随机数，而是1~i的数字，则共有n!中情况，即N=n!，显然满足条件，且时间为O(n),空间为O(1).这也就是Fisher-Yates_shuffle算法，大多数库都使用的这种方法。

我们看看java中Collections实现：

 public static void shuffle(List<?> list, Random rnd) {
        int size = list.size();
        if (size < SHUFFLE_THRESHOLD || list instanceof RandomAccess) {
            for (int i=size; i>1; i--)
                swap(list, i-1, rnd.nextInt(i));
        } else {
            Object arr[] = list.toArray();

            // Shuffle array
            for (int i=size; i>1; i--)
                swap(arr, i-1, rnd.nextInt(i));

            // Dump array back into list
            // instead of using a raw type here, it's possible to capture
            // the wildcard but it will require a call to a supplementary
            // private method
            ListIterator it = list.listIterator();
            for (int i=0; i<arr.length; i++) {
                it.next();
                it.set(arr[i]);
            }
        }
    }

除了首先判断能否随机访问，剩下的就是以上算法的实现了。

STL中实现：

// random_shuffle

template <class _RandomAccessIter>
inline void random_shuffle(_RandomAccessIter __first,
                           _RandomAccessIter __last) {
  __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator);
  if (__first == __last) return;
  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
    iter_swap(__i, __first + __random_number((__i - __first) + 1));
}

template <class _RandomAccessIter, class _RandomNumberGenerator>
void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last,
                    _RandomNumberGenerator& __rand) {
  __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator);
  if (__first == __last) return;
  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
    iter_swap(__i, __first + __rand((__i - __first) + 1));
}

如何测试洗牌算法具有随机性呢？其实很简单，调用洗牌算法N次，牌数为n，统计每个数字出现在某个位置的出现次数，构成一个矩阵n * n,如果这个矩阵的值都在N/n左右，则洗牌算法好。比如有100个数字，统计一万次，则每个数字在某个位置的出现次数应该在100左右。

洗牌算法的应用也很广，比如三国杀游戏、斗地主游戏等等。讲一个最常见的场景，就是播放器的随机播放。有些播放器的随机播放，是每次产生一个随机数来选择播放的歌曲，这样就有可能还没有听完所有的歌前，又听到已经听过的歌。另一种就是利用洗牌算法，把待播放的歌曲列表shuffle。如何判断使用的是哪一种方案呢？ 很简单，如果点上一首还能回去，则利用的是洗牌算法，如果点上一首又是另外一首歌，则说明使用的是随机产生方法。比如上一首是3,现在是18,点上一首，如果是3说明采用的洗牌算法，如果不是3，则说明不是洗牌算法（存在误判，多试几次就可以了）。

顺便提一下网上的一些抽奖活动，尤其是转盘，是不是真正的随机？答案留给看客！

• 相关文章
• 全局相关文章