Java中的八个主要排序

Java中的八大排序

一.冒泡排序
冒泡排序
思想：
将相邻的两个数据依次进行比较，如果前一位数比后一位数大，那么交换位置，每一趟的排序就可以确定一个最大的数（即将最大的数往下沉），重复进行比较（确定了的数除外）直到所有元素比较完成，说明排序完成
假设有以下数组：

int[] array = {
  14,16,7,28,99,54,1,10};

图例：

如图所示，相邻数据依次进行比较，最大数99就已经确定
然后除去99，重复以上的比较，直到所有都比较完成
此时我们需要两个for循环，外循环控制该数组排序的趟数
内循环控制每一趟排序的次数
代码：

import java.util.Arrays;

/**
 * 冒泡排序
 * 描述：大的数往下沉
 * 方法：两两依次进行比较
 * @author wangyu
 * @data 2018年5月28日
 */
public class TestDemo1 {
   
    public static void bubbleSort(int[] array) {
        int tmp = 0;
        //外部循环控制比较的趟数（有几个数比较几趟）
        for(int i = 0;i < array.length;i++) {
            //内部循环控制每一趟排序的次数（每一趟就确定一个数，这个数就不参与下次排序）
            for(int j = 0;j < array.length - 1 -i;j++) {
                //如果前一位数大于后一位数，则交换位置
                if(array[ j ] > array[ j + 1 ]) {
                    //进行交换
                    tmp = array[ j ];
                    array[ j ] = array[ j + 1 ];
                    array[ j + 1 ] = tmp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {
  14,16,7,28,99,54,1,10};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
}

那么冒泡排序是否稳定呢？
理所当然是稳定的，因为它是相邻的两个元素依次进行比较，从未有跳跃的比较，所以肯定是稳定的
它的时间复杂度是多少呢？
是O（n^2）

二.直接插入排序
思想：像扑克牌一样，接上来的第一张是唯一的一张，也可认为是有序的，后面接上来的牌对前面有序的进行比较，插入到适当的位置
方法：前面的数据有序，后面的待排数据与前面有序的数据依次进行比较，插入到合适的位置，直到所有数据排列完毕
假设有数组如下：

int[] array = {
  13,52,36,77,55,1,22,3,7};

图例：

i为1号下标，且j为i-1的下标，先将i位置的数存储在tmp中间变量中，如果i位置的数的值大于j位置的数的值，则将现在j位置的值赋值给i所在的值，执行j–；继续让前面有序的值跟tmp（也就是原本无序中的值进行比较）如果大于则和以上执行相同步骤，小于的话则跳出循环，并将tmp的值赋值给所空位置，完成排序
第一趟比较：{ 13,52,36,77,55,1,22,3,7 }
第二趟比较：{ 13,36,52,77,55,1,22,3,7}
第三趟比较：{ 13,36,52,77,55,1,22,3,7}
第四趟比较：{ 13,36,52,55,77,1,22,3,7}
第五趟比较：{ 1,13,36,52,55,77,22,3,7}
第六趟比较：{ 1,13,22,36,52,55,77,3,7}
第七趟比较：{ 1,3,13,22,36,52,55,77,7}
第八趟比较：{ 1,3,7,13,22,35,52,55,77}
粗体为确定的有序序列；
代码实现：

import java.util.Arrays;

/**
 * 直接插入排序
 * 描述：小的数往上冒
 * 方法：从后面的待排序跟前面有序的进行比较
 * @author wangyu
 * @data 2018年5月28日
 */
public class TestDemo2 {
   
    public static void insertSort(int[] array) {
        int j;
        //定义临时变量将此时的array[i]的值保存，即让该位置空出
        int tmp = 0;
        //i指向的是待排序的数
        for(int i = 1; i < array.length; i++) {
            tmp = array[ i ];
            //j是有序数列的最后一个数，往前依次进行比较
            for(j = i - 1; j >= 0; j--) {
                if(array[ j ] > tmp) {
                    array[j + 1] = array[j];
                }else {
                    break;
                }
            }
            array[ j + 1 ] = tmp;
        }
    }
    public static void main(String[] args) {
        int[] array = {
  13,52,36,77,55,1,22,3,7};
        insertSort(array);
        System.out.println(Arrays.toString(array));
    }
}

稳定性：直接插入排序没有跳跃排序，所以其是稳定的
时间复杂度：O（n^2）

三.选择插入排序
思想：将指定排序位置的数据（起始位置）与其他数组数据进行比较，如果满足条件（待比较的数据小于起始位置的数据）就交换位置
每一趟从未排序的数据元素中取出最小的一个元素，顺序地放在已经排好序的数列的最后，直到全部待排序的元素排序完毕
也就是从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处
也就是假设有这么一个数组

int[] array = {