package org.guangsoft;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
public class SortAlgorithm {
//排序算法接口
interface Sort {
//排序算法名称
String sortName();
//元素大小的判断
static boolean greater(Comparable x, Comparable y) {
return x.compareTo(y) > 0;
}
//交换元素
static void swap(Comparable[] data, int i, int j) {
Comparable temp = data[i];
data[i] = data[j];
data[j] = temp;
}
//排序方法
Comparable[] sort(Comparable[] data);
}
//冒泡排序
static class BubbleSort implements Sort {
@Override
public String sortName() {
return "冒泡排序";
}
@Override
public Comparable[] sort(Comparable[] data) {
//需要从由大到小范围进行n-1次筛选
for(int i = 0; i < data.length - 1; i++) {
//在每次筛选的范围内逐个比较，将最小值冒泡到范围最左端
for(int j = data.length - 1; j > i; j--) {
if(Sort.greater(data[j - 1], data[j])) {
Sort.swap(data, j - 1, j);
}
}
}
return data;
}
}
//选择排序
static class SelectionSort implements Sort {
@Override
public String sortName() {
return "选择排序";
}
@Override
public Comparable[] sort(Comparable[] data) {
//需要从由大到小范围进行n-1次筛选
for(int i = 0; i < data.length - 1; i++) {
//在每次筛选的范围内选出最小值，将最小值交换到范围最左端
int minIndex = i;
for(int j = i + 1; j < data.length; j++) {
if(Sort.greater(data[minIndex], data[j])) {
minIndex = j;
}
}
Sort.swap(data, i, minIndex);
}
return data;
}
}
//插入排序
static class InsertionSort implements Sort {
@Override
public String sortName() {
return "插入排序";
}
@Override
public Comparable[] sort(Comparable[] data) {
//需要从由小到大范围进行n-1次筛选
for(int i = 1; i < data.length; i++) {
//在每次筛选的范围内将新增元素插入到有序位置
for(int j = i; j > 0; j--) {
if(Sort.greater(data[j - 1], data[j])) {
Sort.swap(data, j - 1, j);
} else {
break;
}
}
}
return data;
}
}
//动态代理测试器
static class DynamicSort {
//动态代理处理器
static class SortInvocationHandler implements InvocationHandler {
private Sort sort;
SortInvocationHandler(Sort sort) { this.sort = sort;}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.printf("-------------测试%s算法-------------\n", sort.sortName());
Comparable[] data = (Comparable[])args[0];
System.out.printf("排序前数据：%s\n", Arrays.toString(data));
long start = System.currentTimeMillis();
data = (Comparable[]) method.invoke(sort, args);
long end = System.currentTimeMillis();
System.out.printf("排序后数据：%s\n", Arrays.toString(data));
System.out.printf("排序总耗时：%s毫秒\n", end - start);
return null;
}
}
//执行代理
public static void sort(Comparable[] data, Class clazz) throws Throwable {
Sort sort = (Sort) clazz.getDeclaredConstructor().newInstance();
sort = (Sort)Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), new InvocationHandler(sort));
sort.sort(data);
}
}
//启动类
public static void main(String args[]) throws Throwable {
Integer[] data = {8, 4, 5, 7, 1, 3, 2, 6};
//测试冒泡排序
DynamicSort.sort(Arrays.copyOf(data, data.length), BubbleSort.class);
//测试选择排序
DynamicSort.sort(Arrays.copyOf(data, data.length), SelectionSort.class);
//测试插入排序
DynamicSort.sort(Arrays.copyOf(data, data.length), InsertionSort.class);
}
}
