时间复杂度为O（n^2）。但是当最好的情况时，内层循环只是做了简单的元素对比且只对比一次然后全部直接退出，那么时间复杂度为O（n）。因此插入排序经常作为其他高阶排序的辅助手段。最坏情况，就是内外层都全部执行O（n^2）。空间复杂度还是O（1）。是一个稳定的排序算法。

2.2.2希尔排序

插入排序就是在近乎有序的数组上性能非常好或者在小数据规模的集合中性能也很好，希尔排序就是针对于直接插入排序的优化。所以希尔排序的思路就是先将数组调整的近乎有序，最终在整个近乎有序的数组上来一次插入排序。

具体操作：先选定一个整数（gap），将待排序的集合中按照gap分组（所有距离为gap的元素在同一组），对同一组的元素进行排序，不断缩小这个gap的长度（gap/=2，gap/=3），重复上述的分组与排序过程，当gap==1，时整个数组已经近乎有序，最终来以此全数组的插入排序，整个集合就有序了。

当gap > 1都是分组，组内进行插入排序，当gap == 1时，其实整个数组近乎有序，整体来一次插入排序即可。组内进行的插入排序就相当于将插入排序中的1改为gap。

    public static void shellSort(int[] array){int gap = array.length/2;while(gap>1){insertSortByGap(array,gap);gap = gap>>1;}insertSortByGap(array,1);}public static void insertSortByGap(int[] array,int gap){for (int i = gap; i < array.length; i++) {for (int j = i; j >= gap && array[j] < array[j - gap]; j-=gap) {int tmp = array[j];array[j] = array[j-gap];array[j-gap] = tmp;}}}

一次一次按照gap分组，第一个gap = 7，分成七组，两两一组通过选择排序组内比较。然后第二次分组再比较，最后gap= 1，此刻已经近乎有序了，整体进行选择排序。 

 时间复杂度为O（n^（1.2-1.3）），具体看gap分组的长度。 

 2.3归并排序

将待排序的数组分为如下两个阶段。

归而为一：阶段一，首先不断将数组一分为二，知道每个子数组一分为二，直到每个子数组只剩下一个元素，拆分阶段结束（此时每个子数组都是有序数组）。

 并而为整：阶段二，不断地将相邻的两个有序子数组，合并为一个大的有序数组，知道合并为完整的数组，此时整个数组有序。

首先要创建一个方法mergeSortInternal用于递归分组，在这个方法中当l>=r时，则只有一个元素或者没有元素则不需要再进行递归直接返回即可，然后定义变量int mid = l + ((r - l) >> 1)，存储中间值。然后先进行左半数组l-mid中继续进行归并排序，再在右半数组mid+1-r进行归并排序，将每个小数组都有序之后再将左右两个有序子数组进行排序调用merge方法。

在这个方法中有两个优化，1、首先是在方法最后调用merge方法这里的优化，只有当两个子数组部分元素还存在乱序，才需要合并。2、在小数组区间上使用插入排序进行优化,减少了很多小数组的递归合并过程，小数组即l  -r <= 15的情况下（是经过实验的）。

归并排序的核心在于merge函数（合并过程）。

在merge方法中设置两个变量int i = l，int j = mid+1。（r为数组最后一个元素下标，l为数组起点下标）先创一个大小为r - l +1 的临时数组aux，将两个子数组的内容复制到aux，进行两个子数组的比较合并过程直到两个子数组完成。

情况1：i > mid说明子数组1的所有元素已经处理完毕。直接将子数组2的剩余元素覆盖即可。

情况2：j > r说明子数组2的所有元素处理完毕，将子数组1的剩余元素进行覆盖。

剩余的情况就进行两个子数组的元素内容大小比较，如果aux[i-1] <= [j-1]选择子数组1的元素进行覆盖，保证了相等元素的稳定性。

    public static void mergeSort(int[] array){mergeSortInternal(array,0,array.length-1);}private static void merge(int[] arr, int l, int mid, int r) {int[] aux = new int[r - l + 1];System.arraycopy(arr, l, aux, 0, (r - l + 1));int i = l,j = mid+1;for (int k = l; k <= r; k++) {if(i > mid){arr[k] = aux[j - l];j ++;}else if (j > r) {arr[k] = aux[i - l];i ++;}else if (aux[i - l] <= aux[j - l]) {arr[k] = aux[i - l];i ++;}else {arr[k] = aux[j - l];j ++;}}}private static void mergeSortInternal(int[] array, int l, int r) {if (r - l <= 15) {insertionSortPart(array,l,r);return;}int mid = l + ((r - l) >> 1);mergeSortInternal(array,l,mid);mergeSortInternal(array,mid+1,r);if(array[mid]> array[mid+1]){merge(array,l,mid,r);}}private static void insertionSortPart(int[] arr, int l, int r) {for (int i = l + 1; i <= r; i++) {for (int j = i; j > l && arr[j] < arr[j - 1]; j--) {swap(arr,j,j - 1);}}}

不断将原数组拆分递归的过程本质就是一颗二叉树， 递归的次数其实就是树的高度，递归的时间复杂度就是O(logn），merge方法的时间复杂度就是O（n）。创建了临时数组，空间复杂度为O（n）。

所以归并排序的时间复杂度为O（nlogn），并且是稳定的。

2.4基于交换的思想

2.4.1冒泡排序

冒泡排序是从头开始两个两个元素之间进行比较，若前面的元素大于后面的元素的值，那么两者交换，这样最大的元素就会移动到最后面，然后重复上述步骤为了快速则忽略掉已经排好序的后面元素。

    private static void bubbleSort(int[] num) {for(int i = 0;i num[j + 1]) {int tmp = num[j];num[j] = num[j + 1];num[j + 1] = tmp;}}}}

时间复杂度为O（n^2）。是稳定的排序方法。 

2.4.2快速排序

现在无序数组中选取一个分区点（数组中的一个元素），扫描整个集合，将比当前分区点小的元素放在分区点数值的左侧，比分区点大的元素放在分区点的右侧，那么分区点数值就放在了正确的位置。=》重复上述过程继续在左半区间和右半区间进行快速排序。

快速排序的核心在于分区函数的实现：针对分区函数的实现有N种操作。

（1）Hoare方法

默认第一个元素或最后一个元素为分区点，其中i索引指向开始位置，j指向终止为止，先让j从后向前扫描，碰到第一个v的值停止，让两者进行交换，不断重复，直到 i>=j 停止。

（2）挖坑法=》针对Hoare方法的改进

默认将第一个位置值作为分取值，即将他取出，其中i索引指向开始位置，j指向终止为止，先让j从后向前扫描，碰到第一个v的值停止再填到j的位置上，不断重复，直到 i>=j 停止，然后将分区值填到这个位置。

    public static void quickSort(int[] arr) {quickSortInternalByHell(arr,0,arr.length - 1);}public static void quickSortInternalByHell(int[] arr,int l,int r){if(l>=r){return ;}int pivot = partitionByHell(arr,l,r);quickSortInternalByHell(arr,l,pivot-1);quickSortInternalByHell(arr,l +1 ,r);}private static int partitionByHell(int[] arr, int l, int r) {int v = arr[l];int i = l;int j = r;while (i < j) {while (i=v){j--;}arr[i] = arr[j];while (i