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

如下，一组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[n];
            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