blocks|key|1667383|text|Fisher-Yates+shuffle是一个很好的线性时间混洗算法。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1667384|你会发现你提出的算法的一个问题是，当你接近混洗结束时，你的循环将花费大量时间寻找尚未交换的随机选择的元素。一旦到达要交换的最后一个元素，这可能需要一段不确定的时间。|1667385|此外，如果要排序的元素数量为奇数，则您的算法似乎永远不会终止。|1667386|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Fisher-Yates_shuffle^0|0|K|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

A good linear-time shuffling algorithm is the <a href="http://en.wikipedia.org/wiki/Fisher-Yates_shuffle" rel="noreferrer">Fisher-Yates shuffle</a>.

One problem you'll find with your proposed algorithm is that as you near the end of the shuffle, your loop will spend a lot of time looking for randomly chosen elements that have not yet been swapped. This may take an indeterminate amount of time once it gets to the last element to swap.

Also, it looks like your algorithm will never terminate if there are an odd number of elements to sort.

blocks|key|1452390|text|为了提高效率，您可以保留一组已交换的值/索引，而不是用于指示它们已交换的布尔值。从剩余的池中选择您的随机掉期指数。当池为0时，或者当你通过初始列表时，你就完成了。您没有可能尝试选择一个随机的掉期索引值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1452391|进行交换时，只需将它们从池中删除即可。|1452392|对于您正在查看的数据大小来说，这并不是什么大问题。|1452393|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

To improve your efficiency you can keep a set of values/indices that have been swapped rather than a boolean for indicating they were swapped. Pick your randomized swap index from the remaining pool. When the pool is 0, or when you made it through the initial list then you are done. You don't have the potential to try to select a random swap index value. 

When you do a swap, just remove them from the pool.

For the size of data you are looking at it is no big deal.

blocks|key|1667466|text|我不确定效率系数，但如果您不反对使用ArrayList，我使用了类似于以下内容的内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1667467|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;
}|code-block|syntax|javascript|1667468|使用这种方法，您不必担心中间交换。|1667469|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|$]]

I am not sure of the efficiency factor, but I have used something similar to the following, if you aren't opposed to using an ArrayList:

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

Using this, you do not have to worry about the intermediate swapping.

blocks|key|1452443|text|像这样的东西不会起作用吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1452444|var+list+=+new[]{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
var+random+=+new+Random();
list.Sort((a,b)=>random.Next(-1,1));|code-block|syntax|javascript|1452445|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|$]]

Wouldn't something like this work?

<pre><code>var list = new[]{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
var random = new Random();
list.Sort((a,b)=&gt;random.Next(-1,1));
</code></pre>

blocks|key|1667489|text|static+Random+random+=+new+Random();

public+static+IEnumerable<T>+RandomPermutation<T>(IEnumerable<T>+sequence)
{
++++T[]+retArray+=+sequence.ToArray();


++++for+(int+i+=+0;+i+<+retArray.Length+-+1;+i+%2B=+1)
++++{
++++++++int+swapIndex+=+random.Next(i,+retArray.Length);
++++++++if+(swapIndex+!=+i)+{
++++++++++++T+temp+=+retArray[i];
++++++++++++retArray[i]+=+retArray[swapIndex];
++++++++++++retArray[swapIndex]+=+temp;
++++++++}
++++}

++++return+retArray;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1667490|修改为处理列表或其他实现IEnumerable的对象|unstyled|1667491|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>static Random random = new Random();

public static IEnumerable&lt;T&gt; RandomPermutation&lt;T&gt;(IEnumerable&lt;T&gt; sequence)
{
 T[] retArray = sequence.ToArray();


 for (int i = 0; i &lt; retArray.Length - 1; i += 1)
 {
 int swapIndex = random.Next(i, retArray.Length);
 if (swapIndex != i) {
 T temp = retArray[i];
 retArray[i] = retArray[swapIndex];
 retArray[swapIndex] = temp;
 }
 }

 return retArray;
}
</code></pre>

modified to handle lists or other objects implementing IEnumerable

blocks|key|1667546|text|我们可以为此创建一个扩展方法，以获得任意IList集合的随机枚举器|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1667547|class+Program
{
++++static+void+Main(string[]+args)
++++{
++++++++IList<int>+l+=+new+List<int>();
++++++++l.Add(7);
++++++++l.Add(11);
++++++++l.Add(13);
++++++++l.Add(17);

++++++++foreach+(var+i+in+l.AsRandom())
++++++++++++Console.WriteLine(i);

++++++++Console.ReadLine();
++++}
}


public+static+class+MyExtensions
{
++++public+static+IEnumerable<T>+AsRandom<T>(this+IList<T>+list)
++++{
++++++++int[]+indexes+=+Enumerable.Range(0,+list.Count).ToArray();
++++++++Random+generator+=+new+Random();

++++++++for+(int+i+=+0;+i+<+list.Count;+%2B%2Bi+)
++++++++{
++++++++++++int+position+=+generator.Next(i,+list.Count);

++++++++++++yield+return+list[indexes[position]];

++++++++++++indexes[position]+=+indexes[i];
++++++++}
++++}
}+++|code-block|syntax|javascript|1667548|这对我们想要随机枚举的列表的索引使用反向Fisher-Yates随机置乱。它有点大(分配4*list.Count字节)，但运行时间为O(n)。|1667549|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|$]]

We can make an extension method out of this to get a Random enumerator for any IList collection

<pre><code>class Program
{
 static void Main(string[] args)
 {
 IList&lt;int&gt; l = new List&lt;int&gt;();
 l.Add(7);
 l.Add(11);
 l.Add(13);
 l.Add(17);

 foreach (var i in l.AsRandom())
 Console.WriteLine(i);

 Console.ReadLine();
 }
}


public static class MyExtensions
{
 public static IEnumerable&lt;T&gt; AsRandom&lt;T&gt;(this IList&lt;T&gt; list)
 {
 int[] indexes = Enumerable.Range(0, list.Count).ToArray();
 Random generator = new Random();

 for (int i = 0; i &lt; list.Count; ++i )
 {
 int position = generator.Next(i, list.Count);

 yield return list[indexes[position]];

 indexes[position] = indexes[i];
 }
 }
} 
</code></pre>

This uses a reverse Fisher-Yates shuffle on the indexes of the list we want to randomly enumerate through. Its a bit of a size hog (allocating 4*list.Count bytes), but runs in O(n).

blocks|key|1667602|text|我使用临时Hashtable创建了一个方法，允许Hashtable的自然键排序随机化。只需添加、读取和丢弃即可。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1667603|int+min+=+1;
int+max+=+100;
Random+random;
Hashtable+hash+=+new+Hashtable();
for+(int+x+=+min;+x+<=+max;+x%2B%2B)
{
++++random+=+new+Random(DateTime.Now.Millisecond+%2B+x);
++++hash.Add(random.Next(Int32.MinValue,+Int32.MaxValue),+x);
}
foreach+(int+key+in+hash.Keys)
{
++++HttpContext.Current.Response.Write(" "+%2B+hash[key]+%2B+"::"+%2B+key);
}
hash.Clear();+//+cleanup|code-block|syntax|javascript|1667604|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|$]]

I made a method using a temporary Hashtable, allowing the Hashtable's natural key sort to randomize. Simply add, read and discard.

<pre><code>int min = 1;
int max = 100;
Random random;
Hashtable hash = new Hashtable();
for (int x = min; x &lt;= max; x++)
{
 random = new Random(DateTime.Now.Millisecond + x);
 hash.Add(random.Next(Int32.MinValue, Int32.MaxValue), x);
}
foreach (int key in hash.Keys)
{
 HttpContext.Current.Response.Write("&lt;br/&gt;" + hash[key] + "::" + key);
}
hash.Clear(); // cleanup
</code></pre>

blocks|key|1452588|text|itemList.OrderBy(x=>Guid.NewGuid()).Take(amount).ToList()|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1452589|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>itemList.OrderBy(x=&gt;Guid.NewGuid()).Take(amount).ToList()
</code></pre>

blocks|key|1667667|text|ICR的答案是非常快的，但是结果数组不是正态分布的。如果你想要一个正态分布，代码如下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1667668|++++public+static+IEnumerable<T>+RandomPermutation<T>(this+IEnumerable<T>+sequence,+int+start,int+end)
++++{
++++++++T[]+array+=+sequence+as+T[]+??+sequence.ToArray();

++++++++var+result+=+new+T[array.Length];

++++++++for+(int+i+=+0;+i+<+start;+i%2B%2B)
++++++++{
++++++++++++result[i]+=+array[i];
++++++++}
++++++++for+(int+i+=+end;+i+<+array.Length;+i%2B%2B)
++++++++{
++++++++++++result[i]+=+array[i];
++++++++}

++++++++var+sortArray=new+List<KeyValuePair<double,T>>(array.Length-start-(array.Length-end));
++++++++lock+(random)
++++++++{
++++++++++++for+(int+i+=+start;+i+<+end;+i%2B%2B)
++++++++++++{
++++++++++++++++sortArray.Add(new+KeyValuePair<double,+T>(random.NextDouble(),+array[i]));
++++++++++++}
++++++++}

++++++++sortArray.Sort((i,j)=>i.Key.CompareTo(j.Key));

++++++++for+(int+i+=+start;+i+<+end;+i%2B%2B)
++++++++{
++++++++++++result[i]+=+sortArray[i+-+start].Value;
++++++++}

++++++++return+result;
++++}|code-block|syntax|javascript|1667669|请注意，在我的测试中，此算法比ICR提供的算法慢6倍，但是这是我能想出的获得正态结果分布的唯一方法|1667670|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|$]]

ICR's answer is very fast, but the resulting arrays aren't distributed normally. If you want a normal distribution, here's the code:

<pre><code> public static IEnumerable&lt;T&gt; RandomPermutation&lt;T&gt;(this IEnumerable&lt;T&gt; sequence, int start,int end)
 {
 T[] array = sequence as T[] ?? sequence.ToArray();

 var result = new T[array.Length];

 for (int i = 0; i &lt; start; i++)
 {
 result[i] = array[i];
 }
 for (int i = end; i &lt; array.Length; i++)
 {
 result[i] = array[i];
 }

 var sortArray=new List&lt;KeyValuePair&lt;double,T&gt;&gt;(array.Length-start-(array.Length-end));
 lock (random)
 {
 for (int i = start; i &lt; end; i++)
 {
 sortArray.Add(new KeyValuePair&lt;double, T&gt;(random.NextDouble(), array[i]));
 }
 }

 sortArray.Sort((i,j)=&gt;i.Key.CompareTo(j.Key));

 for (int i = start; i &lt; end; i++)
 {
 result[i] = sortArray[i - start].Value;
 }

 return result;
 }
</code></pre>

Note that in my tests, this algorithm was 6 times slower than the one ICR provided, however this is the only way I could come up with to get a normal result distribution

blocks|key|1667709|text|下面是什么：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1667710|System.Array.Sort(arrayinstance,+RandomizerMethod);
...
//any+evoluated+random+class+could+do+it+!
private+static+readonly+System.Random+Randomizer+=+new+System.Random();

private+static+int+RandomizerMethod<T>(T+x,+T+y)
++++where+T+:+IComparable<T>
{
++++if+(x.CompareTo(y)+==+0)
++++++++return+0;

++++return+Randomizer.Next().CompareTo(Randomizer.Next());
}|code-block|syntax|javascript|1667711|瞧！|1667712|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|$]]

what about :

<pre><code>System.Array.Sort(arrayinstance, RandomizerMethod);
...
//any evoluated random class could do it !
private static readonly System.Random Randomizer = new System.Random();

private static int RandomizerMethod&lt;T&gt;(T x, T y)
 where T : IComparable&lt;T&gt;
{
 if (x.CompareTo(y) == 0)
 return 0;

 return Randomizer.Next().CompareTo(Randomizer.Next());
}
</code></pre>

voila!

blocks|key|1667752|text|这是我使用的。这肯定不是最快的，但对于大多数情况来说，它可能已经足够好了，最重要的是，它非常简单。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1667753|IEnumerable<ListItem>+list+=+...;
Random+random+=+new+Random();+//+important+to+not+initialize+a+new+random+in+the+OrderBy()+function
return+list.OrderBy(i+=>+random.Next());|code-block|syntax|javascript|1667754|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 is what I used.
This is surely not the fastest one, but it is probably good enough for most cases and most importantly, it is very simple.

<pre class="lang-c# prettyprint-override"><code>IEnumerable&lt;ListItem&gt; list = ...;
Random random = new Random(); // important to not initialize a new random in the OrderBy() function
return list.OrderBy(i =&gt; random.Next());
</code></pre>

I need to randomly 'sort' a list of integers (0-1999) in the most efficient way possible. Any ideas?

Currently, I am doing something like this:

<pre><code>bool[] bIndexSet = new bool[iItemCount];

for (int iCurIndex = 0; iCurIndex &lt; iItemCount; iCurIndex++)
{
 int iSwapIndex = random.Next(iItemCount);
 if (!bIndexSet[iSwapIndex] &amp;&amp; iSwapIndex != iCurIndex)
 {
 int iTemp = values[iSwapIndex];
 values[iSwapIndex] = values[iCurIndex];
 values[iCurIndex] = values[iSwapIndex];
 bIndexSet[iCurIndex] = true;
 bIndexSet[iSwapIndex] = true;
 }
}
</code></pre>

Most efficient way to randomly "sort" (Shuffle) a list of integers in C#

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我需要以最有效的方式随机‘排序’一个整数列表(0-1999)。有什么想法吗？目前，我正在做这样的事情：bool[] bIndexSet = new bool[iItemCount];for (int iCurIndex = 0; iCurIndex < iItemCount; iCurIndex++){ int ...

问在C#中随机“排序”(混洗)整数列表的最有效方法
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C#中随机“排序”(混洗)整数列表的最有效方法EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C#中随机“排序”(混洗)整数列表的最有效方法
EN