千万级别的希尔排序和快速排序性能测试

排序算法大家肯定都知道有什么了，时间复杂度也是到处都有，但是他们之间的差距并不直观，这里做个简单测试，仅供参考，一共测试了三个算法，直接插入排序，希尔插入排序，Arrays类自带的sort快速排序，分别做了千万级别的平均数测试和逆序数测试，对于最坏情况，对不起我做不到。。。这里建立数组的时间大概为300到400毫秒，这个主要是对比差距，绝对的数据并没有什么意义

package test1;

import java.util.Arrays;

/**
 * 测试千万级别的希尔排序和快速排序
 */
public class Sort {
	
	public static  int[] random(int n) {	
		int[] text = new int[n];
		for (int i = 0; i < text.length; i++) {
			text[i]=(int)(Math.random()*100); //生成100以内的随机数
		}			
		return text;
	}
	
	public static int[] reverse(int n) {
		int [] a =new int[n];
		int [] b =new int[n];
		for (int i = 0; i < n-1; i++) {
			a[i]=(int)(Math.random()*100); //生成100以内的逆序数
		}
		Arrays.sort(a);
		for (int i = 0; i < n-1; i++) {
			b[i] = a[n - i - 1];
		}
		return b;
	}
	
	public void insertSort(int n) {
		long start = System.currentTimeMillis();
		int[] a = random(n);
		int temp = 0;
		int b = 0;
		for (int i = 0; i < a.length; i++) {
			temp = a[i];
			for ( b = i; b > 0 && temp < a[b-1]; b--) {
				a[b] = a[b-1];
			}
			a[b] = temp;
		}
		long end = System.currentTimeMillis();	 
		System.out.println("完全插入排序完成的时间："+(end - start)+"毫秒");
	}
	
	public void shellSort(int[] a) {
		long start = System.currentTimeMillis();
		int n =a.length;
		int j,gap;
		for (gap = n/2; gap > 0; gap /=2) {
			for (j = gap; j < n; j++) {
				if (a[j]<a[j-gap]) {
				int temp = a[j];
				int k = j -gap;
				while (k>=0&&a[k]>temp) {
					a[k+gap] = a[k];
					k-=gap;
				}
				a[k+gap]=temp;
				}	
			}
		}		
		long end = System.currentTimeMillis();
		System.out.println("希尔插入排序完成的时间："+(end - start)+"毫秒");
	}
	
	public void arraySort(int[] n) {
		long start = System.currentTimeMillis();	
		Arrays.sort(n);
		long end = System.currentTimeMillis();
		System.out.println("快速排序完成的时间："+(end - start)+"毫秒");
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Sort a1 = new Sort();	
		int [] a = random(10000000);
		int [] b = random(10000000);
		int [] c = reverse(10000000);
		int [] d = reverse(10000000);
			a1.insertSort(100000);	//10万级别 随机数
			a1.arraySort(a);	//千万级别 随机数			
			a1.shellSort(b); 	//千万级别	随机数	
			a1.arraySort(c);	//千万级别	逆序数
			a1.shellSort(d);	//千万级别	逆序数
	}	
}

最后贴上连续3次的结果

第一次：

完全插入排序完成的时间：4404毫秒（随机数）
快速排序完成的时间：312毫秒（随机数）
希尔插入排序完成的时间：1554毫秒（随机数）
快速排序完成的时间：70毫秒（逆序数）
希尔插入排序完成的时间：508毫秒（逆序数）

第二次：

完全插入排序完成的时间：4739毫秒（随机数）
快速排序完成的时间：334毫秒（随机数）
希尔插入排序完成的时间：1687毫秒（随机数）
快速排序完成的时间：69毫秒（逆序数）
希尔插入排序完成的时间：410毫秒（逆序数）

第三次

完全插入排序完成的时间：5163毫秒（随机数）
快速排序完成的时间：412毫秒（随机数）
希尔插入排序完成的时间：2381毫秒（随机数）
快速排序完成的时间：90毫秒（逆序数）
希尔插入排序完成的时间：631毫秒（逆序数）

总结：这里发现逆序数排序居然比随机数快那么多，可能是都是100以为的数，会比较快，对于随机数参考价值更大一点，可以看出希尔排序比快速排序慢5倍左右（千万级），而直接插入排序可以看见仅仅10万级别就快5000秒了，完全不是一个等级的，当然快速排序也有很多种，这里选的最为官方，看了下源码比较这两个算法来说还是挺麻烦的。所以这东西了解一下就好了，基本上是没有太大的优化空间了。