[java]排序算法总结

用java写了一个排序算法的总结，可初步用来比较排序算法的效率

使用代理模式，在排序开始和结束时记录机器时间，计算耗时

1. 定义排序接口

public interface sort {
	void dosort(int[] array,int beg,int end);	
}

2. 随机数生成器，测试用

public class RandNums {
	static Random rand=new Random();
	static int[] getIntArrays(int size,int low_bound,int up_bound)
	{
		return rand.ints(size,low_bound,up_bound).toArray();
	}
}

3. 实现代理对象的方法

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyInvocationHandler implements InvocationHandler {
	
	private long time_beg;
	private Object target;
	
	void setTarget(Object target)
	{
		this.target=target;
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// TODO Auto-generated method stub
		
		time_beg=System.currentTimeMillis();
		
		Object result = method.invoke(target,args);
		
		long time_cost=(System.currentTimeMillis()-time_beg);
		System.out.println("time cost: " + time_cost);
		
		return result;
	}
}

4.为制定的target生成动态代理

import java.lang.reflect.Proxy;

public class MyProxyFactory {
	public static Object getProxy(Object target)
	{
		MyInvocationHandler handler=new MyInvocationHandler();
		handler.setTarget(target);
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);
	}
}

5. 排序的具体实现

class QuickSort implements sort {

	@Override
	public void dosort(int[] array,int beg,int end) {
		// TODO Auto-generated method stub
		//1. 选择一个值作为轴  中间值 记录在temp中
		//2. 将轴值与末尾值swap
		//3. 从前往后扫描  如果遇到比轴值大的放在末尾
		//4. 从后往前扫描
		//5. 因为有些算法设计到递归调用，需要制定数组的开始和结束下边
		
		
		//当规模比较小时 使用插排
		if((end-beg+1) < 28)
		{
			sort is=new InsertSort();
			is.dosort(array, beg, end);
		}
		else
		{
			int mid=(beg+end)/2;
			int temp=array[mid];
			array[mid]=array[end];
			int j=end;
			int i=beg;
			while(i<j)
			{
				while(i<j && array[i]<=temp) i++;//此处需要包含等号 否则如果包含相等的元素 死循环
				array[j]=array[i];
				while(i<j && array[j]>=temp) j--;
				array[i]=array[j];
			}
			array[i]=temp;

			dosort(array,beg,i-1);

			dosort(array,i+1,end);
		}
		
	}
	static public void main(String[] args){
		int[] array=RandNums.getIntArrays(30,1,100);
		for(int i:array)
			System.out.print(" "+i);
		
		System.out.print('\n');
		QuickSort qs=new QuickSort();
		
		qs.dosort(array,0,array.length-1);
		
		for(int i:array)
			System.out.print(" "+i);
		
		System.out.print('\n');
		
	}

}


class RecursiveSort implements sort{
	@Override
	public void dosort(int[] array,int beg,int end){
		//1. 将array分成有序的两部分
		//2. 将有序的两部分组合起来
//		if(beg>=end)
//			return;
		if((end-beg+1) < 28)
		{
			sort is=new InsertSort();
			is.dosort(array, beg, end);
		}else
		{
		
			int mid = (beg + end) / 2;
			dosort(array, beg, mid);
			dosort(array, mid + 1, end);

			merge(array, beg, mid, end);
		}
		
	}
	void merge(int[] array,int beg,int mid,int end){
		//将 beg-mid   mid+1-end有序数组组合起立
		int left_size=mid-beg+1;
		int[] left=new int[left_size];
		System.arraycopy(array, beg, left, 0, left_size);
		int right_size=end-mid;
		int[] right=new int[right_size];
		System.arraycopy(array, mid+1, right, 0, right_size);
		int i=0,j=0;
		int count=beg;  //开始初始为0 一直出错 
		while((i<left_size) && (j<right_size))  
		{
			if(left[i] <= right[j])
			{
				array[count++]=left[i++];
			}else
				array[count++]=right[j++];
		}
		while(i<left_size)
			array[count++]=left[i++];
		while(j<right_size)
			array[count++]=right[j++];
	}
	
	
}

class InsertSort implements sort{
	@Override
	public void dosort(int[] array,int beg,int end){
		//1. 从第二个元素开始，讲其与前面的元素比较  找到合适的插入位置
		if(beg>=end)
			return;
		
		for(int i=beg+1;i<=end;++i)
		{
			int temp=array[i];
			int j=i-1;
			while(j>=0 && temp < array[j])
			{
				array[j+1]=array[j];
				j--;
			}
			array[j+1]=temp;
		}
		
	}
}

class BubbletSort implements sort{
	@Override
	public void dosort(int[] array,int beg,int end){
		//1.从后往前 通过交换 把最小的放第一个
		//2.然后是次小的放第二位
		//3.如果一趟中没有出现交换，则说明已经排好了 break
		if(beg >= end)
			return;
		for(int i=beg;i<end;++i)
		{
			boolean changed=false;
			for(int j=end;j>i;--j)
			{
				if(array[j] < array[j-1])
				{
					changed=true;
					int temp=array[j];
					array[j]=array[j-1];
					array[j-1]=temp;
				}
			}
			if(!changed)
				return;
		}
		
	}
	
}

class SelectSort implements sort{
	@Override
	public void dosort(int[] array,int beg,int end){
		//1. 和冒泡法类似  只是标记最下值所在的位置 然后和应该在位置的值交换
		
		if(beg >= end)
			return;
		int pos=0;
		for(int i=0;i<end;++i)
		{
			pos=i;
			for(int j=i+1;j<=end;++j)
			{
				if(array[pos] > array[j])
					pos=j;
			}
			{
				int temp=array[pos];
				array[pos]=array[i];
				array[i]=temp;
			}
		}
	}
	
}

6. 测试类

public class Test {
	static void test(sort sorter,int[] array){
		sorter.dosort(array, 0, array.length-1);
	}
	
	static void print(int[] array)
	{
		for(int i:array)
			System.out.print(" "+i);
		System.out.print('\n');
	}
	
	public static void main(String[] args){
		int[] array=RandNums.getIntArrays(30000,0,300000);
		
		//print(array);
		
//		sort qs=new QuickSort();
//		System.out.println(qs.getClass().getName());
//		int[] arraytemp=new int[array.length];
//		System.arraycopy(array, 0, arraytemp, 0, array.length);
//		test(qs,arraytemp);
//		print(arraytemp);
//		
//		sort rs=new RecursiveSort();
//		System.out.println(rs.getClass().getName());
//		System.arraycopy(array, 0, arraytemp, 0, array.length);
//		test(rs,arraytemp);
//		print(arraytemp);
//		
//		sort is=new InsertSort();
//		System.out.println(is.getClass().getName());
//		System.arraycopy(array, 0, arraytemp, 0, array.length);
//		test(is,arraytemp);
//		print(arraytemp);
//		
//		 
//		sort bs=new BubbletSort();
//		System.out.println(bs.getClass().getName());
//		System.arraycopy(array, 0, arraytemp, 0, array.length);
//		test(bs,arraytemp);
//		print(arraytemp);
//		
//		
//		sort ss=new SelectSort();
//		System.out.println(ss.getClass().getName());
//		System.arraycopy(array, 0, arraytemp, 0, array.length);
//		test(ss,arraytemp);
//		print(arraytemp);
		
		int[] arraytemp=new int[array.length];
		sort sort_proxy=null;
		
		InsertSort is =new InsertSort();
		System.out.println(is.getClass().getName());
		System.arraycopy(array, 0, arraytemp, 0, array.length);
		sort_proxy=(sort)MyProxyFactory.getProxy(is);
		sort_proxy.dosort(arraytemp, 0, array.length-1);
		
		QuickSort qs=new QuickSort();
		System.out.println(qs.getClass().getName());
		System.arraycopy(array, 0, arraytemp, 0, array.length);
		sort_proxy=(sort)MyProxyFactory.getProxy(qs);
		sort_proxy.dosort(arraytemp, 0, array.length-1);
		
		
		RecursiveSort rs =new RecursiveSort();
		System.out.println(rs.getClass().getName());
		System.arraycopy(array, 0, arraytemp, 0, array.length);
		sort_proxy=(sort)MyProxyFactory.getProxy(rs);
		sort_proxy.dosort(arraytemp, 0, array.length-1);

		
	}
}