排序就是将数组按照递增或者递减的顺序排列起来
直接插入排序
当插入到第i个元素时，前边i-1个元素已经排好了序，只需要将i元素依次与前i-1个元素进行比较，找到合适位置插入进去，原来位置上的元素后移即可。
public void insertSort(int[] array){
for (int i=1;i<array.length;i++){
int tmp=array[i];
int j=i-1;
for (;j>=0;j--){
if (array[j]>tmp){
array[j+1]=array[j];
}else {
break;
}
}
array[j+1]=tmp;
}
}
时间复杂度 最坏：O(n^2) 逆序 最好：O(n) 有序 场景：当数据基本上是有序的时候，使用直接插入排序
希尔排序
先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
public static void shell(int[] array,int gap){
for (int i=gap;i<array.length;i++){
int tmp=array[i];
int j=i-gap;
for (;j>=0;j-=gap){
if (array[j]>tmp){
array[j+gap]=array[j];
}else {
break;
}
}
array[j+gap]=tmp;
}
}
public static void shellSort(int[] array){
int gap=array.length;
while (gap>1){
shell(array,gap);
gap=gap/2;
}
shell(array,1);
}选择排序
第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零
public static void selectSort(int[] array){
for (int i = 0; i < array.length-1; i++) {
int minIndex=i;
for (int j = i+1; j < array.length; j++) {
if (array[minIndex]>array[j]){
minIndex=j;
}
}
swap(array,i,minIndex);
}
}
public static void swap(int[] array,int i,int j){
int tmp=array[i];
array[i]=array[j];
array[j]=tmp;
}
public static void selectSort2(int[] array){
int left=0;
int right=array.length-1;
while (left<right){
int minIndex=left;
int maxIndex=left;
for (int i = left+1; i <= right ; i++) {
if (array[i]<array[minIndex]){
minIndex=i;
}
if (array[i]>array[maxIndex]){
maxIndex=i;
}
}
swap(array,left,minIndex);
if (left==maxIndex){
maxIndex=minIndex;
}
swap(array,right,maxIndex);
left++;
right--;
}
}
时间复杂度:O(n^2) 空间复杂度：O(1)
堆排序
以升序排序为例，先建立一个大根堆，每次跟堆顶元素进行交换，直到交换完成。
private static void createBigHeap(int[] array){
for (int parent = (array.length-2)/2; parent >= 0; parent--) {
shiftDown(array,parent,array.length);
}
}
public static void heapSort(int[] array){
createBigHeap(array);
int end=array.length-1;
while (end>=0){
swap(array,0,end);
shiftDown(array,0,end);
end--;
}
}
private static void shiftDown(int[] array,int parent,int len){
int child=2*parent+1;
while (child<len){
if (child+1<len && array[child]<array[child+1]){
child++;
}
if (array[child]>array[parent]){
swap(array,child,parent);
parent=child;
child=2*parent+1;
}else {
break;
}
}
}
时间复杂度：O(n*logn) 空间复杂度:O(1)
冒泡排序
从第一位开始进行相邻的两个数的比较，将较大的数放后面，比较完毕之后向后挪一位继续比较下面两个相邻的两个数大小关系，重复此步骤，直到最后一个还没归位的数。
public static void bubbleSort(int[] array){
for (int i = 0; i < array.length-1; i++) {
boolean flg=false;
for (int j = 0; j < array.length-1-i; j++) {
if (array[j]>array[j+1]){
swap(array,j,j+1);
flg=true;
}
}
if (!flg){
break;
}
}
}
冒泡排序 时间复杂度:O(N^2)* 针对优化后的代码，时间复杂度在有序的情况下: O(n) 空间复杂度:0(1)
快速排序
Hoare法
public static int partition(int[] array,int start,int end){
int i=start;
int key=array[start];
while (start<end){
while (start<end && array[end]>=key){
end--;
}
while (start<end && array[start]<=key){
start++;
}
swap(array,start,end);
}
swap(array,start,i);
return start;
}
public static void quick(int[] array,int left,int right){
if (left>=right){
return;
}
int pivot=partition(array,left,right);
quick(array,left,pivot-1);
quick(array,pivot+1,right);
}
public static void quickSort(int[] array){
quick(array,0,array.length-1);
}挖坑法
public static int partition(int[] array,int start,int end){
int key=array[start];
while (start<end){
while (start<end && array[end]>=key){
end--;
}
array[start]=array[end];
while (start<end && array[start]<=key){
start++;
}
array[end]=array[start];
}
array[start]=key;
return start;
}前后指针法
public static int partition(int[] array,int start,int end){
int prev=start;
int cur=start+1;
while (cur<=end){
if (array[cur]<array[start] && array[++prev]!=array[cur]){
swap(array,cur,prev);
}
cur++;
}
swap(array,prev,start);
return prev;
}
时间复杂度：O(n*logn) 【理想情况下】 空间复杂度：O(logn)
归并排序
递归法
public static void mergeFunc(int[] array,int left,int right){
if (left>=right){
return;
}
int mid=(left+right)/2;
mergeFunc(array,left,mid);
mergeFunc(array,mid+1,right);
merge(array,left,right,mid);
}
private static void merge(int[] array,int start,int end,int midIndex){
int[] tmpArr=new int[end-start+1];
int k=0;
int s1=start;
int s2=midIndex+1;
while (s1<=midIndex && s2<=end){
if (array[s1]<=array[s2]){
tmpArr[k++]=array[s1++];
}else {
tmpArr[k++]=array[s2++];
}
}
while (s1<=midIndex){
tmpArr[k++]=array[s1++];
}
while (s2<=end){
tmpArr[k++]=array[s2++];
}
for (int i = 0; i < k; i++) {
array[i+start]=tmpArr[i];
}
}
public static void mergeSort(int[] array){
mergeFunc(array,0,array.length-1);
}
时间复杂度：O（n*logn） 空间复杂度：O(n)
非递归法
public static void mergeSort(int[] array){
int gap=1;
while (gap<array.length){
for (int i = 0; i < array.length; i+=2*gap) {
int s1=i;
int e1=s1+gap-1;
if (e1>=array.length){
e1=array.length-1;
}
int e2=e1+gap;
if (e2>=array.length){
e2=array.length-1;
}
merge(array,s1,e2,e1);
}
gap*=2;
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
