java实现常用排序算法

参考文章：

1. 十大经典排序算法
2. Data Structure and Algorithms - Quick Sort

主程序

    public static void main(String[] args) {
        Test tmp = new Test();
        int times = 10;
        for (int i = 0; i < times; i++) {
            tmp.run();
        }
    }

测试类
这里使用自定义注解配置需要测试的排序方法。随后在运行中通过反射调取注解配置，再次调用反射加载注解配置。

@MyAnnotation(className = "com.java.learning.LearnSort",methodName = "quick_sort")
public class Test {
    int len;
    LearnSort obj;
    Class<Test> testClass = Test.class;
    MyAnnotation myAnno;
    public Test(){
    	// 动态生成一个 实现了该注解接口的子类 对象
        myAnno = testClass.getAnnotation(MyAnnotation.class);
        len = myAnno.len();
        obj = new LearnSort(len);
    }

    private void Gen(){
        obj.generate_rand_arraylist();
    }

    private void sort(){
    	// 子类对象实现注解定义的方法，并返回传入值
        String className = myAnno.className();
        String methodName = myAnno.methodName();
        try {
        	// 反射加载指定类
            Class<?> sortClass = Class.forName(className);
            // 反射调用指定方法
            Method method = sortClass.getMethod(methodName,int.class,int.class);
            System.out.println("method "+methodName+" in "+className+" class");
            method.invoke(obj,0,len-1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void check(){
        obj.check_ans();
    }
    private void clear(){
        obj.clear();
    }

    public void run(){
        Gen();
        sort();
        check();
        clear();
    }
}

排序实现类

public class LearnSort {
    private List<Integer> a;
    private List<Integer> copy;
    private List<Integer> stand;
    private int length;
    private int lim=2048;

    public LearnSort(int len){
        this.length=len;
    }
    public LearnSort(int len,int lim){
        this.length=len;
        this.lim=lim;
    }
    public void setLength(int length) {
        this.length = length;
    }

    public int getLength() {
        return length;
    }

    public void generate_rand_arraylist(){
        a = new ArrayList<>();
        copy = new ArrayList<>();
        stand = new ArrayList<>();
        Random r = new Random();
        for(int i=0;i<length;i++)
            a.add(r.nextInt(lim));
        copy.addAll(a);
        stand.addAll(a);
    }
    public void generate_same_arraylist(int val){
        a = new ArrayList<>();
        copy = new ArrayList<>();
        stand = new ArrayList<>();
        for (int i = 0; i <this.length; i++) {
            a.add(val);
        }
        copy.addAll(a);
        stand.addAll(a);
    }
    public void clear(){
        if(a==null){
            return;
        }
        a.clear();copy.clear();stand.clear();
    }
    private void show(List<Integer> info){
        Iterator<Integer> it = info.iterator();
        while(it.hasNext()){
            int tmp = it.next();
            System.out.printf("%d ",tmp);
        }
    }
    public Boolean check_ans() {
        Boolean state=true;
        Collections.sort(stand);
        if(a.equals(stand)) {
            System.out.println("perfect!");
            state = true;
        }else{
            System.out.println("Error\ninput:");
            show(copy);
            System.out.println("\nmy ans:");
            show(a);
            System.out.println("\nstand ans:");
            show(stand);
            state = false;
        }
        //System.out.println("\n");
        return state;
    }

    private void swap(@NotNull List<Integer> source, int i, int j){
        int tmp = source.get(i);
        source.set(i,source.get(j));
        source.set(j,tmp);
    }
    public void bubble_sort(){
        for (int i = 0; i < a.size(); i++) {
            for(int j=i+1;j<a.size();j++){
                if(a.get(i)>a.get(j)) Collections.swap(a, i, j);
            }
        }
    }
    public void select_sort(){
        for (int i = 0; i < this.length; i++) {
            int minPos=i;
            for (int j = i+1; j < this.length; j++) {
                if(a.get(minPos)>a.get(j))
                    minPos=j;
            }
            swap(a,i,minPos);
        }
    }
    public void insert_sort(){
        a.add(0,-1);
        for (int i = 2; i <= this.length; i++) {
            Integer insert_num=a.get(i);
            for(int j=i-1;j>=0;j--) {
                if (insert_num >= a.get(j)) {
                    a.add(j + 1,insert_num);
                    a.remove(i + 1);
                    break;
                }
            }
        }
        a.remove(0);
    }
    public void shell_sort(){
        a.add(0,-1);
        int[] step = new int[]{7,5,3,2,1};
        for (int now_step : step) {
            for (int i = now_step; i <= this.length; i += now_step) {
                int insert_num = a.get(i);
                for (int j = i - now_step; j >= 0; j -= now_step) {
                    if (insert_num >= a.get(j)) {
                        a.add(j + 1, insert_num);
                        a.remove(i + 1);
                        break;
                    }
                }

            }
        }
        a.remove(0);
    }
    public void merge_sort(int left,int right){
        if(left==right)
            return;
        int mid=(left+right)/2;
        merge_sort(left,mid);merge_sort(mid+1,right);
        ArrayList<Integer> tmp = new ArrayList<>();
        int left_star=left,right_star=mid+1;
        while(left_star<=mid && right_star<=right){
            int left_num=a.get(left_star),right_num=a.get(right_star);
            if(left_num>right_num){
                tmp.add(right_num);
                right_star++;
            }else{
                tmp.add(left_num);
                left_star++;
            }
        }
        while(left_star<=mid){
            tmp.add(a.get(left_star));
            left_star++;
        }
        while(right_star<=right){
            tmp.add(a.get(right_star));
            right_star++;
        }
        for (int i = 0; i <= right-left; i++) {
            a.set(i+left,tmp.get(i));
        }
    }
    public void quick_sort(int left,int right){
        if(left>=right)
            return;
        int mid=left+(right-left)/2;
        int pivot = a.get(mid);
        a.remove(mid);
        int le=left,ri=right-1;
        while(le<ri && ri>=left && le<=right-1){
            int left_num=a.get(le),right_num=a.get(ri);
            if(left_num<=pivot)
                le++;
            if(right_num>=pivot)
                ri--;
            if(left_num>pivot && right_num<pivot)
                swap(a,le,ri);
        }
        if(a.get(le)<=pivot)
            a.add(le+1,pivot);
        else
            a.add(le,pivot);
        quick_sort(left,le);quick_sort(le+1,right);
    }
    public void heap_sort(){
        ArrayList<Integer> heap = new ArrayList<>();
        int len=a.size();
        for (int i = 0; i < len; i++) {
            insert(heap,a.get(i));
        }

        a.clear();
        for(int i=0;i<len;i++){
            a.add(pop(heap));
        }
    }
    private void insert(List<Integer> heap,int num){
        int pos=heap.size();
        heap.add(num);
        while(pos>0){
            int father_node=(pos-1)/2;
            if(heap.get(father_node)>heap.get(pos)) {
                Collections.swap(heap, pos, father_node);
                pos=father_node;
            }else
                break;
        }
    }
    private int pop(List<Integer> heap){
        int num=heap.get(0);
        int len=heap.size();
        heap.set(0,heap.get(len-1));
        heap.remove(len-1);len--;
        int node=0;
        while(node<len){    //结点下沉
            int left=2*node+1,right=2*node+2;
            int nowNum=heap.get(node);
            int leftNum=2*node+1<len ? heap.get(left):heap.get(node)+1;
            int rightNum=2*node+2<len ? heap.get(right):heap.get(node)+1;
            int minN=Math.min(leftNum,rightNum);
            if(nowNum<minN)
                break;
            if(leftNum<rightNum){
                Collections.swap(heap,left,node);
                node=left;
            }else{
                Collections.swap(heap,right,node);
                node=right;
            }
        }
        return num;
    }
}