排序-介绍，代码思路，使用建议，代码实现-1

插入排序 ：直接插入排序，希尔排序

选择排序 ：直接选择排序，堆排

交换排序 ：冒泡排序       ，快排

归并排序 ：归并排序

一：直接插入排序

1. 简单介绍：时间复杂度O(N^2) , 空间复杂度O(1)，稳定（一个本身稳定的排序可以是稳定->不稳定，但是不稳定/>稳定）

2. 思路：打扑克牌，往里一个个插，两层for循环，第一层 i=1，第二层 j=i-1 j>=0，（i=1 -> 从第二张牌开始比较）（j=i-1 -> 要比较的第i张牌 与已经有顺序的第 j (i-1) 张最大的牌开始比较)

3. 建议：数组趋于有序的时候使用

4. 代码解析:

5. 代码：

//直接插入排序
    public static void insertSort(int[] array){
        for (int i = 1; i < array.length; i++) {
            int val = array[i];
            int j = i-1;
            for (; j >= 0; j--) {
                if(val < array[j]){
                    array[j+1] = array[j];
                }else {
                    break;
                }
            }
            array[j+1] = val;
        }
    }

二：希尔排序

1. 简单介绍：时间复杂度O(N^1.3~N^1.5) , 空间复杂度O(1)，不稳定

2. 思路：让数据分组，每组数据排序，分的组数越来越小，最后组数为1（实现 分组+直接插入）

               最小增量算法——跳跃式分组(尽量让小的数据在前面，大的数据在后面，数据更趋于有序)（没有具体说过分多少组,怎么分,所以时间复杂度为一个区间），组内直接插入排序

3. 建议：数组趋于有序的时候使用

4. 代码解析:

 5. 代码：

//希尔排序
    private static void shell(int[] array,int gap){
        for (int i = 1; i < array.length; i++) {
            int val = array[i];
            int j = i-gap;
            for (; j >= 0; j-=gap) {
                if(val < array[j]){
                    array[j+gap] = array[j];
                }else {
                    break;
                }
            }
            array[j+gap] = val;
        }
    }
    public static void shellSort(int[] array){
        int gap = array.length;
        while (gap > 1){
            shell(array,gap);
            gap /= 2;
        }
        shell(array,1);
    }

三 ：直接选择排序

1. 简单介绍：时间复杂度O(N^2) , 空间复杂度O(1)，不稳定

2. 思路：找一遍，找到最小的，与前面的数换（或者你也可以一次找两个，找一个最大的，找一个最小的（这有一个坑，代码解析标注））

3. 代码解析：

 4. 代码：

//选择排序 找最小的
    public static void selectSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            int min = i;
            for (int j = i+1; j < array.length; j++) {
                if(array[j] < array[min]){
                    min = j;
                }
            }
            swap(array,i,min);
        }
 
    }
    private static void swap(int[] array,int a,int b){
        int c = array[a];
        array[a] =array[b];
        array[b] = c;
    }
    //选择排序 找最小的和找最大的
    public static void selectSort1(int[] array){
        int left = 0;
        int right = array.length-1;
        while (left
            int min = left;
            int max = left;
            for (int i = left+1; i <= right; i++) {
                if(array[i] < array[min]){
                    min = i;
                }
                if(array[i] > array[max]){
                    max = i;
                }
            }
            swap(array,left,min);
            if(max == left){
                max = min;
            }
            swap(array,right,max);
            left++;
            right--;
        }
 
    }

四 ：堆排

1. 简单介绍：时间复杂度O(N^logN) , 空间复杂度O(1)，不稳定

2. 思路：先大根堆，然后让根(最大的数)与最后一个数据换，循环

3. 代码：

 //堆排
    public static void heapSort(int[] array){
        creatHeap(array);
        int end = array.length-1;
        while(end >= 0){
            swap(array,0,end);
            shiftDown(array,0,end);
            end--;
        }
    }
    private static void creatHeap(int[] array){
        for (int parent = (array.length-1-1)/2; parent >= 0; parent--) {
            shiftDown(array,parent,array.length);
        }
    }
    private static void shiftDown(int[] array,int parent,int end){
        int child = 2*parent+1;
        while (child < end){
            if(child+1array[child]<array[child+1]){
                child++;
            }
            if(array[parent] < array[child]){
                swap(array,parent,child);
                parent = child;
                child = 2*parent+1;
            }else {
                break;
            }
        }
    }

五 ：冒泡排序

1. 简单介绍：时间复杂度O(N^2) , 空间复杂度O(1)，稳定

2. 思路：两次for循环，第一层i，第二层j （j=0;j）

public static void bubbleSort(int[] array){
        for (int i = 0; i < array.length-1; i++) {
            boolean ret = false;
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] > array[j+1]){
                    swap(array,j,j+1);
                    ret = true;
                }
            }
            if(!ret){
                break;
            }
        }
    }