我总结了常见的基于比较的排序，通俗易懂（一）

)

一、常见排序总览

接下来将分两次讲解上图的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）
稳定性：稳定

结尾

我们这次介绍了四种排序算法，剩下我三种我放到第二篇文章里，今天的你掌握了吗？