你可以把原数列放到一个数组中，然后从中随机选择一个，加入到另一个数组中，并把它从原数组中删除，依次下去。

用两个数组arr1和arr2。。
arr1里面放1～200的数。。。
随机生成一个1到200的数，然后就从arr1取出，放入arr2。。
直到arr1为空。。。

不知道效率怎么样。。没测试过。。

晕掉。。跟Knight94(愚翁) 想的一样。。

我刚才在Java区看到一个算法，就是从前面199个中任意取一个数字与最后一个互换，然后再从前面198个任意取一个与第199个数字互换，再从前面197个随机取数与第198个数字互换，依次类推....

感觉有点意思。。就写一段程序。。供楼主参考。。
速度还可以。。

int []st1=new int[200];
for(int i=0;i<200;i++)
{
st1[i]=i+1;
}
ArrayList al1=new ArrayList(st1);
ArrayList al2=new ArrayList();
while(al1.Count!=0)
{
Random rad=new Random();
int n=rad.Next(0,201);
if(al1.Contains(n))
{
al2.Add(n);
this.richTextBox1.Text+=n.ToString()+" ";
al1.Remove(n);
}
}
al2就是你要的结果。。

Knight94(愚翁) 的方法效率并不高

因为最后选择到有效记录的概率越来越小，

最后一个数是 1/200,  也就是说要生成200个数

才 有可能 刚好碰上那个数

也就是 min_jie(止戈) 的实现， 速度当然可以了

因为你只生成了200个数，而且 .NET 运行得快

但是你里面的循环差不多要 200 ^ 2 / 2 次

再加上内部的 Contains 操作，差不多是 O(N^3) 的速度了

你试试 2000 个数，估计没有半天出不了结果

使用ArrayList数组和object数组,速度就会慢,

测试了一下2000个数的情况。。
第一次运行需要130秒。。
第二次运行只需70多秒。。
也不算太糟糕。。

1分钟啊~~~~

黄花菜都凉了

呵呵。。你有更好的办法？

换个数据结构肯定比这个快么

个人认为johnsuna(缘来是e)说的方法较好！1、不占额外内存空间；2、运算速度较快，只需199次即可。
给段代码：
public void randomsort(int[] arr)
{
   int k = arr.Length-1; // 要保存的位置
   Random rad=new Random();
   for( int i = 0; i < arr.Length-1; i++ ) // 执行N-1次循环，随机产生要被打乱的数据所在的位置
   {
       int idx = rad.Next(0,k+1);
       // 交换数据
       int n = arr[idx];
       arr[idx] = arr[k-1];
       arr[k-1] = n;
       // 递减要保存的位置
       k--;
    }
}

这个算法就足够随机足够好足够快，

谁不服可以挑战 :)

using System;
public class Test
{
  public static int [] Random(int n)
  {
   int [] a = new int[n];
for(int i = 0; i < n; i++) a[i] = i;
Random r = new Random();
for(int i = 0; i < n; i++)
{
int m = a[i];
int k = i + r.Next() % (n - i);
a[i] = a[k];
a[k] = m;
}
return a;
  }
  public static void Main(string[] args)
  {
   foreach(int n in Random(20)) Console.WriteLine(n);
  }
}

刚刚想到跟楼上相似的办法。。
用数组下标来控制。。

johnsuna(缘来是e) 的方法也不错，

但是有个比较搞得问题就是到底要循环几次才足够随机？

这个是很难确定的，如果光循环 N次，

有很大的概率是其中有个数没有被交换过

哦，我看错了，johnsuna的方法没有问题，

看成仅做随机交换了，不好意思 :)

也还快。。
int []st1=new int[200];
for(int i=0;i<200;i++)
{
st1[i]=i+1;
}
ArrayList al1=new ArrayList(st1);
ArrayList al2=new ArrayList();
Random rad=new Random();
int n=rad.Next(0,200);
for(int j=0;j<200;j++)
{
al2.Add(al1[n]);
this.richTextBox1.Text+=al1[n].ToString()+" ";
al1.Remove(al1[n]);
n=rad.Next(0,199-j);
}

总结一下：

private void button2_Click(object sender, System.EventArgs e)
{
arrInt = InitArray(1,100000);
arrInt = RandomSort(arrInt);
System.Text.StringBuilder sb = new System.Text.StringBuilder();
for( int i = 0; i < arrInt.Length-1; i++ )
{
sb.Append(arrInt[i].ToString() + "\r\n");
}
textBox1.Text = sb.ToString();
sb = null;
}

public int[] RandomSort(int[] arr)
{
int k = arr.Length-1; // 要保存的位置
Random rad=new Random();
for( int i = 0; i < arr.Length-1; i++ ) // 执行N-1次循环，随机产生要被打乱的数据所在的位置
{
int idx = rad.Next(0,k+1);
// 交换数据
int n = arr[idx];
arr[idx] = arr[k-1];
arr[k-1] = n;
// 递减要保存的位置
k--;
}
return arr;
}

int[] arrInt = null;
private int[] InitArray(int min, int max)
{
arrInt = new int[max - min];
for(int i = min; i < max; i++)
{
arrInt[i-min] = i;
}
return arrInt;
}
我用了一百万，速度也很快。

强，顶

速度瓶颈：
Random rad=new Random();
rad.Next(0,k+1);
有没有一个办法可以一次性保存rad的所有值，然后，每次直接调用它即可？

其实很简单了。

想一想平时玩扑克的时候是怎么洗排的就可以了。

一般洗牌，洗4次就可以了。

也就是遍历4次数组就可以了。

问题在于你所指的杂乱无章的程度是怎样定义的。
举例来说，只要是不连续的数列，就符合你所说的条件。
生成 1、3、5...199、2、4、6...200这样的序列，效率又是多高呢。

johnsuna(缘来是e) 的想法很好,可以考虑空间换时间的办法

俺的算法同5楼的一样，不是看来时间复杂度很大，学习johnsuna(缘来是e)的思想，自己再写个看看

johnsuna(缘来是e)和lloach(lloach)提供的方法不是随机分布，做一下统计就知道
int[,] arrIntStatic=null;

private void Static(int[] arr)
{
for( int i=0;i<10;i++)
{
arrIntStatic[i,arr[i]-1]++;
}
}

同意tiaoci(我挑刺，我快乐)的算法,基本上算法的增長率是線性的了.而且用內存少,只用了一個數年組.

洗牌原理就行了，随即洗个8－9次全乱了，没有必要循环200次

我的算法：如果有１－n的数需要处理，先随机生成n个随机数，然后一一和原数据对应（键为随机数，值为原数据）．比如存放在sortedlist中
然后把键排序（sortedlist是按照健排序的，所有如果用sortedlist就不用这步了）
然后按照索引的顺序取出就可以了．

private void Form1_Load(object sender, System.EventArgs e)
{
int[] st1=new int[20000];
for(int i=0;i<20000;i++)
{
st1[i]=i+1;
}
DateTime dtStart=DateTime.Now;
st1=RandomSort(st1);
DateTime dtEnd=DateTime.Now;
TimeSpan ts=dtEnd-dtStart;
StringBuilder sb=new StringBuilder();
foreach(int i in st1)
{
sb.Append(i);
}
textBox2.Text=sb.ToString();
textBox1.Text=ts.ToString();

}
private int[] RandomSort(int[] arr)
{
SortedList sl=new SortedList();
Random rad=new Random();
foreach(int i in arr)
{
int ikey;
do
{
ikey=rad.Next(1000000000);
}while(sl.ContainsKey(ikey));

sl.Add(ikey,i);
}
int count=0;
foreach(object o in sl.Keys)
{
 arr[count]=int.Parse(sl[o].ToString());
count++;
}
return arr;
}
２００００条生成速度是０.５秒，应该满足要求

个人觉得使用：
do
{
  ikey=rad.Next(1000000000);
}
while(sl.ContainsKey(ikey));
语句后效率会降低，因为需要遍历搜索。

经过分布统计确定，1-200在各位置上出现的概率是平均分布
public static int GetRandomSeed()
{
byte[] rndBytes = new byte[4];
System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
rng.GetBytes(rndBytes);
return BitConverter.ToInt32(rndBytes,0);
}
public static int[] GetRandomSort(int[] arr)
{
int k = arr.Length; // 要保存的位置
Random rad=new Random(GetRandomSeed());
for( int i = 0; i < k-1; i++ ) // 执行N-1次循环，随机产生要被打乱的数据所在的位置
{
int idx = rad.Next(0,k-i);
// 交换数据
int n = arr[idx];
arr[idx] = arr[k-i-1];
arr[k-i-1] = n;
}
return arr;
}
MSN:liangpz_2000@hotmail.com QQ:18692679

这个算法在经济适用房摇号系统中可以使用，楼主赶紧给我加分