排序算法汇总
排序算法是一个最基本的算法，经常会被问到，有些公司的面试也可能会考到，这里特意将所有的排序算法做一个总结
1. 冒泡排序
//冒泡排序,两个循环都从0开始冒泡 public int[] MaoPao(int [] array){ int len = array.length; for(int i=0;i<len-1;i++){ for(int j=0;j<len-i-1;j++){ if(array[j]>array[j+1]){ int temp = array[j]; array[j] = array[j+1]; array[j+1] = temp; } } } return array; }
最基本的一个排序算法，总是将最大的往右进行冒泡，总是比较两个相邻的元素。
平均时间复杂度O（n^2），最好时间O（n），最坏时间O（n^2），空间复杂度O（1），不需要另外开辟空间
稳定的算法，因为冒泡排序总是比较相邻的两个元素，所以是稳定的。
2. 直接插入排序
//直接插入排序 public int[] ChaRu(int [] array){ int len = array.length; for(int i=1;i<len;i++){ int temp = array[i]; int j=i-1; while(j>=0 && temp<array[j]){ //所有元素后移 array[j+1]=array[j]; j--; } array[j+1] = temp; //出入元素 } return array; }
第一个元素认为排序好的，之后的每一个元素往排好顺序的数组里插入，其他所有的元素向后移动一位
平均时间复杂度O（n^2），最好时间O（n），最坏时间O（n^2），空间复杂度O（1），不需要另外开辟空间
稳定的算法，因为出入排序每次也是相邻的比较并且后移，因此也是稳定的
3. 选择排序
//选择排序,每次找到最小的排过去就好 public int[] selectSort(int [] array){ int len = array.length; for(int i=0;i<len;i++){ int index = i; for(int j=len-1;j>i;j--){ if(array[j]<array[index]){ index=j; } } int temp = array[i]; array[i] = array[index]; array[index] = temp; } return array; }
每次循环，找到最小的一个元素，放在每一次循环的位置
平均时间复杂度O（n^2），最好时间O（n^2），无论如何都需要循环完才能确定最小元素，最坏时间O（n^2），空间复杂度O（1），不需要另外开辟空间
不稳定的排序算法，因为每次都需要选择来进行，而且是选择位置插入的。
4. 快速排序
//快速排序思想,每次第一个为base，然后小的放左边，大的放右边，递归两边 public int[] quickSort(int[] array, int left, int right){ if(left<right){ int base = array[left]; int temp; int i=left, j=right; do{ while(array[i]<base && i<right){ i++; } while(array[j]>base && j>left){ j--; } if(i<=j){ temp = array[i]; array[i] = array[j]; array[j] = temp; i++; j--; } }while(i<=j); if(left<j){ quickSort(array,left,j); } if(right>i){ quickSort(array,i,right); } } return array; }
每次，将首个left元素作为基础base，然后从left和right两边开始，小的放在左半部分，大的放在右半部分。然后递归排序左边和右边，直到left==right停止
平均时间复杂度O（nlog(n)），最好时间O（nlog(n)），最坏时间O（n^2），空间复杂度一般是O（log(n)），但是也可以到达O（1），如上述代码，是没有额外开辟空间的。
快速排序也是一个不稳定的排序算法
5. 归并排序
//归并排序 public int[] mergeSort(int[] array, int left, int right){ int mid = (left+right)/2; if(left<right){ mergeSort(array,left,mid); mergeSort(array,mid+1,right); merge(array,left,mid,right); } return array; } public void merge(int[] array, int left, int mid, int right){ int[] temp = new int[right-left+1]; int k = 0; int i=left; //左 int j=mid+1; //右 //合并 while(i<=mid && j<=right){ if(array[i]<array[j]){ temp[k]=array[i]; k++; i++; }else{ temp[k]=array[j]; i++; j++; } } //左边剩余 while(i<=mid){ temp[k]=array[i]; k++; i++; } //右边剩余 while(j<=right){ temp[k]=array[j]; k++; i++; } //复制到原数组中 for(int ii=0;ii<temp.length;ii++){ array[left+ii]=temp[ii]; } }
采用了分治法的思想，首先把一个数组不断地拆分，一直拆分到每个都只有一个元素为止，然后调用merge算法，不断地合并两个已经排好序的数组，知道最后排好顺序
平均时间复杂度O（nlog(n)），最好时间O（nlog(n)），最坏时间O（nlog(n)），空间复杂度一般是O（log(n)），归并排序是需要额外的申请空间的，每次是需要生成新的数组的。
归并排序是稳定的，因为是总是先分治到最小的数组，然后进行合并的。
6. 希尔排序
本质是分治思想和直接插入排序算法的结合
平均时间复杂度O（n^(1.3)），最好时间O（n），最坏时间O（n^(2)），空间复杂度一般是O（1）
不稳定的排序算法
7. 堆排序
本质是使用最小堆或者最大堆进行排序（二叉树），首先需要建立堆，之后每次拿出一个最小元素或者最大元素，需要重新地调整堆
平均时间复杂度O（nlog(n)），最好时间O（nlog(n)），最坏时间O（nlog(n)），空间复杂度一般是O（l）
不稳定的排序算法
8. 基数排序，基于桶排序的算法
(1) 首先根据个位数进行桶排序，然后按照0-9得到桶中的元素
(2) 根据十位数进行桶排序，然后按照0-9得到桶中的元素
(3) .......
(4) 一直达到最高位位置，得到的结果即为最终的排序结果
9. 桶排序
用空间换取时间的做法，给定一个很大范围的桶，每个元素放在一个桶中，只用一遍循环便可
时间复杂度O（n）
总结
冒泡，插入，归并和基数排序都是稳定的排序算法
选择排序，快速排序，希尔排序和堆排序都是不稳定的排序算法
