插入排序与希尔排序效率对比

最新推荐文章于 2024-04-24 16:23:58 发布

转载最新推荐文章于 2024-04-24 16:23:58 发布 · 194 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/shking/blog/163362

文章标签：

#数据结构与算法

本文通过具体的Java代码实现，对比了希尔排序与插入排序两种算法的执行效率。实验结果显示，在相同的数据集下，希尔排序的平均执行时间短于插入排序，证明了希尔排序在处理大量数据时具有更高的效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

为什么80%的码农都做不了架构师？>>>

public class Suanfa {
	
	final static int COUNT = 500000;
	final static int[] array = new int[COUNT];
	//初始化数据
	static {
		Random random  = new Random();
		for (int i = 0; i < COUNT; i++) {
			array[i] = random.nextInt(COUNT * 5);
		}
		print(array);
		System.out.println("..............排序中..............");
	}
	
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		 long h = test(new Hill());
		 System.out.println("希尔排序 平均时间 " + h);
		 long i = test(new Insertion());
		 System.out.println("插入排序 平均时间 " + i);
	}
	
	static long test(Sort sort) throws InterruptedException, ExecutionException{
		FutureTask<Long> future = new FutureTask<Long>(new SortThread(sort,array));
		new Thread(future).start();
		return future.get();
	}
	
	//排序线程
	static class SortThread implements Callable<Long> {
		private Sort sort;
		private int[] item;
		public SortThread(Sort sort,int[] item){
			this.sort = sort;
			this.item = Arrays.copyOf(item, item.length);
		}
		public Long call() throws Exception {
			long s = System.currentTimeMillis();
			int[] ss = sort.get(item);
			long e = System.currentTimeMillis();
			print(ss);
			return e - s;
		}
	}
	
	//排序接口
	interface Sort {
		int[] get(int items[]);
	}
	
	//希尔排序
	static class Hill implements Sort{
		public int[] get(int item[]) {
			int len = item.length;
			int i,j;
			int d = len >> 1;
			while(d > 0) {
				for(i=d;i<len;i++){
					j = i-d;
					while(j >= 0 && item[j] > item[j+d]){
						int temp = item[j];
						item[j] = item[j+d];
						item[j+d] = temp;
						j -= d;
					}
				}
				d = d >> 1;
			}
			return item;
		}
	}
	
	//插入排序
	static class Insertion implements Sort{
		public int[] get(int item[]) {
			for (int i = 1; i < item.length; i++) {
				if(item[i] < item[i-1]) {
					int k = item[i];
					int j = i - 1;
					item[i] = item[i-1];
					while(j > -1 && k < item[j]){
						item[j+1]=item[j];
						j--;
					}
					item[j+1] = k;
				}
			}
			return item;
		}
	}
	
	
	static void print(int[] items){
/*		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < items.length; i++) {
			sb.append(items[i]).append(",");
		}
		sb.deleteCharAt(sb.length()-1);
		System.out.println(sb);*/
	}
	
}

执行效率

还是希尔排序效率高