在java下Array.Sort和（自己写的）快速排序到底那个快？

      近期做java实习题时，无意间用到了快速排序，当时因为忘记了，上网搜了一下......可搜的搜的我思考一个问题：在java下Array.Sort和（自己写的）快速排序到底那个快？

      网上有很多博主讨论过这个问题，他们做出的结论都是System.Array.Sort比自己写的排序算法要快很多，例如：http://www.cnblogs.com/Mainz/archive/2008/04/22/1165429.html的答案就是这样的！自己怀着好奇的心态在java下做了一下，可结果......

微软MSDN上对System.Array.Sort的说明： 

     “Array 中的每个元素均必须实现 IComparable 接口，才能与 array 中的其他所有元素进行比较。如果排序不能成功地完成，则结果未定义。此方法使用 QuickSort 算法。此实现执行不稳定排序；亦即，如果两元素相等，则其顺序可能不被保留。相反，稳定排序保留相等元素的顺序。 一般情况下，此方法的运算复杂度为 O(n log n)，其中 n 是 array 的 Length；最坏的情况下其运算复杂度为 O(n ^ 2)。”

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class QuickSort {
    public static void Quicksort(int[] a,int Left,int Right){
        int left,right,temp,middle;
        middle=a[(Left+Right)/2];
        left=Left;
        right=Right;
        do{
            //从左边寻找大于中间值的下标
            while(left<Right&&a[left]<middle){
                left++;
            }
            //从右边寻找小于中间值的下标
            while(right>Left&&a[right]>middle){
                right--;
            }
            //找到一对，对换他们
            //注意：如果少了等于号，会长生死循环
            if(left<=right){
                temp=a[left];
                a[left]=a[right];
                a[right]=temp;
                left++;
                right--;
            }
            
        }while(right>=left); //直到左右对换
        
        if(Left<right){
            Quicksort(a,Left,right);
        }
        
        if(Right>left){
            Quicksort(a,left,Right);
        }
    }
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner myscnner=new Scanner(System.in);
        System.out.println("请输入排序数组大小:");
   
        int n=myscnner.nextInt();
        int[] a=new int[n];
        
        Random random=new Random();
        for (int i = 0; i < a.length; i++) {
            a[i]=Math.abs(random.nextInt())%10000000;
        }
        
        //System.Array.Sort执行时间以及执行结果
        System.out.println("System.Array.Sort执行时间以及执行结果:");
        long t=System.nanoTime();
        Arrays.sort(a,0,a.length);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
        System.out.println(System.nanoTime()-t);
        
        //My QuickSort执行时间以及执行结果
        System.out.println("My QuickSort执行时间以及执行结果:");
        long t2=System.nanoTime();
        Quicksort(a,0,n-1);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
        System.out.println(System.nanoTime()-t2);
    }

}

运行结果截图：

 当数组很小时：

逐渐增大：

自己很惊奇，难道java下这个问题的答案是：Array.Sort小于（自己写的）快速排序。

不知道自己得出的结论是否正确，我多次实验过，得出的结果都是一样的！

希望看到此篇的牛人们看有没有问题？？？邮箱联系（15658081582@163.com）