blocks|key|1536030|text|生成相同长度的随机浮点数或整型数组。对该数组进行排序，并在目标数组上执行相应的交换。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1536031|这就产生了一个真正独立的排序。|1536032|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Generate an array of random floats or ints of the same length. Sort that array, and do corresponding swaps on your target array.

This yields a truly independent sort.

blocks|key|1750998|text|随机化数组是密集的，因为您必须在一堆字符串之间移动。为什么不直接从数组中随机读取呢？在最坏的情况下，您甚至可以使用getNextString()创建一个包装类。如果您确实需要创建一个随机数组，那么您可以这样做|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1750999|for+i+=+0+->+i=+array.length+*+5
+++swap+two+strings+in+random+places|code-block|syntax|javascript|1751000|*5是任意的。|1751001|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Randomizing the array is intensive as you have to shift around a bunch of strings. Why not just randomly read from the array? In the worst case you could even create a wrapper class with a getNextString(). If you really do need to create a random array then you could do something like

<pre><code>for i = 0 -&gt; i= array.length * 5
 swap two strings in random places
</code></pre>

The *5 is arbitrary.

blocks|key|1536149|text|如果你使用的是.NET+3.5，你可以使用下面的IEnumerable+coolness：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1536150|Random+rnd=new+Random();
string[]+MyRandomArray+=+MyArray.OrderBy(x+=>+rnd.Next()).ToArray();++++|code-block|syntax|javascript|1536151|编辑:下面是相应的VB.NET代码：|1536152|Dim+rnd+As+New+System.Random
Dim+MyRandomArray+=+MyArray.OrderBy(Function()+rnd.Next()).ToArray()|1536153|第二，为了回应System.Random“不是线程安全的”和“只适用于玩具应用程序”的评论，因为它返回了基于时间的序列:正如我在示例中所使用的，Random()是完全线程安全的，除非您允许重新输入将数组随机化的例程，在这种情况下，您无论如何都需要像lock+(MyRandomArray)这样的东西，这样才不会损坏您的数据，这也将保护rnd。|offset|length|style|CODE|1536154|此外，应该很好地理解，System.Random作为熵的来源并不是很强。正如MSDN+documentation中所指出的，如果您正在做任何与安全相关的事情，那么您应该使用从System.Security.Cryptography.RandomNumberGenerator派生的内容。例如：|1536155|using+System.Security.Cryptography;|1536156|..。|1536157|RNGCryptoServiceProvider+rnd+=+new+RNGCryptoServiceProvider();
string[]+MyRandomArray+=+MyArray.OrderBy(x+=>+GetNextInt32(rnd)).ToArray();|1536158|1536159|static+int+GetNextInt32(RNGCryptoServiceProvider+rnd)
++++{
++++++++byte[]+randomInt+=+new+byte[4];
++++++++rnd.GetBytes(randomInt);
++++++++return+Convert.ToInt32(randomInt[0]);
++++}|1536160|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.random.aspx^0|0|0|0|0|3G|K|4N|3|0|2F|1E|12|I|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1B|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1D|8|@$M|1E|N|1F|O|P]|$M|1G|N|1H|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1I|8|@$M|1J|N|1K|O|P]]|9|@$M|1L|N|1M|1|1N]]|A|$]]|$1|S|3|T|5|D|7|1O|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1P|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1Q|8|@]|9|@]|A|$E|F]]|$1|Y|3|V|5|6|7|1R|8|@]|9|@]|A|$]]|$1|Z|3|10|5|D|7|1S|8|@]|9|@]|A|$E|F]]|$1|11|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|12|$13|$5|14|15|16|A|$17|18]]]]

If you're on .NET 3.5, you can use the following IEnumerable coolness:
<pre><code>Random rnd=new Random();
string[] MyRandomArray = MyArray.OrderBy(x =&gt; rnd.Next()).ToArray(); 
</code></pre>
Edit: and here's the corresponding VB.NET code:
<pre><code>Dim rnd As New System.Random
Dim MyRandomArray = MyArray.OrderBy(Function() rnd.Next()).ToArray()
</code></pre>
Second edit, in response to remarks that System.Random &quot;isn't threadsafe&quot; and &quot;only suitable for toy apps&quot; due to returning a time-based sequence: as used in my example, Random() is perfectly thread-safe, unless you're allowing the routine in which you randomize the array to be re-entered, in which case you'll need something like <code>lock (MyRandomArray)</code> anyway in order not to corrupt your data, which will protect <code>rnd</code> as well.
Also, it should be well-understood that System.Random as a source of entropy isn't very strong. As noted in the <a href="http://msdn.microsoft.com/en-us/library/system.random.aspx" rel="noreferrer">MSDN documentation</a>, you should use something derived from <code>System.Security.Cryptography.RandomNumberGenerator</code> if you're doing anything security-related. For example:
<pre><code>using System.Security.Cryptography;
</code></pre>
...
<pre><code>RNGCryptoServiceProvider rnd = new RNGCryptoServiceProvider();
string[] MyRandomArray = MyArray.OrderBy(x =&gt; GetNextInt32(rnd)).ToArray();
</code></pre>
...
<pre><code>static int GetNextInt32(RNGCryptoServiceProvider rnd)
 {
 byte[] randomInt = new byte[4];
 rnd.GetBytes(randomInt);
 return Convert.ToInt32(randomInt[0]);
 }
</code></pre>

blocks|key|1536208|text|在我的脑海中，你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1536209|public+string[]+Randomize(string[]+input)
{
++List<string>+inputList+=+input.ToList();
++string[]+output+=+new+string[input.Length];
++Random+randomizer+=+new+Random();
++int+i+=+0;

++while+(inputList.Count+>+0)
++{
++++int+index+=+r.Next(inputList.Count);
++++output[i%2B%2B]+=+inputList[index];
++++inputList.RemoveAt(index);
++}

++return+(output);
}|code-block|syntax|javascript|1536210|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Just thinking off the top of my head, you could do this:

<pre><code>public string[] Randomize(string[] input)
{
 List&lt;string&gt; inputList = input.ToList();
 string[] output = new string[input.Length];
 Random randomizer = new Random();
 int i = 0;

 while (inputList.Count &gt; 0)
 {
 int index = r.Next(inputList.Count);
 output[i++] = inputList[index];
 inputList.RemoveAt(index);
 }

 return (output);
}
</code></pre>

blocks|key|1536220|text|Random+r+=+new+Random();
List<string>+list+=+new+List(originalArray);
List<string>+randomStrings+=+new+List();

while(list.Count+>+0)
{
int+i+=+r.Random(list.Count);
randomStrings.Add(list[i]);
list.RemoveAt(i);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1536221|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>Random r = new Random();
List&lt;string&gt; list = new List(originalArray);
List&lt;string&gt; randomStrings = new List();

while(list.Count &gt; 0)
{
int i = r.Random(list.Count);
randomStrings.Add(list[i]);
list.RemoveAt(i);
}
</code></pre>

blocks|key|1536255|text|下面是一个使用OLINQ的简单方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1536256|//+Input+array
List<String>+lst+=+new+List<string>();
for+(int+i+=+0;+i+<+500;+i+%2B=+1)+lst.Add(i.ToString());

//+Output+array
List<String>+lstRandom+=+new+List<string>();

//+Randomize
Random+rnd+=+new+Random();
lstRandom.AddRange(from+s+in+lst+orderby+rnd.Next(100)+select+s);|code-block|syntax|javascript|1536257|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a simple way using OLINQ:

<pre><code>// Input array
List&lt;String&gt; lst = new List&lt;string&gt;();
for (int i = 0; i &lt; 500; i += 1) lst.Add(i.ToString());

// Output array
List&lt;String&gt; lstRandom = new List&lt;string&gt;();

// Randomize
Random rnd = new Random();
lstRandom.AddRange(from s in lst orderby rnd.Next(100) select s);
</code></pre>

blocks|key|1751300|text|下面的实现使用Fisher-Yates+algorithm，也就是Knuth+Shuffle。它在O(n)时间内运行，并就地洗牌，因此比“按随机排序”技术性能更好，尽管它的代码行更多。有关性能测量的一些比较信息，请参阅here。我已经使用过System.Random，这对于非加密目的来说很好。*|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1751301|static+class+RandomExtensions
{
++++public+static+void+Shuffle<T>+(this+Random+rng,+T[]+array)
++++{
++++++++int+n+=+array.Length;
++++++++while+(n+>+1)+
++++++++{
++++++++++++int+k+=+rng.Next(n--);
++++++++++++T+temp+=+array[n];
++++++++++++array[n]+=+array[k];
++++++++++++array[k]+=+temp;
++++++++}
++++}
}|code-block|syntax|javascript|1751302|用法：|1751303|var+array+=+new+int[]+{1,+2,+3,+4};
var+rng+=+new+Random();
rng.Shuffle(array);
rng.Shuffle(array);+//+different+order+from+first+call+to+Shuffle|1751304|*对于更长的数组，为了使(极大的)排列数量相等，有必要对每个交换运行伪随机数生成器(PRNG)多次迭代，以产生足够的熵。对于500个元素的数组，只有500个元素的一小部分！使用PRNG可以获得排列。尽管如此，Fisher-Yates算法是没有偏见的，因此混洗效果将与您使用的RNG一样好。|1751305|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Fisher%25E2%2580%2593Yates_shuffle|1|http://aspnet.4guysfromrolla.com/articles/070208-1.aspx^0|7|M|0|31|4|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]|$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|F|7|15|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|16|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|17|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|18|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|X]]]]

The following implementation uses the <a href="https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle" rel="noreferrer">Fisher-Yates algorithm</a> AKA the Knuth Shuffle. It runs in O(n) time and shuffles in place, so is better performing than the 'sort by random' technique, although it is more lines of code. See <a href="http://aspnet.4guysfromrolla.com/articles/070208-1.aspx" rel="noreferrer">here</a> for some comparative performance measurements. I have used System.Random, which is fine for non-cryptographic purposes.*

<pre><code>static class RandomExtensions
{
 public static void Shuffle&lt;T&gt; (this Random rng, T[] array)
 {
 int n = array.Length;
 while (n &gt; 1) 
 {
 int k = rng.Next(n--);
 T temp = array[n];
 array[n] = array[k];
 array[k] = temp;
 }
 }
}
</code></pre>

Usage:

<pre><code>var array = new int[] {1, 2, 3, 4};
var rng = new Random();
rng.Shuffle(array);
rng.Shuffle(array); // different order from first call to Shuffle
</code></pre>

* For longer arrays, in order to make the (extremely large) number of permutations equally probable it would be necessary to run a pseudo-random number generator (PRNG) through many iterations for each swap to produce enough entropy. For a 500-element array only a very small fraction of the possible 500! permutations will be possible to obtain using a PRNG. Nevertheless, the Fisher-Yates algorithm is unbiased and therefore the shuffle will be as good as the RNG you use.

blocks|key|1536424|text|你的解决方案是一个定制的IComparer是不安全的。排序例程要求比较器满足几个要求才能正常工作。它们中的第一个是一致性。如果对同一对对象调用比较器，则它必须始终返回相同的结果。(比较也必须是可传递的)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1536425|未能满足这些要求可能会导致排序例程中出现许多问题，包括无限循环的可能性。|1536426|对于将随机数值与每个条目相关联然后按该值排序的解决方案，这些解决方案会导致输出中的固有偏差，因为任何时候为两个条目分配相同的数值，输出的随机性都将受到影响。(在“稳定”排序例程中，输入中的第一个将是输出中的第一个。Array.Sort碰巧不稳定，但基于快速排序算法所做的分区仍然存在偏差)。|1536427|你需要对你需要的随机性做一些思考。如果您正在运行一个扑克站点，您需要加密级别的随机性来保护您免受坚定的攻击者的攻击，那么您的要求就与那些只想随机化歌曲播放列表的人非常不同。|1536428|对于歌曲列表混洗，使用种子PRNG+(如System.Random)是没有问题的。对于扑克网站，这甚至不是一个选择，你需要比任何人在stackoverflow上为你做的更困难地考虑这个问题。(使用加密RNG只是一个开始，您需要确保您的算法不会引入偏差，您有足够的熵源，并且您不会暴露任何会影响后续随机性的内部状态)。|1536429|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Jacco, your solution ising a custom IComparer isn't safe. The Sort routines require the comparer to conform to several requirements in order to function properly. First among them is consistency. If the comparer is called on the same pair of objects, it must always return the same result. (the comparison must also be transitive).

Failure to meet these requirements can cause any number of problems in the sorting routine including the possibility of an infinite loop. 

Regarding the solutions that associate a random numeric value with each entry and then sort by that value, these are lead to an inherent bias in the output because any time two entries are assigned the same numeric value, the randomness of the output will be compromised. (In a "stable" sort routine, whichever is first in the input will be first in the output. Array.Sort doesn't happen to be stable, but there is still a bias based on the partitioning done by the Quicksort algorithm).

You need to do some thinking about what level of randomness you require. If you are running a poker site where you need cryptographic levels of randomness to protect against a determined attacker you have very different requirements from someone who just wants to randomize a song playlist.

For song-list shuffling, there's no problem using a seeded PRNG (like System.Random). For a poker site, it's not even an option and you need to think about the problem a lot harder than anyone is going to do for you on stackoverflow. (using a cryptographic RNG is only the beginning, you need to ensure that your algorithm doesn't introduce a bias, that you have sufficient sources of entropy, and that you don't expose any internal state that would compromise subsequent randomness).

blocks|key|1751442|text|这篇文章已经得到了很好的回答-使用Fisher-Yates+shuffle的Durstenfeld实现，以获得快速和公正的结果。甚至还发布了一些实现，尽管我注意到有些实现实际上是不正确的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1751443|前段时间我写了几篇关于implementing+full+and+partial+shuffles+using+this+technique的文章，还有a+follow-up+post+about+how+to+check+whether+your+implementation+is+unbiased+(第二个链接是我希望增加价值的地方)，它可以用来检查任何随机算法。在第二篇文章的末尾，你可以看到随机数字选择中的一个简单错误所产生的效果。|offset|length|1751444|entityMap|0|LINK|mutability|MUTABLE|url|http://gregbeech.com/blogs/tech/archive/2008/09/03/shuffle-and-takerandom-extension-methods-for-ienumerable-lt-t-gt.aspx|1|http://gregbeech.com/blogs/tech/archive/2008/09/09/determining-the-bias-of-a-shuffle-algorithm.aspx^0|0|B|1N|0|24|23|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]|$D|U|E|V|1|W]]|A|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]|N|$5|I|J|K|A|$L|O]]]]

This post has already been pretty well answered - use a Durstenfeld implementation of the Fisher-Yates shuffle for a fast and unbiased result. There have even been some implementations posted, though I note some are actually incorrect.

I wrote a couple of posts a while back about <a href="http://gregbeech.com/blogs/tech/archive/2008/09/03/shuffle-and-takerandom-extension-methods-for-ienumerable-lt-t-gt.aspx" rel="nofollow noreferrer">implementing full and partial shuffles using this technique</a>, and (this second link is where I'm hoping to add value) also <a href="http://gregbeech.com/blogs/tech/archive/2008/09/09/determining-the-bias-of-a-shuffle-algorithm.aspx" rel="nofollow noreferrer">a follow-up post about how to check whether your implementation is unbiased</a>, which can be used to check any shuffle algorithm. You can see at the end of the second post the effect of a simple mistake in the random number selection can make.

blocks|key|1751468|text|您还可以在Matt+Howells之外创建一个扩展方法。举例说明。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1751469|+++namespace+System
++++{
++++++++public+static+class+MSSystemExtenstions
++++++++{
++++++++++++private+static+Random+rng+=+new+Random();
++++++++++++public+static+void+Shuffle<T>(this+T[]+array)
++++++++++++{
++++++++++++++++rng+=+new+Random();
++++++++++++++++int+n+=+array.Length;
++++++++++++++++while+(n+>+1)
++++++++++++++++{
++++++++++++++++++++int+k+=+rng.Next(n);
++++++++++++++++++++n--;
++++++++++++++++++++T+temp+=+array[n];
++++++++++++++++++++array[n]+=+array[k];
++++++++++++++++++++array[k]+=+temp;
++++++++++++++++}
++++++++++++}
++++++++}
++++}|code-block|syntax|javascript|1751470|然后你可以像这样使用它：|1751471|++++++++string[]+names+=+new+string[]+{
++++++++++++++++"Aaron+Moline1",+
++++++++++++++++"Aaron+Moline2",+
++++++++++++++++"Aaron+Moline3",+
++++++++++++++++"Aaron+Moline4",+
++++++++++++++++"Aaron+Moline5",+
++++++++++++++++"Aaron+Moline6",+
++++++++++++++++"Aaron+Moline7",+
++++++++++++++++"Aaron+Moline8",+
++++++++++++++++"Aaron+Moline9",+
++++++++++++};
++++++++names.Shuffle<string>();|1751472|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can also make an extention method out of Matt Howells. Example.

<pre><code> namespace System
 {
 public static class MSSystemExtenstions
 {
 private static Random rng = new Random();
 public static void Shuffle&lt;T&gt;(this T[] array)
 {
 rng = new Random();
 int n = array.Length;
 while (n &gt; 1)
 {
 int k = rng.Next(n);
 n--;
 T temp = array[n];
 array[n] = array[k];
 array[k] = temp;
 }
 }
 }
 }
</code></pre>

Then you can just use it like: 

<pre><code> string[] names = new string[] {
 "Aaron Moline1", 
 "Aaron Moline2", 
 "Aaron Moline3", 
 "Aaron Moline4", 
 "Aaron Moline5", 
 "Aaron Moline6", 
 "Aaron Moline7", 
 "Aaron Moline8", 
 "Aaron Moline9", 
 };
 names.Shuffle&lt;string&gt;();
</code></pre>

blocks|key|1751477|text|private+ArrayList+ShuffleArrayList(ArrayList+source)
{
++++ArrayList+sortedList+=+new+ArrayList();
++++Random+generator+=+new+Random();

++++while+(source.Count+>+0)
++++{
++++++++int+position+=+generator.Next(source.Count);
++++++++sortedList.Add(source[position]);
++++++++source.RemoveAt(position);
++++}++
++++return+sortedList;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1751478|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>private ArrayList ShuffleArrayList(ArrayList source)
{
 ArrayList sortedList = new ArrayList();
 Random generator = new Random();

 while (source.Count &gt; 0)
 {
 int position = generator.Next(source.Count);
 sortedList.Add(source[position]);
 source.RemoveAt(position);
 } 
 return sortedList;
}
</code></pre>

blocks|key|1751521|text|好吧，这显然是我这边的一个碰撞(道歉……)，但我经常使用一个相当通用和加密强大的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1751522|public+static+class+EnumerableExtensions
{
++++static+readonly+RNGCryptoServiceProvider+RngCryptoServiceProvider+=+new+RNGCryptoServiceProvider();
++++public+static+IEnumerable<T>+Shuffle<T>(this+IEnumerable<T>+enumerable)
++++{
++++++++var+randomIntegerBuffer+=+new+byte[4];
++++++++Func<int>+rand+=+()+=>
+++++++++++++++++++++++++++++{
+++++++++++++++++++++++++++++++++RngCryptoServiceProvider.GetBytes(randomIntegerBuffer);
+++++++++++++++++++++++++++++++++return+BitConverter.ToInt32(randomIntegerBuffer,+0);
+++++++++++++++++++++++++++++};
++++++++return+from+item+in+enumerable
+++++++++++++++let+rec+=+new+{item,+rnd+=+rand()}
+++++++++++++++orderby+rec.rnd
+++++++++++++++select+rec.item;
++++}
}|code-block|syntax|javascript|1751523|Shuffle()是任何IEnumerable上的一个扩展，因此可以使用以下命令在列表中获取从0到1000的随机顺序的数字|1751524|Enumerable.Range(0,1000).Shuffle().ToList()|1751525|当涉及到排序时，这种方法也不会给出任何惊喜，因为排序值是为序列中的每个元素生成并记住一次。|1751526|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Ok, this is clearly a bump from my side (apologizes...), but I often use a quite general and cryptographically strong method.

<pre><code>public static class EnumerableExtensions
{
 static readonly RNGCryptoServiceProvider RngCryptoServiceProvider = new RNGCryptoServiceProvider();
 public static IEnumerable&lt;T&gt; Shuffle&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable)
 {
 var randomIntegerBuffer = new byte[4];
 Func&lt;int&gt; rand = () =&gt;
 {
 RngCryptoServiceProvider.GetBytes(randomIntegerBuffer);
 return BitConverter.ToInt32(randomIntegerBuffer, 0);
 };
 return from item in enumerable
 let rec = new {item, rnd = rand()}
 orderby rec.rnd
 select rec.item;
 }
}
</code></pre>

Shuffle() is an extension on any IEnumerable so getting, say, numbers from 0 to 1000 in random order in a list can be done with

<pre><code>Enumerable.Range(0,1000).Shuffle().ToList()
</code></pre>

This method also wont give any surprises when it comes to sorting, since the sort value is generated and remembered exactly once per element in the sequence.

blocks|key|1751553|text|这是一个完整的基于the+example+provided+in+here的工作控制台解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1751554|class+Program
{
++++static+string[]+words1+=+new+string[]+{+"brown",+"jumped",+"the",+"fox",+"quick"+};

++++static+void+Main()
++++{
++++++++var+result+=+Shuffle(words1);
++++++++foreach+(var+i+in+result)
++++++++{
++++++++++++Console.Write(i+%2B+"+");
++++++++}
++++++++Console.ReadKey();
++++}

+++static+string[]+Shuffle(string[]+wordArray)+{
++++++++Random+random+=+new+Random();
++++++++for+(int+i+=+wordArray.Length+-+1;+i+>+0;+i--)
++++++++{
++++++++++++int+swapIndex+=+random.Next(i+%2B+1);
++++++++++++string+temp+=+wordArray[i];
++++++++++++wordArray[i]+=+wordArray[swapIndex];
++++++++++++wordArray[swapIndex]+=+temp;
++++++++}
++++++++return+wordArray;
++++}+++++++++
}|code-block|syntax|javascript|1751555|entityMap|0|LINK|mutability|MUTABLE|url|https://msdn.microsoft.com/en-us/library/dd537615%2528v=vs.110%2529.aspx^0|9|S|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

This is a complete working Console solution based on <a href="https://msdn.microsoft.com/en-us/library/dd537615%28v=vs.110%29.aspx" rel="nofollow">the example provided in here</a>:

<pre><code>class Program
{
 static string[] words1 = new string[] { "brown", "jumped", "the", "fox", "quick" };

 static void Main()
 {
 var result = Shuffle(words1);
 foreach (var i in result)
 {
 Console.Write(i + " ");
 }
 Console.ReadKey();
 }

 static string[] Shuffle(string[] wordArray) {
 Random random = new Random();
 for (int i = wordArray.Length - 1; i &gt; 0; i--)
 {
 int swapIndex = random.Next(i + 1);
 string temp = wordArray[i];
 wordArray[i] = wordArray[swapIndex];
 wordArray[swapIndex] = temp;
 }
 return wordArray;
 } 
}
</code></pre>

blocks|key|1751574|text|++++++++int[]+numbers+=+{0,1,2,3,4,5,6,7,8,9};
++++++++List<int>+numList+=+new+List<int>();
++++++++numList.AddRange(numbers);

++++++++Console.WriteLine("Original+Order");
++++++++for+(int+i+=+0;+i+<+numList.Count;+i%2B%2B)
++++++++{
++++++++++++Console.Write(String.Format("{0}+",numList[i]));
++++++++}

++++++++Random+random+=+new+Random();
++++++++Console.WriteLine("\n\nRandom+Order");
++++++++for+(int+i+=+0;+i+<+numList.Capacity;+i%2B%2B)
++++++++{
++++++++++++int+randomIndex+=+random.Next(numList.Count);
++++++++++++Console.Write(String.Format("{0}+",+numList[randomIndex]));
++++++++++++numList.RemoveAt(randomIndex);
++++++++}
++++++++Console.ReadLine();|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1751575|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> int[] numbers = {0,1,2,3,4,5,6,7,8,9};
 List&lt;int&gt; numList = new List&lt;int&gt;();
 numList.AddRange(numbers);

 Console.WriteLine("Original Order");
 for (int i = 0; i &lt; numList.Count; i++)
 {
 Console.Write(String.Format("{0} ",numList[i]));
 }

 Random random = new Random();
 Console.WriteLine("\n\nRandom Order");
 for (int i = 0; i &lt; numList.Capacity; i++)
 {
 int randomIndex = random.Next(numList.Count);
 Console.Write(String.Format("{0} ", numList[randomIndex]));
 numList.RemoveAt(randomIndex);
 }
 Console.ReadLine();
</code></pre>

blocks|key|1751583|text|可能是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1751584|Random+random+=+new();

string+RandomWord()
{
++++const+string+CHARS+=+"abcdefghijklmnoprstuvwxyz";
++++int+n+=+random.Next(CHARS.Length);
++++return+string.Join("",+CHARS.OrderBy(x+=>+random.Next()).ToArray())[0..n];
}|code-block|syntax|javascript|1751585|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Could be:
<pre class="lang-cs prettyprint-override"><code>Random random = new();

string RandomWord()
{
 const string CHARS = &quot;abcdefghijklmnoprstuvwxyz&quot;;
 int n = random.Next(CHARS.Length);
 return string.Join(&quot;&quot;, CHARS.OrderBy(x =&gt; random.Next()).ToArray())[0..n];
}
</code></pre>

blocks|key|1536624|text|+public+static+void+Shuffle(object[]+arr)
++++{
++++++++Random+rand+=+new+Random();
++++++++for+(int+i+=+arr.Length+-+1;+i+>=+1;+i--)
++++++++{
++++++++++++int+j+=+rand.Next(i+%2B+1);
++++++++++++object+tmp+=+arr[j];
++++++++++++arr[j]+=+arr[i];
++++++++++++arr[i]+=+tmp;
++++++++}
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1536625|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> public static void Shuffle(object[] arr)
 {
 Random rand = new Random();
 for (int i = arr.Length - 1; i &gt;= 1; i--)
 {
 int j = rand.Next(i + 1);
 object tmp = arr[j];
 arr[j] = arr[i];
 arr[i] = tmp;
 }
 }
</code></pre>

What is the best way to randomize an array of strings with .NET? My array contains about 500 strings and I'd like to create a new <code>Array</code> with the same strings but in a random order.

Please include a C# example in your answer.

Best way to randomize an array with .NET

使用.NET随机化字符串数组的最佳方法是什么？我的数组包含大约500个字符串，我想创建一个新的Array，其中包含相同的字符串，但顺序是随机的。请在您的答案中包含一个C#示例。

问使用.NET随机化数组的最佳方法
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用.NET随机化数组的最佳方法EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用.NET随机化数组的最佳方法
EN