使用shell排序，插入排序，选择排序，冒泡排序，以及java的Arrays中自带的排序进行对比

有兴趣的可以看看java自带的Arrays.sort()中的源码。其中是根据数据量的多少进行的快排或者是归并排序等。
博主并非大牛，所以该文不具有权威性，感兴趣的可以看看。
全部代码如下，可以去掉注释进行对比。懒得将该删的删去了，将就的看看。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SelectSearch {

	public static void main(String[] args) {
//		int[] arr = {9, 2, 6, 1, 7, 5, 4, 0, 3, 8};
//		selectSearch(arr);
//		insertSearch(arr);
//		shellSearch(arr);
//		mergeSort(arr, 0, 1);
//		System.out.println(Arrays.toString(arr));
		int count = 1000;
		List<Integer> list = new ArrayList<>();
		for(int i = 0; i < count; i++)
			list.add(i);
		Collections.shuffle(list);
		Integer[] arrI = list.toArray(new Integer[list.size()]);
		
//		System.out.println("shell start : " + Arrays.toString(arrI));
		/*
		 * shell与java自带的性能差不多，时好时坏，有时shell快有时java快
		 * shell
		long start = System.currentTimeMillis();
		shellSearch(arrI);
		System.out.println("shell spend : " + (System.currentTimeMillis() - start));
		
		//java  Arrays中自带的
		arrI = list.toArray(new Integer[list.size()]);
		start = System.currentTimeMillis();
		Arrays.sort(arrI);
		System.out.println("java spend : " + (System.currentTimeMillis() - start));
		*/
		
//		System.out.println("insert start : " + Arrays.toString(arrI));
		/*
		 * 
		 * 在数据量小的时候比较好，大时也不行。但是比选择，collections，冒泡，要好。没有shell和java自带的好
		arrI = list.toArray(new Integer[list.size()]);
		start = System.currentTimeMillis();
		insertSearch(arrI);
		System.out.println("insert spend : " + (System.currentTimeMillis() - start));
		*/
		
		/*
		 *Collections.sort()排序，当数据量小的时候，跟shell排序的性能差不多，当数据量大时（万，十万等）时是shell性能的两倍慢 （两倍只是大体估摸的数字）
		start = System.currentTimeMillis();
		Collections.sort(list);
		arrI = list.toArray(new Integer[list.size()]);
		System.out.println("collections spend : " + (System.currentTimeMillis() - start));
		*/
		
//		System.out.println("select start : " + Arrays.toString(arrI));
		/*
		 * 选择排序比冒泡稍微好一点点
		arrI = list.toArray(new Integer[list.size()]);
		start = System.currentTimeMillis();
		selectSearch(arrI);
		System.out.println("select spend : " + (System.currentTimeMillis() - start));
		*/
		
//		System.out.println("maopao start : " + Arrays.toString(arrI));
		/*
		 * 冒泡法的性能最差
		arrI = list.toArray(new Integer[list.size()]);
		start = System.currentTimeMillis();
		mapPaoSearch(arrI);
		System.out.println("maopao spend : " + (System.currentTimeMillis() - start));
		*/
	}

	public static int fibonaciArr(int n) {
		
		int i = 1,j = 1;
		int sum = 0;
		while(n > 2) {
			sum = i + j;
			j = i;
			i = sum;
			n--;
		}
		return sum;
	}
	
	public static int fibonaci(int n) {
		
		if(n == 1 || n== 2)
			return 1;
		else
			return fibonaci(n - 1) + fibonaci(n  - 2);
	}
	
	/**
	 * @param arrI
	 * @param s
	 * @param len
	 * 每次归并的有序集合的长度
	 */
	public static void mergeSort(Integer[] arrI, int s, int len) {
		int size = arrI.length;
		int mid = size / (len << 1);
		int c = size & ((len << 1) - 1);
		//归并到只剩一个有序集合的时候 就结束算法
		if(mid == 0)
			return;
		//进行一趟归并排序
		for(int i = 0; i  < mid; ++i) {
			s = i * 2 * len;
			merge(arrI, s, s + len, (len << 1) + s - 1);
		}
		 //　-------将剩下的数和倒数一个有序集合归并-------//
        if(c != 0)
            merge(arrI, size - c - 2 * len, size - c, size - 1);
        //　-------递归执行下一趟归并排序------//
        mergeSort(arrI, 0, 2 * len);
	}
	/**
	 * 二路归并
	 * 原理：将两个有序表合并和一个有序表
	 * @param arrI
	 * @param s
	 * 第一个有序表的起始下标
	 * @param m
	 * 第二个有序表的起始下标
	 * @param t
	 * 第二个有序表的结束小标
	 */
	private static void merge(Integer[] arrI, int s, int m, int t) {
		int[] tmp = new int[t - s + 1];
		int i = s, j = m, k = 0;
		while(i < m && j <= t) {
			if(arrI[i] <= arrI[j]) {
				tmp[k] = arrI[i];
				k++;
				i++;
			} else {
				tmp[k] = arrI[j];
				j++;
				k++;
			}
		}
		while(i < m) {
			tmp[k] = arrI[i];
			i++;
			k++;
		}
		while(j <= t) {
			 tmp[k] = arrI[j];
	            j++;
	            k++;
		}
		System.arraycopy(tmp, 0, arrI, s, tmp.length);
	}
	
	/**
	 * Shell排序
	 * 
	 * @param arr
	 */
	public static void shellSearch(Integer[] arrI) {
		
		int d = arrI.length;
		while (true) {
			d >>>= 1;
			for (int x = 0; x < d; x++) {
				for (int i = x + d; i < arrI.length; i = i + d) {
					int temp = arrI[i];
					int j;
					for (j = i - d; j >= 0 && arrI[j] > temp; j = j - d) {
						arrI[j + d] = arrI[j];
					}
					arrI[j + d] = temp;
				}
			}
			if (d == 1) {
				break;
			}
		}
	}

	/**
	 * 插入排序，每次将最小的放在第一个位置上
	 * 
	 * @param arrI
	 */
	public static void insertSearch(Integer[] arrI) {

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

	/**
	 * 从第一个开始，将每个挨个拿出，再挨个循环len-j-1次，与每个数字比较，将最小的放在第j个位置
	 * 选择排序，每次将最小的放在第一个位置
	 * 
	 * @param arrI
	 */
	public static void selectSearch(Integer[] arrI) {

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

	/**
	 * 冒泡排序，每次将最大的放在最后面
	 * 
	 * @param arrI
	 */
	public static void mapPaoSearch(Integer[] arrI) {

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