经典排序算法

data.txt

8,10,211,4,128,12,5,365,9,192,7,1,3,2,6,1024,11,13,20,54

SortAlgorithm.java

package io.guangsoft;

import java.io.FileInputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
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 ShellSort implements Sort {
        @Override
        public String sortName() {
            return "希尔排序";
        }
        @Override
        public Comparable[] sort(Comparable[] data) {
            int gap = 1;
            //确定初始增量
            while(gap < data.length / 2) {
                gap = 2 * gap + 1;
            }
            //逐步二分缩小排序增量
            while(gap >= 1) {
                //从中间位置开始向后逐步分组
                for(int i = gap; i < data.length; i++) {
                    //组内进行插入排序
                    for(int j = i; j >= gap; j -= gap) {
                        if(Sort.greater(data[j - gap], data[j])) {
                            Sort.swap(data, j - gap, j);
                        } else {
                            break;
                        }
                    }
                }
                //缩小gap
                gap >>>= 1;
            }
            return data;
        }
    }

    //归并排序
    static class MergeSort implements Sort {
        private static Comparable[] assist;
        @Override
        public String sortName() {
            return "归并排序";
        }
        @Override
        public Comparable[] sort(Comparable[] data) {
            assist = new Comparable[data.length];
            int lo = 0;
            int hi = data.length - 1;
            sort(data, lo, hi);
            return data;
        }
        //递归体
        private static void sort(Comparable[] data, int lo, int hi) {
            if(hi <= lo) return;
            int mid = lo + (hi - lo) / 2;
            sort(data, lo, mid);
            sort(data, mid + 1, hi);
            merge(data, lo, mid, hi);
        }
        //合并
        private static void merge(Comparable[] data, int lo, int mid, int hi) {
            //定义三个指针
            int i = lo, p1 = lo, p2 = mid + 1;
            //遍历，移动p1指针和p2指针，比较对应索引处的值，找出小的那个，放到辅助数组的对应索引处
            while(p1 <= mid && p2 <= hi) {
                if(!Sort.greater(data[p1], data[p2])) {
                    assist[i++] = data[p1++];
                } else {
                    assist[i++] = data[p2++];
                }
            }
            //遍历，如果p1指针没有走完，那么顺序移动p1指针，把对应的元素放到辅助数组的对应索引处
            while(p1 <= mid) {
                assist[i++] = data[p1++];
            }
            //遍历，如果p2指针没有走完，那么顺序移动p1指针，把对应的元素放到辅助数组的对应索引处
            while(p2 <= hi) {
                assist[i++] = data[p2++];
            }
            //把辅助数组中的元素拷贝到原数组中
            for(int index = lo; index <= hi; index++) {
                data[index] = assist[index];
            }
        }
    }

    //快速排序
    static class QuickSort implements Sort {
        @Override
        public String sortName() {
            return "快速排序";
        }
        @Override
        public Comparable[] sort(Comparable[] data) {
            int lo = 0, hi = data.length - 1;
            sort(data, lo, hi);
            return data;
        }
        //递归体
        private static void sort(Comparable[] data, int lo, int hi) {
            if(hi <= lo) return;
            int partition = partition(data, lo, hi);
            sort(data, lo, partition - 1);
            sort(data, partition + 1, hi);
        }
        //分组
        private static int partition(Comparable[] data, int lo, int hi) {
            //确定分界值
            Comparable key = data[lo];
            //定义两个指针，分别指向待切分元素的最小索引处和最大索引处的下一个位置
            int left = lo, right = hi + 1;
            //切分
            while(true) {
                //先从左往右扫描，移动right指针，找到一个比分界值小的元素，停止
                while(!Sort.greater(key, data[--right])) {
                    if(right == lo) break;
                }
                //再从左往右扫描，移动left指针，找到一个比分界值大的元素，停止
                while(!Sort.greater(data[++left], key)) {
                    if(left == hi) break;
                }
                //判断left>=right，如果是，则证明元素扫描完毕，结束循环，如果不是，则交换元素即可
                if(left >= right) {
                    break;
                } else {
                    Sort.swap(data, left, right);
                }
            }
            //交换分界值
            Sort.swap(data, lo, right);
            return right;
        }
    }

    //动态代理执行测试
    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);
        }
    }

    //NIO加载数据
    public static<T> T[] loadData(Class<T> c) throws Throwable{
        FileInputStream fileInputStream = new FileInputStream(Sort.class.getClassLoader().getResource("data.txt").getPath());
        FileChannel fileChannel = fileInputStream.getChannel();
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        StringBuffer stringBuffer = new StringBuffer();
        int length = -1;
        while((length = fileChannel.read(byteBuffer)) != -1) {
            byteBuffer.clear();
            byte[] bytes = Arrays.copyOf(byteBuffer.array(), length);
            stringBuffer.append(new String(bytes));
        }
        fileChannel.close();
        fileInputStream.close();
        return (T[]) Arrays.stream(stringBuffer.toString().split(",")).mapToInt(Integer::valueOf).boxed().toArray(Integer[]::new);
    }

    //启动类
    public static void main(String args[]) throws Throwable {
        Comparable[] data = loadData(Integer.class);
        //测试冒泡排序
        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);
        //测试希尔排序
        DynamicSort.sort(Arrays.copyOf(data, data.length), ShellSort.class);
        //测试归并排序
        DynamicSort.sort(Arrays.copyOf(data, data.length), MergeSort.class);
        //测试快速排序
        DynamicSort.sort(Arrays.copyOf(data, data.length), QuickSort.class);
    }

}

运行结果