2.7 洗牌算法

出自数据结构与算法分析--C语言描述 习题2.7

在有个函数int rand(int n)返回1-n之间的随机数。如何把数组A[N]打乱?

最初的Fisher–Yates算法是在另外开辟一个数组B[N],把打算后的A[N]放到B[N]中,步骤如下

设i=0

1、生成1-A.length长度之间的随机数k

2、把A[k]放到B[i],去除数组A中的A[k],i++。

3、如果A.length>0,转到第1步。

这个算法要去除A中的数,每次要移位,所以算法复杂度为O(N^2)。

例如一个算法过程如下:

随机数范围 随机数 A B  
    1 2 3 4 5 6 7 8  
随机数范围 随机数 A B
1–8 3 1 2 3 4 5 6 7 8 3
随机数范围 随机数 A B
1–7 4 1 2 3 4 5 6 7 8 3 5
随机数范围 随机数 A B
1–6 5 1 2 3 4 5 6 7 8 3 5 7
1–5 3 1 2 3 4 5 6 7 8 3 5 7 4
1–4 4 1 2 3 4 5 6 7 8 3 5 7 4 8
1–3 1 1 2 3 4 5 6 7 8 3 5 7 4 8 1
1–2 2 1 2 3 4 5 6 7 8 3 5 7 4 8 1 6
    1 2 3 4 5 6 7 8 3 5 7 4 8 1 6 2

后来算法有了改进,不是另外开辟数组,而是来交换数组A上面的元素来达到重排。

这个算法有2个版本,原理一样:

版本1:

[cpp] view plaincopy

  1. for(int i = n; i>=1; --i)
  2. {
  3. int j=rand(i);//生成1-i之间的随机数
  4. exchange(A[i],A[j]);//交换A[i],A[j]
  5. }

版本2:

[cpp] view plaincopy

  1. for(int i = 1; i <= n; ++i)
  2. {
  3. int j=(rand(n)/n)*(n-i+1)+i-1;//生成i-n之间的随机数
  4. exchange(A[i],A[j]);//交换A[i],A[j]

版本1的一个演算过程如下:

Modern method[edit]

We‘ll now do the same thing using Durstenfeld‘s version of the algorithm: this time, instead of striking out the chosen numbers and copying them elsewhere, we‘ll swap them with the last number not yet chosen. We‘ll start by writing out the numbers from 1 to 8 as before:

Range Roll Scratch Result
    1 2 3 4 5 6 7 8  

For our first roll, we roll a random number from 1 to 8: this time it‘s 6, so we swap the 6th and 8th numbers in the list:

Range Roll Scratch Result
1–8 6 1 2 3 4 5 8 7 6

The next random number we roll from 1 to 7, and turns out to be 2. Thus, we swap the 2nd and 7th numbers and move on:

Range Roll Scratch Result
1–7 2 7 3 4 5 8 2 6

The next random number we roll is from 1 to 6, and just happens to be 6, which means we leave the 6th number in the list (which, after the swap above, is now number 8) in place and just move to the next step. Again, we proceed the same way until the permutation is complete:

Range Roll Scratch Result
1–6 6 1 7 3 4 5 8 2 6
1–5 1 5 7 3 4 1 8 2 6
1–4 3 5 7 4 3 1 8 2 6
1–3 3 5 7 4 3 1 8 2 6
1–2 1 7 5 4 3 1 8 2 6

参考:http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle

时间: 2024-10-06 23:48:22

2.7 洗牌算法的相关文章

算法之洗牌算法

洗牌算法是我们常见的随机问题,在玩游戏.随机排序时经常会碰到,一个最常用的地方就是组卷.它可以抽象成这样:M以内的所有自然数的随机顺序数组. package com.math; import java.util.Random; /** * @author summer * */ public class Shuffle { static final int[] a = new int[54]; static Random rnd = new Random(); static{ for(int i

完美洗牌算法

本文是看完july博客完美洗牌之后的个人笔记. 题目:把a1,a2,a3,a4,...,an-1 an,b1,b2,b3,...,bn-1,bn变成a1,b1,a2,b1,...,an,bn.要求时间复杂度为O(n),空间复杂度为O(1). 1.位置置换算法:b是新开的一个数组,但是时间复杂度为O(n),空间复杂度为O(n). void perfectShuttle(int a[],int n){ int n2=n*2,b[N]; for(int i=1;i<=n2;i++) b[(2*i)%(

洗牌算法Fisher-Yates以及C语言随机数的产生

前些天在蘑菇街的面试中碰到一道洗牌的算法题,拿出来和大家分享一下! 原题是:54张有序的牌,如何无序的发给3个人? 这个题是运用经典的洗牌算法完成.首先介绍一种经典的洗牌算法--Fisher-Yates.现在大家在网上看到,大多是Fisher-Yates算法的变形.将本来O(n2),简化到了O(n).代码如下: #include<stdio.h> #include <stdlib.h> void func(char *, int); void main() { char a[7]

洗牌算法(转载)

作者:flyinghearts出处:http://www.cnblogs.com/flyinghearts/ 又一次看到讨论"洗牌"算法的文章,奇怪不少人喜欢造轮子,但造的轮子却远没有STL的random_shuffle好用. 若某个序列里面的每个元素在每个位置已经等概率出现,那么新增加一个元素,只要新增加的元素和所有元素进行等概率交换,则新序列中每个元素在每个位置仍是等概率出现.(若原来有n个元素,新增加的第n+1个元素在任一位置b的概率显然是1/(n+1),在同一位置b,原来的n个

JS洗牌算法

洗牌算法 以请将1~10共10个数字的数组随机打乱为列子,目前我知道的有两种方法,一种sort()方法和push()方法. 一.sort方法: var arr=[1,2,3,4,5,6,7,8,9]; function Upset(a,b) { //用Math.random()函数生成0~1之间的随机数与0.5比较,返回-1或1   return Math.random()>.5 ? -1 : 1;  //简化上面的方法 // return 0.5 - Math.random();  } arr

洗牌算法浅试

Python有自带的洗牌算法函数shuffle(). 自己也通过学习也琢磨了一下它的实现,然后给出一个时间复杂度O(n),空间复杂度O(1)的例子: 1 import random 2 3 def shuffle1(lst) : 4 l = len(lst) 5 if l <= 1 : return lst 6 7 i = 0 8 while l > 1 : 9 j = int(random.random() * l) 10 t = lst[i] 11 lst[i] = lst[i+j] 12

转:浅谈洗牌算法(面试题)

很多人都有耳闻过洗牌算法,时常会在面试中碰到,我们下面来定义一下这个问题. 所谓洗牌算法,就是给你一个1到n的序列,让你随机打乱,保证每个数出现在任意一个位置的概率相同,也就是说在n!个的排列中,每一个排列出现的概率相同. 最朴素的做法 对于这个问题我们从最朴素的解法谈起.每次随机选出一个没有被选过的数放到一个队列中,如果随机出来的数已经被选过,那么继续随机直到遇到一个没有被选过的数放入到队列中:重复这样子操作直到所有的数都被选择出来. 我们看看这样子作为什么是对的.首先选第一个数的时候有n个数

随机算法之30万员工抽取10万员工(洗牌算法)

算法方面不是我的强项,所以遇到这个问题,记录一下解决方法: 最开始的时候,做法是从random中来随机选取一个,然后再判断已有列表中是否存在, 然后以此重复,看到这里,会算法的同学肯定会说这明显不行:就好比多少人中生日为一天的概率大于50%: 所以然后查找了一些资料,看到了洗牌算法:包括多种变种吧. 这里说一下我参考的解决办法: 比如有30万个元素的列表,那么第一次随机选择一个:记录位置是x: 然后把元素的最后一个位置元素存入位置x,然后把最后位置的元素删除: (这里在交换的时候,需要判断这个元

Javascript 洗牌算法,打乱数组,随机获取元素

//利用洗牌算法Array.prototype.shuffle=function(){ var i,t,m=this.length; while(m){ i=Math.floor(Math.random()*m--); t=this[m]; this[m]=this[i]; this[i]=t; } return this;} var arr=[1,2,3,4,5];console.log(arr.shuffle());console.log(arr.slice(0,2));

【每日算法】洗牌算法

洗牌算法 给定一个n个数的序列,设计一个算法将其随机打乱,保证每个数出现在任意一个位置的概率相同(也就是说在n!个的排列中,每一个排列出现的概率相同). 朴素的做法: 假设输入为数组num[length]. 随机选一个数,放到num[0]中,再随机选数,如果该数已经选过,重新选,直到该数未选过时放入num[1]中,以此类推,直到所有的数都选出来,很明显,这种选法一共有n!中可能,每种可能出现的概率都相同. 但是该做法效率不高,因为选过的数再选将耗费大量时间. 改进的洗牌算法: 基于以上算法的缺陷