排序算法之冒泡排序、选择排序、插入排序

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算法-------------
", sort.sortName());
                Comparable[] data = (Comparable[])args[0];
                System.out.printf("排序前数据：%s
", Arrays.toString(data));
                long start = System.currentTimeMillis();
                data = (Comparable[]) method.invoke(sort, args);
                long end = System.currentTimeMillis();
                System.out.printf("排序后数据：%s
", Arrays.toString(data));
                System.out.printf("排序总耗时：%s毫秒
", 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 SortInvocationHandler(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);
    }

}