双路快排与Spring IoC注解-优快云博客

学习目标：

使用注解方式实现SpringIoC

通过代码实现双路快速排序法并且对其进行复杂度分析

学习内容：

使用注解进行了IoC容器的初始化，并且学习了一些常见的注解比如@Resource等。

import java.util.Arrays;
import java.util.Random;

public class QuickSort {
    private QuickSort(){}
    public static <E extends Comparable<E>> void sort(E[] arr){
        Random rnd = new Random();
        sort(arr,0,arr.length-1,rnd);
    }
    private static <E extends Comparable<E>> void sort(E[] arr,int l,int r,Random rnd){
        if(l>=r)return;
        int p = partition(arr, l, r,rnd);
        sort(arr, l, p - 1,rnd);
        sort(arr,p+1,r,rnd);
    }
     private static <E extends Comparable<E>> int partition(E[] arr,int l,int r,Random rnd){
        //生成[l,r]之间的随机索引
         int p=l+(rnd.nextInt(r-l+1));
         swap(arr,l,p);
        //arr[l+1...j]<V;arr[j+1...i]>=V
         int j=l;
         for(int i=l+1;i<=r;i++){
             if(arr[i].compareTo(arr[l])<0){
                 j++;
                 swap(arr,i,j);
             }
         }
         swap(arr,l,j);
         return j;
     }
    public static <E extends Comparable<E>> void sort2ways(E[] arr){
        Random rnd = new Random();
        sort2ways(arr,0,arr.length-1,rnd);
    }
    private static <E extends Comparable<E>> void sort2ways(E[] arr,int l,int r,Random rnd){
        if(l>=r)return;
        int p = partition2(arr, l, r,rnd);
        sort2ways(arr, l, p - 1,rnd);
        sort2ways(arr,p+1,r,rnd);
    }
    private static <E extends Comparable<E>> int partition2(E[] arr,int l,int r,Random rnd){
        //生成[l,r]之间的随机索引
        int p=l+(rnd.nextInt(r-l+1));
        swap(arr,l,p);
        //arr[l+1...i-1]<=v;arr[j+1...r]>=v
        int i=l+1,j=r;
        while (true){
            while (i<=j&&arr[i].compareTo(arr[l])<0)
                i++;
            while (j>=i&&arr[j].compareTo(arr[l])>0)
                j--;
            if(i>=j)break;
            swap(arr,i,j);
            i++;
            j--;
        }
        swap(arr,l,j);
        return j;
    }
     private static <E> void swap(E[] arr,int i,int j){
        E t=arr[i];
        arr[i]=arr[j];
        arr[j]=t;
     }

    public static void main(String[] args) {
        int n=100000;
        Integer[] arr=ArrayGenerator.generatorRandomArray(n,n);
        Integer[] arr2 = Arrays.copyOf(arr, arr.length);
        System.out.println("Random Array");
        SortingHelper.sortTest("QuickSort",arr);
        SortingHelper.sortTest("QuickSort2ways",arr2);
        System.out.println();

        arr = ArrayGenerator.generatorOrderedArray(n);
        arr2 = Arrays.copyOf(arr, arr.length);
        System.out.println("Order Array");
        SortingHelper.sortTest("QuickSort",arr);
        SortingHelper.sortTest("QuickSort2ways",arr2);
        System.out.println();

        arr = ArrayGenerator.generatorRandomArray(n, 1);
        arr2 = Arrays.copyOf(arr, arr.length);
        System.out.println("Same Value Array");
        SortingHelper.sortTest("QuickSort2ways",arr2);
        SortingHelper.sortTest("QuickSort",arr);
        System.out.println();
    }
}

Random Array
QuickSort,n=100000:0.038746 s
QuickSort2ways,n=100000:0.043655 s

Order Array
QuickSort,n=100000:0.012039 s
QuickSort2ways,n=100000:0.006904 s

Same Value Array
QuickSort2ways,n=100000:0.007634 s

其算法复杂度的期望为O（nlogn)

没有任何一组数据能够百分之百保证将其算法降低为O(n*2)