插入排序 :直接插入排序,希尔排序
选择排序 :直接选择排序,堆排
交换排序 :冒泡排序 ,快排
归并排序 :归并排序
一:直接插入排序
1. 简单介绍:时间复杂度O(N^2) , 空间复杂度O(1),稳定(一个本身稳定的排序可以是稳定->不稳定,但是不稳定/>稳定)
2. 思路:打扑克牌,往里一个个插,两层for循环,第一层 i=1,第二层 j=i-1 j>=0,(i=1 -> 从第二张牌开始比较)(j=i-1 -> 要比较的第i张牌 与已经有顺序的第 j (i-1) 张最大的牌开始比较)
3. 建议:数组趋于有序的时候使用
4. 代码解析:
5. 代码:
//直接插入排序
public static void insertSort(int[] array){
for (int i = 1; i < array.length; i++) {
int val = array[i];
int j = i-1;
for (; j >= 0; j--) {
if(val < array[j]){
array[j+1] = array[j];
}else {
break;
}
}
array[j+1] = val;
}
}
二:希尔排序
1. 简单介绍:时间复杂度O(N^1.3~N^1.5) , 空间复杂度O(1),不稳定
2. 思路:让数据分组,每组数据排序,分的组数越来越小,最后组数为1(实现 分组+直接插入)
最小增量算法——跳跃式分组(尽量让小的数据在前面,大的数据在后面,数据更趋于有序)(没有具体说过分多少组,怎么分,所以时间复杂度为一个区间),组内直接插入排序
3. 建议:数组趋于有序的时候使用
4. 代码解析:
5. 代码:
//希尔排序
private static void shell(int[] array,int gap){
for (int i = 1; i < array.length; i++) {
int val = array[i];
int j = i-gap;
for (; j >= 0; j-=gap) {
if(val < array[j]){
array[j+gap] = array[j];
}else {
break;
}
}
array[j+gap] = val;
}
}
public static void shellSort(int[] array){
int gap = array.length;
while (gap > 1){
shell(array,gap);
gap /= 2;
}
shell(array,1);
}
三 :直接选择排序
1. 简单介绍:时间复杂度O(N^2) , 空间复杂度O(1),不稳定
2. 思路:找一遍,找到最小的,与前面的数换(或者你也可以一次找两个,找一个最大的,找一个最小的(这有一个坑,代码解析标注))
3. 代码解析:
4. 代码:
//选择排序 找最小的
public static void selectSort(int[] array){
for (int i = 0; i < array.length; i++) {
int min = i;
for (int j = i+1; j < array.length; j++) {
if(array[j] < array[min]){
min = j;
}
}
swap(array,i,min);
}
}
private static void swap(int[] array,int a,int b){
int c = array[a];
array[a] =array[b];
array[b] = c;
}
//选择排序 找最小的和找最大的
public static void selectSort1(int[] array){
int left = 0;
int right = array.length-1;
while (left<right){
int min = left;
int max = left;
for (int i = left+1; i <= right; i++) {
if(array[i] < array[min]){
min = i;
}
if(array[i] > array[max]){
max = i;
}
}
swap(array,left,min);
if(max == left){
max = min;
}
swap(array,right,max);
left++;
right--;
}
}
四 :堆排
1. 简单介绍:时间复杂度O(N^logN) , 空间复杂度O(1),不稳定
2. 思路:先大根堆,然后让根(最大的数)与最后一个数据换,循环
3. 代码:
//堆排
public static void heapSort(int[] array){
creatHeap(array);
int end = array.length-1;
while(end >= 0){
swap(array,0,end);
shiftDown(array,0,end);
end--;
}
}
private static void creatHeap(int[] array){
for (int parent = (array.length-1-1)/2; parent >= 0; parent--) {
shiftDown(array,parent,array.length);
}
}
private static void shiftDown(int[] array,int parent,int end){
int child = 2*parent+1;
while (child < end){
if(child+1<end && array[child]<array[child+1]){
child++;
}
if(array[parent] < array[child]){
swap(array,parent,child);
parent = child;
child = 2*parent+1;
}else {
break;
}
}
}
五 :冒泡排序
1. 简单介绍:时间复杂度O(N^2) , 空间复杂度O(1),稳定
2. 思路:两次for循环,第一层i,第二层j (j=0;j<array.length-1-i)
3. 代码:
public static void bubbleSort(int[] array){
for (int i = 0; i < array.length-1; i++) {
boolean ret = false;
for (int j = 0; j < array.length-1-i; j++) {
if(array[j] > array[j+1]){
swap(array,j,j+1);
ret = true;
}
}
if(!ret){
break;
}
}
}