1.插入排序

插入排序的主要思想是额外申请一个空间cur，让cur一开始等于数组的第1号位置,设置i=1，让i-1的元素与其比较，如果arr[i-1]>arr[i]，就让arr[i+1] = arr[i]，当进行到最后一次对比结束，i=-1,再让arr[i+1] = cur。

​
private static void insertsort(int[] arr) {for (int i = 1; i < arr.length; i++) {int cur = arr[i];int j = i-1;for ( ;j>=0; j--) {if(cur>arr[j]){arr[j+1] = arr[j];}else{break;}}arr[j+1] = cur;}}​

排序算法的特点是序列越有序，时间效率越高，下面的希尔排序也体现出来。

时间复杂度：O(n^2)

空间复杂度：O（1）

是一种稳定的排序算法。

2.希尔排序

希尔排序的思想是设置一个常量gap，将数组每个相距gap距离的两个数进行分组，然后组内进行排序，每进行一次gap排序后，将gap/2，直到gap为1，排序完成。

    private static void shellsort(int[] arr) {int gep = arr.length;while(gep>1){gep/=2;shell(arr,gep);}}private static void shell(int[] arr, int gep) {for(int i = gep;i< arr.length;i++){int cur = arr[i];int j = i-gep;for(;j>=0;j-=gep){if(cur<arr[j]){arr[j+gep] = arr[j];}else{break;}}arr[j+gep] = cur;}}

这里的希尔排序是先拿出gap间距，进行直接插入排序，所以shell方法的实现和插入排序相似。

希尔排序是对插入排序的优化，当gap>1时，都是对序列有序化，直到gap=1时，数组已经趋于有序，就会排序很快，对于整体来说，就有一个优化的效果。

希尔排序的时间复杂度不好计算，因为每次数组长度不确定，gap的取值不确定。

希尔排序的稳定性：不稳定。                                                                           

3.选择排序

选择排序非常好理解，类似于打擂台，取出一个元素，将它设置为擂主，依次取后面的元素进行比较，如果小于擂主，就进行交换，如果大于，就继续遍历，直到遍历结束。

private static void selectsort(int [] arr) {for(int i= 0;i< arr.length;i++){for (int j = i+1; j < arr.length; j++) {if(arr[i]>arr[j]){int tem = arr[i];arr[i] = arr[j];arr[j] = tem;}}}}

选择排序非常好理解，但效率不是特别高，实际很少使用。

时间复杂度：O（n^2）

空间复杂度：O（1）

不稳定。

4.堆排序

堆排序是基于堆这种数据结构实现的，首先要将数组进行建大堆操作，设置bound记录末尾的位置，然后将数组的头和bound位置元素交换，此时堆中最大的元素在数组末尾，bound--，此时[0，bound]位置就是待排序位置，在进行向下调整，重复过程。

private static void heapsort(int[] arr) {//建堆creatheap(arr);int bound = arr.length-1;for (int i = 0; i < arr.length; i++) {int tem = arr[0];arr[0] = arr[bound];arr[bound] = tem;bound--;shifsort(arr,0,bound);}}private static void shifsort(int[] arr, int index, int bound) {int parent = index;int child = 2*parent + 1;while(child<bound){if(child+1<bound&&arr[child+1]>arr[child]){child+=1;}if(arr[child]>arr[parent]){int tem = arr[child];arr[child] = arr[parent];arr[parent] = tem;}else{break;}parent = child;child = 2*parent + 1;}}private static void creatheap(int[] arr) {for(int i = (arr.length-1-1)/2;i>=0;i--){shifsort(arr,i,arr.length);}}

升序要进行建大堆，降序则建小堆。

堆排序使用堆来调整数据，效率就快很多。

时间复杂度：O(n*logn)

空间复杂度：O(1)

稳定性：不稳定。

5.冒泡排序

冒泡排序非常好理解，我们取数组最后一个元素，依次与前面的数对比。

 private static void pooubsort(int[] arr) {for (int i = 0; i < arr.length; i++) {for (int j = arr.length-1; j > 0 ; j--) {if(arr[j-1] > arr[j]){int tem = arr[j-1];arr[j-1] = arr[j];arr[j] = tem;}}}}

时间复杂度：O(n^2)

空间复杂度：O（1）

稳定性：稳定。

6.快速排序

快速排序是一种非常重要的排序，这里提供Hoare法和挖坑法，Hoare法的思想是取数组最左/右边的值，将它设为基准值，先从右边的第一个值开始，找到比基准值小的值，停下，开始从最左边开始找  比基准值大的值，也停下，交换两个数，当left和right重合，交换基准值和两下标重合位置的值。此时就完成了一次寻找。接下来就是对区间[left,pos-1]和[pos+1,right]分别进行上述调整。因此快排要运用到递归。

//快速排序Hoare法private static void quicksort1(int[] arr) {quick(arr,0,arr.length-1);}private static void quick(int[] arr, int left, int right) {if(left>=right){return;}int pos = parttion(arr,left,right);quick(arr,left,pos-1);quick(arr, pos+1, right);}private static int parttion(int[] arr, int left, int right) {int k = arr[left];int i = left;while(left<right){while(left<right&&arr[right]>=k){right--;}while(left<right&&arr[left]<=k){k++;}sweap(arr,left,right);}sweap(arr,left,i);return left;}private static void sweap(int[] arr, int left, int right) {int tem = arr[left];arr[left] = arr[right];arr[right] = tem;}

挖坑法：挖坑法是先将第一个数据放到一个临时变量，形成一个坑位，从最右边开始找比基准值小的数，让它进入坑位，形成新的坑位，再从左边开始找比基准值大的数，进坑。

private static void quicksort2(int[] arr) {quick1(arr,0,arr.length-1);}private static void quick1( int []arr,int left,int right) {if(left>=right){return;}int pos = parttion1(arr,left,right);quick1(arr,left,pos-1);quick1(arr,pos+1,right);}private static int parttion1(int[] arr, int left, int right) {int key = arr[left];while(left<right){while(left<right&&arr[right]>=key){right--;}arr[left] = arr[right];while(left<right&&arr[left]<=key){left++;}arr[right] = arr[left];}arr[left] = key;return left;}

时间复杂度：O（n*logn）

空间复杂度：O（logn）

稳定性：不稳定

7.归并排序

归并排序也是通过递归（分治法）进行排序，通过将数组分组，使子序列有序，然后让子序列合并。

 private static void mergesort(int[] arr) {mergesortfunc(arr,0,arr.length-1);}private static void mergesortfunc(int [] arr,int left,int right) {if(left>=right){return;}int mid = (left+right)/2;mergesortfunc(arr,left,mid);mergesortfunc(arr,mid+1,right);merger(arr,left,mid,right);}private static void merger(int[] arr, int left, int mid, int right) {int s1 = left;int s2 = mid+1;int [] newarry = new int [right-left+1];int k = 0;while(s1<=mid&&s2<=right){if(arr[s1]>=arr[s2]){newarry[k] = arr[s2];k++;s2++;} else if (arr[s2]>arr[s1]) {newarry[k] = arr[s1];k++;s1++;}}while(s1<=mid){newarry[k++] = arr[s1++];}while(s2<=right){newarry[k++] = arr[s2++];}for (int i = 0; i < newarry.length; i++) {arr[i+left] = newarry[i];}}

归并排序的缺点在于空间复杂度为O（N），归并排序的思考更多在于磁盘外的排序，因为内存无法存储这么多数据，所以要进行外部排序，归并排序是最常用的外部排序。

时间复杂度：O(n*logn)

空间复杂度：O(N)

稳定性：稳定

8.快速排序的非递归实现

快排：首先要有一个栈，设置一个内置类，类中有left,right，将初始的范围[0,arr.length-1]入栈。

 public Range(int right, int left) {this.right = right;this.left = left;}}private static void quicksortbyLoop(int[] arr) {Stack<Range> stack = new Stack<>();stack.push(new Range(0,arr.length-1));while(!stack.isEmpty()){Range range = stack.pop();while(range.left>=range.right){continue;}int pos = parttion(arr,range.left, range.right);stack.push(new Range(range.left,pos-1));stack.push(new Range(pos+1,range.right));}}