我总结了常见的基于比较的排序,通俗易懂(一)

本文已参与「掘力星计划」,赢取创作大礼包,挑战创作激励金。 @[TOC]

)

@TOC

一、常见排序总览

在这里插入图片描述 接下来将分两次讲解上图的7中排序算法,包含他们的实现思路,时空间复杂度,稳定性,和具体代码。


二、排序的稳定性

修饰一个排序的属性通常有它的时间复杂度、空间复杂度,这里在介绍一下排序的稳定性。 在这里插入图片描述 1:最上面的一组数,有两个5,我们对他们做一些记号,前面的叫5a,后面的叫5b,如果在进行排序后前面的5a,仍然处于5b之前,那么我们就说这个排序是稳定的,反之就是不稳定的。 2:一个稳定的排序,可以实现为不稳定的排序,一个本身就不稳定的排序,你就不可能实现为有序的排序。


三、直接插入排序

3.1实现思路:

直接插入排序 是一种最简单的排序方法,把整个区间分成有序的和无序的两组,每次在无序的区间选第一个合理的插入到有序的区间中。

3.2 动态图

在这里插入图片描述 在这里插入图片描述

以静态图为例,3作为有序组的第一个,从无序组的44开始,和3比较,如果比3大那就放到3后面,如果小于3就放到3前面,这里是比3大的,所以不动,这样有序的组就变成了3、44,无序组的第一个是38,拿38和有序组比较,插入到适当的位置,这里它比3大,而比44小,就直接把它放到3和44之间。后面的数以此类推。知道无序组为0;

3.3:代码实现

public static void insertSort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int tmp = array[i];
            int j = i - 1;
//这里不写for(j)的第一个参数是为了array[j+1]=tmp能不超出作用域
            for (; j >= 0; j--) {
                //一开始i=1,j=0;
                if (array[j] > tmp) {
//比较第一个和第二个元素的大小,大了就把第二个元素换成第一个
                    array[j + 1] = array[j];
                }
//如果没有第二个大直接break;for循环外面的array[j+1]=tmp会换回来
                else {
                    break;
                }
            }
// i走过去的地方一定是有序的
            array[j + 1] = tmp;
        }
复制代码

3.4时空间复杂度

直接插入排序

  • 时间复杂度: 最好:O(n) 最坏:O(n^2) 空间复杂度:O(1)

  • 稳定性:稳定

四、希尔排序

4.1与直接插入排序的联系

希尔排序是直接插入的进化版。它的比较速度和交换速度都得到了很大的提升。下表是同一份数据两种排序的比较次数和交换次数。 在这里插入图片描述

4.2:实现思路

1:分组,将要排序的数组按一定的间隔分组,间隔的大小没有固定的大小,一般都是数组长度的一半。 2:在分好的组中进行直接插入排序。 3:在进行分组,这次的间隔是上次间隔的一半。 4:重复以上步骤,直到间隔为1,也就是所以数据都有序了。

4.3:代码实现

 * 用shell来进行重复操作 shell就是直接插入排序
 * @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;
    }
}
/**
 * 希尔排序就是把直接插入排序里j=i-1的一换成gap在一直分组直到gap==1
 * @param array
 */

 public static void shellSort(int []array){
    //处理gap  间隔
      int gap= array.length;
      while(gap>1){
          gap=gap/3+1;// +1是为了保证  保证最后一个序列是1 除几都可以
          shell(array,gap);

      }
  }


复制代码

4.4:时空间复杂度

/**

  • 希尔排序
  • 时间复杂度:不好算!
  • 当作 n^1.3 --- n^1.5之间
  • 空间复杂度:O(1)
  • @param array 排序的数组
  • @param gap 每组的间隔 ->组数

*/

五、选择排序

5.1:实现思路

每一次从无序区间选出最大(或最小)的一个元素,存放在无序区间的最后(或最前),直到全部待排序的数据元素排完 。

5.2:动态图

在这里插入图片描述

5.3:代码实现

public static void selectSort(int[] array)
for (int i = 0; i < array.length - 1; i
// 无序区间: [0, array.length - i)
// 有序区间: [array.length - i, array
int max = 0;
for (int j = 1; j < array.length -
if (array[j] > array[max]) {
max = j;
}
}
int t = array[max];
array[max] = array[array.length - i-1];
array[array.length - i - 1] = t;
}
}

复制代码

5.4:时空间复杂度

时间复杂度:O(n^2) 空间复杂度:O(1) 稳定性:不稳定

六、冒泡排序

6.1:

在无序的区间里相邻的两个数互相比较,将较大的数放到后面。持续这个过程,直到数组有序

6.2:代码实现

public static void bubbleSort(int[] array) {
for (int i = 0; i < array.length - 1; i++)
boolean isSorted = true;
for (int j = 0; j < array.length - i -
// 相等不交换,保证稳定性
if (array[j] > array[j + 1]) {
swap(array, j, j + 1);
isSorted = false;
}
}
if (isSorted) {
break;
}
}
}

复制代码

6.3:时空间复杂度

时间复杂度: 平均O(n^2) 最坏O(n^2) 空间复杂度: O(1) 稳定性:稳定

结尾

我们这次介绍了四种排序算法,剩下我三种我放到第二篇文章里,今天的你掌握了吗? 在这里插入图片描述

猜你喜欢

转载自juejin.im/post/7019501772204933128

相关文章