谁能把这个程序的性能提升一倍？---并行排序算法

如下，一组4元矢量的排序，如何把排序时间缩减一半？可以用并行算法。

using System;
using System.Collections.Generic;
using System.Diagnostics;

namespace Vector4Test
{
public class Vector
{
public double W;
public double X;
public double Y;
public double Z;
public double T;
}

internal class VectorComparer : IComparer<Vector>
{
public int Compare(Vector c1, Vector c2)
{
if (c1 == null || c2 == null)
throw new ArgumentNullException("Both objects must not be null");
double x = Math.Sqrt(Math.Pow(c1.X, 2)
+ Math.Pow(c1.Y, 2)
+ Math.Pow(c1.Z, 2)
+ Math.Pow(c1.W, 2));
double y = Math.Sqrt(Math.Pow(c2.X, 2)
+ Math.Pow(c2.Y, 2)
+ Math.Pow(c2.Z, 2)
+ Math.Pow(c2.W, 2));
if (x > y)
return 1;
else if (x < y)
return -1;
else
return 0;
}
}
internal class VectorComparer2 : IComparer<Vector> {
public int Compare(Vector c1, Vector c2) {
if (c1 == null || c2 == null)
throw new ArgumentNullException("Both objects must not be null");
if (c1.T > c2.T)
return 1;
else if (c1.T < c2.T)
return -1;
else
return 0;
}
}

internal class Program
{
private static void Main(string[] args)
{
Vector[] vectors = GetVectors();
var watch1 = new Stopwatch();
watch1.Start();
A(vectors);
watch1.Stop();
Console.WriteLine("A sort time: " + watch1.Elapsed);
vectors = GetVectors();
watch1.Reset();
watch1.Start();
B(vectors);
watch1.Stop();
Console.WriteLine("B sort time: " + watch1.Elapsed);
vectors = GetVectors();
watch1.Reset();
watch1.Start();
C(vectors);
watch1.Stop();
Console.WriteLine("C sort time: " + watch1.Elapsed);
Console.ReadKey();
}

private static Vector[] GetVectors()
{
int n = 1 << 15;
var vectors = new Vector
;
var random = new Random();
for (int i = 0; i < n; i++)
{
vectors[i] = new Vector();
vectors[i].X = random.NextDouble();
vectors[i].Y = random.NextDouble();
vectors[i].Z = random.NextDouble();
vectors[i].W = random.NextDouble();
}
return vectors;
}

private static void A(Vector[] vectors)
{
Array.Sort(vectors, new VectorComparer());
}

private static void B(Vector[] vectors) {
int n = vectors.Length;
for (int i = 0; i < n; i++)
{
Vector c1 = vectors[i];
c1.T = Math.Sqrt(Math.Pow(c1.X, 2)
+ Math.Pow(c1.Y, 2)
+ Math.Pow(c1.Z, 2)
+ Math.Pow(c1.W, 2));
}
Array.Sort(vectors,new VectorComparer2());
}
private static void C(Vector[] vectors) {
int n = vectors.Length;
for (int i = 0; i < n; i++) {
Vector c1 = vectors[i];
c1.T = Math.Sqrt(c1.X * c1.X
+ c1.Y * c1.Y
+ c1.Z * c1.Z
+ c1.W * c1.W);
}
Array.Sort(vectors, new VectorComparer2());
}

}
}

我晕，刚开始我用的算法A，后来又写了个算法B，我还没用并行算法呢，一看B方法比A方法时间缩短了差不多两个数量级，如下

A sort time: 00:00:00.5346475
B sort time: 00:00:00.0169736
太奇怪了也，难道我的B算法二级缓存命中率比较高？谁能再把我的B方法消耗时间再降低一半，可以用任何语言，Vector类等也可以用自己的数据类型，比如结构啦，四维数组啥的，随意，只要是四元的矢量，每个分量是随机生成的，然后每个矢量的长度是根号下每个分量的平方和，满足这个条件就行。

modify by wawa at 2009-04-22 06:42

应大家回帖要求，

1、把随机数种子初始的语句放到了循环外面

2、每次执行排序重新获取新的乱序Vector

3、把B方法直接对计算出来的double[]排序换成了对对vector[]的排序，因为之前的代码实际上没有对vector[]排序

4、把Vector类增加了值T，用来保存该Vector的长度。

我这里结果如下

A sort time: 00:00:00.6661531
B sort time: 00:00:00.0423115
C sort time: 00:00:00.0302426