算法的java实现（未优化）

直接上代码，基本原理自己应该都清楚

package CN.IT.test;

**/**
 * 可以自己将比较方法和交换方法抽出来，自己进行定义，使用的时候自行引用，
 * 一定程度上实现了解耦合。改比较规则的时候不需要改动源代码。
 * 也可以自己定义一个随机数组，加上时间，数据量越大，越能看出差别。
 */**
import java.util.Arrays;

public class test {
    public static void main(String[] args) {
    
        Integer [] arr = {4,8,5,9,3,2,4,6,1,3,8,11,16};
        test t = new test();


//        t.bubble(arr);
//        t.select(arr);
//        t.insertion(arr);
//        t.shell(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 冒泡
     * @param arr
     */
    public void bubble(Integer[] arr){

        for (int i = arr.length-1; i >0; i--) {
            for (int j = 0; j < i; j++) {
                if (arr[j]>arr[j+1]){
                    int temp;
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }

    /**
     * 选择
     * @param arr
     */
    public void select(Integer [] arr){
        for (int i = 0; i < arr.length-1; i++) {
            int minindex=i;
            for (int j = i+1; j <arr.length ; j++) {
                if (arr[i]>arr[j]){
                    int temp;
                    temp=arr[j];
                    arr[j]= arr[i];
                    arr[i]=temp;
                }
            }
        }

    }

    /**
     * 插入
     * @param arr
     */
    public void insertion(Integer [] arr){
        for (int i = 1; i <arr.length ; i++) {
            for (int j = i; j >0 ; j--) {
                if (arr[j]<arr[j-1]){
                    int temp;
                    temp=arr[j];
                    arr[j]= arr[j-1];
                    arr[j-1]=temp;
                }else {
                    break;
                }
            }
        }
    }

    /**
     * 希尔
     * @param arr
     */
    public void shell(Integer [] arr){
        int h =1;
        while (h<arr.length/2){
            h=2*h+1;
        }
        while (h>=1){
        //1.找到待插入元素。i就是待插入元素。
            for (int i = h; i <arr.length ; i++) {
             //2.把待插入元素插入到有序数列中,有序数列就是待插入元素之前的那些数列
                for (int j = i; j >= h ; j-=h) {
                    if (arr[j]<arr[j-h]){
                        int temp;
                        temp=arr[j];
                        arr[j]= arr[j-h];
                        arr[j-h]=temp;
                    }else {
                        break;
                    }
                }
            }
            h=h/2;
        }
    }
}

二路归并

package CN.IT.algorithm.sort;

/**
 *
 1.尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是 1为止。

 2.将相邻的两个子组进行合并成一个有序的大组；
 3.不断的重复步骤2，直到终只有一个组为止。
 */
public class Merge {

    private static Comparable[] assist;//归并所需要的辅助数组


    /**
     * 对数组a中的元素进行排序
     */
    public static void sort(Comparable [] a ){
        //1.初始化辅助数组 assit
        assist = new Comparable[a.length];
        //2.定义一个lo变量和hi变量，分别记录数组中最小的索引和最大的索引
        int lo=0;
        int hi=a.length-1;
        //3.调用sort重载方法完成数组a中，从索引lo到索引hi元素的排序
        sort(a,lo,hi);
    }
    /**
     * 对数组a中从lo到hi的元素进行排序
      */
   public static void sort(Comparable [] a, int lo, int hi){
       //安全性校验
       if (hi<=lo){
           return;
       }
       //对lo到hi之间的数据进行分两个组

       int mid =lo+(hi-lo)/2;
       //分别对每一组进行排序
       sort(a,lo,mid);
       sort(a,mid+1,hi);

       //两个组的数据进行归并
       merge(a,lo,mid,hi);
   }
   /**
    * 对数组中，从lo到mid为一组，从mid+1到hi为一组，对这两组数据进行归并
    */
    private static void merge(Comparable [] a, int lo, int mid, int hi) {

        //定义三个指针
        int i = lo;
        int p1=lo;
        int p2=mid+1;
        //遍历，移动p1指针和p2指针，比较对应索引处的值找出小的那个，放到辅助数组的对应索引处
        while (p1<=mid && p2<=hi){
            if (less(a[p1],a[p2])){
                assist[i++] =a[p1++];
            }else {
                assist[i++]=a[p2++];
            }
        }
        //一下两个循环只会执行一个
        //遍历，如果p1 的指针没有走完， 那么移动p1指针，把对应元素放到辅助数组的索引处
        while (p1<=mid){
            assist[i++]=a[p1++];
        }
        //遍历，如果p2 的指针没有走完， 那么移动p2指针，把对应元素放到辅助数组的索引处
        while (p2<=hi){
            assist[i++]=a[p2++];
        }
        //把辅助数组中的元素拷贝到原始数组中
        for (int index=lo;index<=hi;index++){
            a[index]=assist[index];
        }
    }
    /**
     * 比较V元素是否小于W元素
     */
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
}

测试类

package CN.IT.algorithm.test;

import CN.IT.algorithm.sort.Merge;

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

public class MergeTest {
    public static void main(String[] args) {
        //获取开始时间
        long startTime=System.currentTimeMillis();

        /**
         * bound: 限制的是取值范围
         */
        Integer [] arr = new Integer[1000];
        Random r  = new Random();
        for (Integer i = 0; i < 1000; i++) {
            arr[i] = r.nextInt(1000);
        }
        Merge.sort(arr);
        System.out.println(Arrays.toString(arr));

        //获取结束时间
        long endTime =System.currentTimeMillis();
        System.out.println("运行总时间："+(endTime-startTime)+"ms");
    }
}