排序之前我们从时间复杂度,空间复杂度和稳定性三方面分析算法。
七大基于比较的排序
1、插入排序
1.1直接插入排序
/**
* 时间复杂度:
* 最坏情况:O(n^2) 最好情况(有序的情况): O(n)
* 越有序越快
* 空间复杂度: O(1)
* 稳定性: 稳定
* @param array
*/
public static 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;
}
}
1.2希尔排序
/**
* 时间复杂度:
* 最好情况: O(n) 最坏情况:O(n^2)
* 空间复杂度: O(1)
* 稳定性: 不稳定
* @param array
* @param gap
*/
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[] drr= {5,3,1};
for (int i = 0; i < drr.length; i++) {
shell(array,drr[i]);
}
}
2、选择排序
2.1选择排序
/**
* 时间复杂度 : O(n^2)
* 空间复杂度 :O(1)
* 稳定性:不稳定 排序
* @param array
*/
public static void selectSort(int[] array) {
for (int i = 0; i < array.length; i++) {
for (int j = i+1; j < array.length; j++) {
if (array[i] > array[j]) {
int tmp = array[j];
array[j] = array[i];
array[i] = tmp;
}
}
}
}
2.2堆排序
/**
* 时间复杂度: O(nlogn) 不管有序还是无序都是
* 空间复杂度: O(1)
* 稳定性: 不稳定
* @param array
*/
public static void heapSort(int[] array) {
createHeap(array);
int end = array.length - 1;
while (end > 0) {
int tmp = array[0];
array[0] = array[end];
array[end] = tmp;
adjustDown(array,0,end);
end--;
}
}
public static void createHeap(int[] array) {
for (int i = (array.length-1-1)/2; i >= 0; i--) {
adjustDown(array,i,array.length);
}
}
public static void adjustDown(int[] array, int root, int len) {
int parent = root;
int child = 2*parent + 1;
while (child < len) {
if(child+1 < len && array[child] < array[child+1]) {
child++;
}
if (array[child] > array[parent]) {
int tmp = array[child];
array[child] = array[parent];
array[parent] = tmp;
parent = child;
child = 2*parent+1;
}else {
break;
}
}
}
交换排序、归并排序:https://blog.csdn.net/m0_46611181/article/details/106338253