1,插入排序
选择一个temp,然后与前面已经排序好的数字进行比较(默认第一个数字是排序好的),然后如果小于,就继续往前比较,直到比比较的数字大,就插入。
public static int[] InserSort(int[] array){
for (int i = 0; i < array.length; i++) {
int temp=array[i];
int k;
for ( k = i-1; k >= 0; k--) {
if(array[k]>temp){
array[k+1]=array[k];
}else{
break;
}
}
array[k+1]=temp;
}
return array;
}
平均时间复杂度为O(n^2),最好的情况是O(n),最坏的情况为O(n^2),空间复杂度为O(1),稳定性:稳定。
2,选择排序
选择排序就是不断找出最小值把他放前面,实现很简单。
public static int[] 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 temp=array[i];
array[i]=array[j];
array[j]=temp;
}
}
}
return array;
}
时间复杂度:O(n^2),空间复杂度O(1),但是我们可以每次查找最大值和最小值,这样就可以加快一半的时间。
3,冒泡排序
将数字两两比较,然后将大的交换到前面,然后一遍一遍的循环,最终就可以完成排序。
public static int[] BubbleSort(int[] array){
for (int i = 0; i < array.length-1; i++) {
for (int j = 0; j < array.length-1; j++) {
if(array[j]>array[j+1]){
int temp=array[j+1];
array[j+1]=array[j];
array[j]=temp;
}
}
}
return array;
}
时间复杂度:最好情况:O(n),最坏情况O(n^2),空间复杂度O(1)。
4,快速排序
对于快速排序,就是使用双指针,选择一个基准值,将每个数字与基准比较,比基准大的放在基准右边,比基准小的放在基准的左边,将数组拆分为两部分,然后不断地拆分,最终完成排序。基本思想就是分治的思想,将大问题拆分为小问题,小问题再拆分。
public static void Quicksort(int[] array, int start, int end){
if(start>=end){
return;
}
int left = start;
int right = end;
int base = array[start];
while(left != right){
while(array[right] >= base && left<right){
right--;
}
while(array[left] <= base && left<right){
left++;
}
int temp=array[left];
array[left]=array[right];
array[right]=temp;
}
array[start]=array[left];
array[left]=base;
//左,右
Quicksort(array,start,left-1);
Quicksort(array,left+1,end);
}
时间复杂度:最好O(nlog(n)),最坏情况:O(n^2),空间复杂度:O(nlog(n)),稳定性:不稳定。快速排序再最坏的情况下可以优化,即优化基准值,方法:三数取中法。
5,归并排序
算法(手写归并排序)_不会Java的MING的博客-CSDN博客
6,堆排序
堆排序是利用堆这种数据结构设计的算法,堆是具有以下性质的完全二叉树:每个结点的值都大于或者等于左右孩子节点值,为大顶堆,反之是小顶堆。
将待排序的序列构造出大顶堆,此时,这个序列的最大值就是root,然后将最大值放到末尾,此时末尾就是最大值,然后将剩余的元素重新构造为一个堆,然后反复执行,最终得到有序序列。
//堆排序
public static void HeapSor(int[] array){
//首先构造大顶堆
for (int i = array.length/2-1; i >=0 ; i--) {
adjustHeap(array,i,array.length);
}
//调整堆结构
for (int i = array.length-1; i > 0; i--) {
swap(array,0,i);
adjustHeap(array,0,i);
}
}
//调整大顶堆
private static void adjustHeap(int[] array, int i, int length) {
while(2*i+1<length){
int j=i*2+1;
if(j+1<length && array[j]<array[j+1]){
j++;
}
if(array[j]<array[i])
break;
swap(array,i,j);
i=j;
}
}
//交换
private static void swap(int[] array, int a, int b) {
int temp=array[a];
array[a]=array[b];
array[b]=temp;
}
堆排序的时间复杂度为O(nlogn)空间复杂度为O(1) 稳定性:不稳定
7,希尔排序
该排序是为了优化插入排序,将一组数据分为n组,之后在进行组内交换。
//希尔排序
public static void ShellSort(int[] array){
int gap=1;
while(gap<array.length/3)
gap=3*gap+1;
while(gap>=1){
for (int i = gap; i <array.length ; i++) {
for (int j = i; j >= gap && array[j]<array[j-gap];j-=gap) {
swap(array, j, j - gap);
}
}
gap=gap/3;
}
}
private static void swap(int[] array, int a, int b) {
array[a] = array[a]+array[b];
array[b] = array[a]-array[b];
array[a] = array[a]-array[b];
}
希尔排序的平均时间复杂度为O(n^1.3~1.5),最好情况是O(n),最坏情况是O(n^2) 。空间复杂度是O(1),稳定性: 不稳定。