排序算法时间比较

下面是冒泡排序， 选择排序， 插入排序， 快速排序， 归并排序， 堆排序和他们执行时间比较

import java.util.ArrayList;
import java.util.List;
import java.util.Random;


public class Sort {
	public static void popsort(List<Integer> A){
		int n = A.size();
		int count = 0;
		for(int i=n-1; i>0; i--){
			for(int j=0; j<i; j++){
				count++;
				if(A.get(j)>A.get(j+1)){
					int tmp = A.get(j);
					A.set(j, A.get(j+1));
					A.set(j+1, tmp);
				}
			}
		}
		System.out.println("count="+count);
	}
	public static void selectsort(List<Integer> A){
		int n = A.size();
		int count = 0;
		for(int i=0; i<n; i++){
			int min = A.get(i), mp = i;
			for(int j=i+1; j<n; j++){
				count++;
				if(A.get(j)<min){
					min = A.get(j);
					mp = j;
				}
			}
			if(count!=i){
				A.set(mp, A.get(i));
				A.set(i, min);
			}
		}
		System.out.println("count = "+count);
	}
	public static void insertsort(List<Integer> A){
		int n = A.size();
		int count = 0;
		for(int i=2; i<n; i++){
			int tmp = A.get(i), mp = i;
			for(int j=i-1; j>=0; j--){
				count ++;
				if(A.get(j)>tmp){
					A.set(j+1, A.get(j));
					mp = j;
				}
			}
			if(mp!=i){
				A.set(mp, tmp);
			}
		}
		System.out.println("count = "+count );
	}
	public static int quicksort(List<Integer> A, int s, int e){
		int X = A.get(s), i = s, j = e;
		int count = 0;
		while(i!=j){
			while(i<j&&A.get(j)>X) {
				j--;
				count++;
			}
			if(i==j) break;
			A.set(i, A.get(j));
			i++;
			while(i<j&&A.get(i)<X){
				count++;
				i++;
			}
			if(i==j) break;
			A.set(j, A.get(i));
			count++;
			j--;
		}
		A.set(i, X);
		if(i-1>s) count += quicksort(A, s, i-1);
		if(j+1<e) count += quicksort(A, j+1, e);
		return count;
	}
	static List<Integer> merge(List<Integer> list1, List<Integer> list2){
		List<Integer> output = new ArrayList<Integer>();
		int m = list1.size(), n = list2.size();
		int i = 0, j = 0;
		while(i<m&&j<n){
			if(list1.get(i)<list2.get(j)){
				output.add(list1.get(i));
				i++;
			}else{
				output.add(list2.get(j));
				j++;
			}
		}
		if(i!=m) output.addAll(list1.subList(i, m));
		if(j!=n) output.addAll(list2.subList(j, n));
		return output;
	}
	static List<Integer> mergesort(List<Integer> list){
		int n = list.size();
		if(n<2) return list;
		List<Integer> output1 = mergesort(list.subList(0, n/2)), output2 = mergesort(list.subList(n/2, n));
		List<Integer> output = merge(output1, output2);
		return output;
	}
	static void adjust(List<Integer> tree, int root){
		int n = tree.size(), left = (root+1)*2-1, right = (root+1)*2;
		if(left>n-1) return;
		int swap = left;
		if(right<n-1&&tree.get(left)>tree.get(right)) swap = right;
		if(tree.get(root)>tree.get(swap)){
			int tmp = tree.get(root);
			tree.set(root, tree.get(swap));
			tree.set(swap, tmp);
			adjust(tree, swap);
		}
	}
	static void initTree(List<Integer> tree){
		int n = tree.size(), last = (n-2)/2;
		for(int i=last; i>=0; i--) adjust(tree, i);
	}
	static List<Integer> treesort(List<Integer> tree){
		initTree(tree);
		List<Integer> output = new ArrayList<Integer>();
		while(tree.size()>1){
			output.add(tree.get(0));
			tree.set(0, tree.remove(tree.size()-1));
			adjust(tree, 0);
		}
		output.add(tree.get(0));
		return output;
	}
	public static void main(String [] args){
		List<Integer> A = new ArrayList<Integer>();
		Random random = new Random();
		for(int i=0; i<10000; i++){
			A.add(random.nextInt());
		}
		long old = System.currentTimeMillis();
		popsort(A);
		System.out.println("popsort time = "+(System.currentTimeMillis()-old));


		System.out.println();
		List<Integer> A1 = new ArrayList<Integer>();
		for(int i=0; i<10000; i++){
			A1.add(random.nextInt());
		}
		old = System.currentTimeMillis();
		selectsort(A1);
		System.out.println("selectsort time = "+(System.currentTimeMillis()-old));

		System.out.println();
		List<Integer> A2 = new ArrayList<Integer>();
		for(int i=0; i<10000; i++){
			A2.add(random.nextInt());
		}
		old = System.currentTimeMillis();
		insertsort(A2);
		System.out.println("insertsort time = "+(System.currentTimeMillis()-old));
		
		
		System.out.println();
		List<Integer> A3 = new ArrayList<Integer>();
		for(int i=0; i<10000; i++){
			A3.add(random.nextInt());
		}
		old = System.currentTimeMillis();
		System.out.println("count =" + quicksort(A3, 0, A3.size()-1));
		System.out.println("quicksort time = "+(System.currentTimeMillis()-old));
		
		System.out.println();
		List<Integer> list = new ArrayList<Integer>();
		for(int i=0; i<10000; i++){
			list.add(random.nextInt());
		}
		old = System.currentTimeMillis();
		List<Integer> output = mergesort(list);
		System.out.println("mergesort time = "+(System.currentTimeMillis()-old));
		
		System.out.println();
		List<Integer> tree = new ArrayList<Integer>();
		for(int i=0; i<10000; i++){
			tree.add(random.nextInt());
		}
		old = System.currentTimeMillis();
		List<Integer> output1 = treesort(tree);
		System.out.println("treesort time = "+(System.currentTimeMillis()-old));
		
		
	}

}

执行时间

popsort time = 608

selectsort time = 83

insertsort time = 119

quicksort time = 12

mergesort time = 73

treesort time = 29