常见的排序算法总结

1.插入排序

一般分两种 

直接插入排序和希尔排序

（1）直接插入排序：

（1）对于一个有序的数组插入元素i，先把i和数组[end]比较，如果大于，直接加入到最后，如果小于

则于数组[end-1]进行比较，类比同理，知道找到大于的end的值。

 (2)对于一个没有或者说不知道有没有排序的数组，我们需要怎么办？

首先我们可以把这个数组看成很多的小的。

代码解析：用intsertValue来记录要插入的值，两个for，第一个for来遍历一遍数组，第二个for来做判断，判断要插入的数是不是比前一个要小，如果小

就需要把插入的数向前移动，即把前面的数赋值给右边，arr[j+1] = arr[j]，一直到比插入的数要大的时候停止，并把缺失的insertVallue值赋值给arr[j+1]

    public static int[] insertSort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            int insertValue = arr[i];
            int j = i - 1;
            //从右向左比较元素的同时，进行元素复制
            for(; j >=0 && insertValue < arr[j]; j--){//如果右边的比要插入的值小，把左边的赋值给右边
                arr[j+1] = arr[j];
            }
            //insertValue的值插入适当位置
            arr[j+1] = insertValue;
        }
        return arr;
    }}

public static void insertSort(int[] arr){
  //第一轮
    int temp=0;

for (int i=1;i< arr.length;i++){
    for (int j=i-1;j>=0;j=j-1){
        if (arr[j]>arr[j+1]){
            temp=arr[j];
            arr[j]=arr[j+1];
            arr[j+1]=temp;
        }
    }

（2）希尔排序：

简单来说就是先对数组进行分组，对个个分过组的数组进行插入排序

public static void shell(int[] arr){
  //第一轮
    int temp=0;
      for (int i=5;i< arr.length;i++){
        for (int j=i-5;j>=0;j=j-5){
            if (arr[j]>arr[j+5]){
                temp=arr[j];
                arr[j]=arr[j+5];
                arr[j+5]=temp;
            }
        }
    }
    System.out.println("排序后的数据：");
    System.out.println(Arrays.toString(arr));

    //第二轮
    for (int i=2;i< arr.length;i++){
        for (int j=i-2;j>=0;j=j-2){
            if (arr[j]>arr[j+2]){
                temp=arr[j];
                arr[j]=arr[j+2];
                arr[j+2]=temp;
            }
        }
    }
    System.out.println("排序后的数据：");
    System.out.println(Arrays.toString(arr));

    //第三轮
    for (int i=1;i< arr.length;i++){
        for (int j=i-1;j>=0;j=j-1){
            if (arr[j]>arr[j+1]){
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
    System.out.println("排序后的数据：");
    System.out.println(Arrays.toString(arr));
}

2.交换排序

一般分两种 冒泡排序和快速排序

（1）冒泡排序

冒泡排序,双循环，两两交换，把最大的放后面，然后是第二大的

public static int[] bubbleSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return arr;
    }
    for (int i = 0; i < arr.length - 1; i++) {
        boolean flag  = true;//有序标记，每一轮的初始是true
        for (int j = 0; j < arr.length -i - 1; j++) {
            if (arr[j + 1] < arr[j]) {
                flag  = false;//有元素交换，所以不是有序，标记变为false
                int t = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = t;
            }
        }
        //一趟下来是否发生位置交换，如果没有交换直接跳出大循环
        if(flag )
            break;
    }
    return arr;
}

（2）快速排序

双指针，设置两个参数，left和right，分别从左到右边寻找第一个大于a[0]（数组的第一个元素）的值，从右到左寻找第一个
小于i的值，并进行交换位置。当left和right的值不相等的时候，继续寻找，当相等的时候，结束循环，并把a[0]的值和a[i]替换。
在分别把i左边的数组和右边的数组快速排序（递归）
注意：因为以左边第一个为基点，所以要从右边开始。

 private static void quickSorting(int[] a, int left, int right) {
    if ( left > right ) {
        return;
    }
    int i = left;
    int j = right;
    int base = a[left];
    while (i != j) {
        while ( a[j]>= base&&i<j) {
            j--;
        }
        while ( a[i] <= base&&i<j) {
            i++;
        }
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
    a[left] = a[i];
    a[i] = base;
        quickSorting(a,left,i-1);
        quickSorting(a,i+1,right);
}

3.选择排序

一般分为直接选择排序和堆排序

（1）直接选择排序

每次从待排序数组中，选出最小的或者最大的一个元素，放到已经排序的末尾，重复直到完成

public static void selectSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        int min = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[min]) {
                min = j;
            }
        }
        int temp = arr[min];
        arr[min] = arr[i];
        arr[i] = temp;
    }
}

（2）堆排序

大根堆，小根堆

3.归并排序